Messages

Send a request

Point the Anthropic SDK at https://api.llm.buzz/api, without /v1: the SDK adds /v1/messages itself. max_tokens is required. Claude Code takes the same base URL: Authentication.

from anthropic import Anthropic
import os

client = Anthropic(
    base_url="https://api.llm.buzz/api",
    api_key=os.environ["LLM_BUZZ_KEY"],
)
message = client.messages.create(
    model="anthropic/claude-sonnet-5.5",
    max_tokens=2048,
    system="You answer in one short sentence.",
    messages=[{"role": "user", "content": "Why do HTTP clients retry with backoff?"}],
)
for block in message.content:
    if block.type == "text":
        print(block.text)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  baseURL: "https://api.llm.buzz/api",
  apiKey: process.env.LLM_BUZZ_KEY,
});
const message = await client.messages.create({
  model: "anthropic/claude-sonnet-5.5",
  max_tokens: 2048,
  system: "You answer in one short sentence.",
  messages: [{ role: "user", content: "Why do HTTP clients retry with backoff?" }],
});
for (const block of message.content) {
  if (block.type === "text") console.log(block.text);
}

curl https://api.llm.buzz/api/v1/messages \
  -H "x-api-key: $LLM_BUZZ_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5.5",
    "max_tokens": 2048,
    "system": "You answer in one short sentence.",
    "messages": [{"role": "user", "content": "Why do HTTP clients retry with backoff?"}]
  }'

The loop reads the text blocks because a model that thinks puts a thinking block first. The fields llm.buzz adds to Anthropic's request, provider, gateway and session_id, go through extra_body in the SDKs, for example extra_body={"provider": {"data_collection": "deny"}}. The model name, and the models you can call, come from GET https://api.llm.buzz/api/v1/models (Choosing an API).

Request fields

A field Messages does not know, such as seed, is dropped, and the body's x-sgr-ignored-parameters names it, on message_start and on the final message. A field llm.buzz deliberately refuses is a 400 before any provider is called, in Anthropic's invalid_request_error.

Thinking

You can ask for thinking three ways, and llm.buzz translates each into the terms of the provider that serves the request.

• thinking takes Anthropic's forms: adaptive, disabled, and enabled with a budget_tokens. Every Claude model llm.buzz lists today is in an adaptive-only family, and those families refuse a budget. A thinking object with budget_tokens answers 400 invalid_request_error naming thinking.budget_tokens, and a bare {"type": "enabled"} runs adaptive thinking, named thinking.type->adaptive in x-sgr-ignored-parameters. Use adaptive, and set the depth with output_config.effort.
• A model from another provider gets thinking translated. A bare enabled or adaptive reasons at the model's default effort, and at medium when the model names none. A budget_tokens goes to providers that have a budget field, and is refused before any provider is called where none has one.
• For a Claude model that takes a budget, which none on llm.buzz does today, a bare {"type": "enabled"} takes half of the output limit as its budget, and budget_tokens must be below max_tokens (at or above it is a 400 naming thinking.budget_tokens).
• reasoning, OpenRouter's object, is accepted too: effort or max_tokens, plus enabled and exclude. Its fields must agree: an effort tier or a budget beside enabled: false, or effort: "none" beside enabled: true, is a 400 invalid_request_error whose message ends (param: reasoning.enabled).
• output_config.effort is a reasoning control that every provider receives in its own terms. A route that cannot serve the effort refuses the request and names output_config.effort.

Thinking off is not always available. thinking: {"type": "disabled"} is refused before any provider is called for Claude Opus 5.5, Sonnet 5.5, Fable 5 and Fable 5.1, at every effort level. Leave thinking out, or use adaptive and choose an effort. Sonnet 5.5 takes {"type": "between_tools"} in place of disabled: it turns off up-front thinking, works with an output_config.effort of low, medium or high, and takes no other thinking field. reasoning.exclude: true keeps reasoning text out of the answer while the model still thinks and bills for it, but Anthropic's own signed thinking blocks stay, because replaying them depends on them.

A conversation can move between models. Claude's signed thinking blocks go back to Claude. Another provider gets the turn without them, and x-sgr-ignored-parameters names it messages.thinking->dropped(unsupported_by_provider).

A max_tokens under 1,024, with no thinking or effort setting of your own, on a model whose providers all reason by default and offer a none effort, is sent at effort none, named reasoning_effort->none(max_tokens_headroom). The reply is text, not thinking cut off at the ceiling. Reasoning has the rest.

Headers

You send:

Messages has no Idempotency-Key: see Retries. Every answer carries:

An answer that asks you to wait, a 429 and some 402 and 503 answers, carries Retry-After: wait that many seconds before you retry.

Count tokens

POST https://api.llm.buzz/api/v1/messages/count_tokens takes a Messages request body and answers how many input tokens it comes to. It needs no max_tokens; one is accepted and changes nothing. gateway is refused with a 400 invalid_request_error naming it.

curl https://api.llm.buzz/api/v1/messages/count_tokens \
  -H "x-api-key: $LLM_BUZZ_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-sonnet-5.5",
    "messages": [{"role": "user", "content": "Why do HTTP clients retry with backoff?"}]
  }'

The answer is {"input_tokens": N}. The count is llm.buzz's own estimate, because no provider counts tokens for it, and the body says so with input_tokens->estimated(gateway_tokenizer) in x-sgr-ignored-parameters. It is free, and a key whose spending limit is reached can still call it. It answers the same 404 as a Messages call for a model none of whose providers meets your data policy (Models and routing).

The answer

A non-streamed answer is Anthropic's message object. llm.buzz adds or fixes these parts:

• content holds text blocks, tool_use blocks, and the model's reasoning as thinking blocks: Anthropic's own, signed, when Anthropic serves the request, and one unsigned block with the readable reasoning from other providers. A tool turn of some models also ends with a redacted_thinking block. Send every thinking block back unchanged with the assistant turn. reasoning.exclude withholds the unsigned one.
• stop_reason is end_turn for a finished answer, tool_use when the model called tools, max_tokens when the output ceiling cut it, and stop_sequence when a stop sequence you sent matched, with the matched string in stop_sequence.
• usage is described below.
• x-sgr-ignored-parameters is a key in the body, not a header. It lists every field llm.buzz dropped and every value it changed, with the reason, such as temperature->dropped(unsupported_by_provider). It is on the final message and on message_start. Check it when a setting seems to have no effect.

Stream

Set stream: true and the answer arrives as Anthropic's events.

Closing a Messages stream stops the request, and the prompt and the output produced up to then are billed. While the model is silent, comment lines beginning with : keep the connection active; clients skip them. Streaming covers the event shapes of all three text APIs.

Usage and cost

The four counts are always present, 0 when the provider reported none. The usage of message_start is a figure taken before the provider answers: Anthropic's own start counts when Anthropic serves the request, and llm.buzz's estimate of the prompt for any other provider, with output_tokens of 1 and cache counts of 0. message_delta carries the final counts, which replace it.

The Anthropic Python SDK does not copy cost into the message it assembles from a stream. Read it from the message_delta event, or from the answer of a request that does not stream:

stream = client.messages.create(
    model="anthropic/claude-sonnet-5.5",
    max_tokens=2048,
    messages=[{"role": "user", "content": "Why do HTTP clients retry with backoff?"}],
    stream=True,
)
for event in stream:
    if event.type == "message_delta":
        print(event.usage.model_extra.get("cost"))

message.usage.model_extra["cost"] is the same value on a non-streamed message. cost is a JSON number that includes any billed tool-search rounds, so it can exceed the counts times the listed prices. A failed attempt that another provider replaced adds 0. It is left out when any part of the cost is unknown; a model with no price reports 0. Usage and limits covers the rest, and Prompt caching the cache fields.

Retries

The Messages API defines no idempotency header, so llm.buzz applies none: a retry is a separate request that runs, and bills, again.

• The Anthropic SDK also retries failed requests on its own, and each retry is a separate request. Set max_retries=0 when your application must bound the work of one operation.
• A provider that fails or times out before output reaches you is replaced by the next one, and the failed attempt costs nothing; a provider's own 400 is not tried on another provider. Once output has reached you, the request stays on the provider that sent it.

Retries and idempotency explains the rest.

Errors

Errors come in Anthropic's body, {"type": "error", "error": {"type": "...", "message": "..."}}, and the message says what to do. A named field is appended to the message as (param: NAME), and a refusal by the model adds refusal_reason to error. error.type follows the status:

A stream that fails after output ends with an error event, described under Stream. Errors lists every code, including the key, balance, model and provider errors this API shares with the others.

Limits

• max_tokens is required. A model's context window is context_length on its entry in GET https://api.llm.buzz/api/v1/models, and top_provider.max_completion_tokens is its output ceiling.
• A request may run for 600 seconds. A stream still generating then ends with a timeout error and is billed for the prompt and the output you received. A request that is not streaming answers 504.
• A request body over 64 MiB answers 413 request_too_large.
• A request makes at most 8 provider calls, every fallback included; gateway.retry lowers the ceiling.

Usage and limits collects the limits of every API.

Related

• Tools and structured output, Streaming, Reasoning, Images in requests and Prompt caching cover what the three text APIs share.
• Chat Completions and Responses are the other two text APIs; Choosing an API compares them.
• Coming from OpenRouter lists every difference from OpenRouter in one place.