Overview

Base URL and SDKs

Every model route is under https://api.llm.buzz/api/v1. Point an SDK at it and change nothing else:

Authentication

Send an inference key as a bearer token:

curl https://api.llm.buzz/api/v1/models \
  -H "Authorization: Bearer $LLM_BUZZ_KEY"

The Messages API also takes the key in x-api-key, the header the Anthropic SDK sends. A management key calls only the key routes below: create one on the console's Keys page, as you create an inference key, and send it the same way. The samples for those routes read it from $LLM_BUZZ_MANAGEMENT_KEY. Authentication covers keys, expiry and spending limits.

Endpoints

Paths are relative to https://api.llm.buzz/api/v1. Model routes outside it, such as /v1/chat/completions on the bare host, answer 404.

Decisions are served on POST /systemone and on POST https://api.llm.buzz/api/alpha/decisions, and no listed model answers them today. Choosing an API says which API each kind of model takes, and Decisions covers the two routes.

The keyless public catalog under /public/v1 (the site facts, every public model and provider) is what the llm.buzz website is built from, and the API reference lists it too. It needs no key, but it is the website's data, not a stable API: its fields can change without notice. Build on GET /models and the endpoints route instead.

The model list

GET /models returns data, total_count and links. Prices are decimal strings in US dollars per token. An audio model's prompt price is per second of audio or per character of input, and an image model lists its output price in image_output (Images explains image prices). Its query parameters:

A model whose lead provider's listing names its reasoning efforts carries them as reasoning_efforts, in order from none to max. The key is left out otherwise, including for a model whose efforts llm.buzz knows only from its own rules for the model's family, so a model without it can still reason: Reasoning. A speech-to-text model carries verbose_json, and a text-to-speech model supported_voices, default_voice and speech_speed; Audio explains them.

Without an Authorization header the list, a model and its endpoints answer the public catalog, at most 1,000 models, priced at each model's first-ranked public provider.

On the endpoints route, llm.buzz's own provider is one endpoint, provider_name llm.buzz and tag llm-buzz, priced at the lowest live direct price of each component. The llm.buzz provider explains it.

The provider object

Send provider in the request body (with the OpenAI SDK, in extra_body) to steer one request. Chat Completions, Responses, Messages, Embeddings and the image routes read every field; the audio routes read only zdr and data_collection. Every field accepts null.

order, only and ignore take at most 64 names. A name matches a provider's display name, its tag, or the tag's first part, ignoring case; an EU provider's tag ends in /eu. llm.buzz or llm-buzz names llm.buzz's own provider, and llm-buzz/eu only its capacity in the EU. Models and routing explains the order a model's providers are tried in.

extra_body={"provider": {"only": ["scaleway/eu"], "zdr": True}}

Model suffixes

A suffix on the model's name changes one request: :floor tries the cheapest provider first, :nitro the fastest, and :exacto is accepted and ignored. :online asks for a web search on Chat Completions and Responses; on Messages it does nothing and is named in x-sgr-ignored-parameters as model:online.

llm.buzz runs no web search today. A request that asks for one, with :online, web_search_options or plugins: [{"id": "web"}], is still served, without the search: nothing is sent to a search service, no search is billed, and x-sgr-ignored-parameters names it as web_search->dropped(search_unavailable). For an organization whose requests llm.buzz keeps in the EU, such a request answers 400 web_search_unavailable_in_region instead.

Request fields

Each API's page lists every field and what llm.buzz does with it: Chat Completions, Responses and Messages. Fields the surface does not know are dropped instead of refused, and Chat Completions, Responses and Messages name them in x-sgr-ignored-parameters in the response body. A field llm.buzz refuses answers 400 before any provider is called: Errors. These fields do something on llm.buzz:

On Chat Completions and Responses, send an Idempotency-Key header. A retry with the same key and the same body never runs the request twice: it returns the first answer, or 409 idempotency_replay_unavailable when that answer is not stored where the retry arrived. Send the same key again only when the first call got no answer, or after an answer carrying x-gateway-admission-refused: true; after any other error answer send a new key. A retry without the key, or with a new one, runs the request again and is billed again. Retries and idempotency says which key to send after each answer, and Errors lists the codes.

Sampling settings a model does not take

Some models refuse sampling settings. The Claude models that only think adaptively (Opus 4.7 onward, Sonnet 5, Haiku 5, Fable 5, Mythos 5) take no temperature, top_p or top_k, and OpenAI's reasoning models take temperature and top_p only where OpenAI does: some never, others only at reasoning effort none. llm.buzz drops such a value instead of failing the request, and names it in x-sgr-ignored-parameters, as temperature->dropped(unsupported_by_provider), or temperature->dropped(set_reasoning_effort_none) where setting the effort to none keeps it.

Two more rules follow the model or the provider:

• Claude models that always think. Claude Opus 5.5, Sonnet 5.5 and the Fable models take no none effort: reasoning_effort: none and thinking.type: disabled answer 400 before any provider is called, whichever provider would serve the model. Leave thinking out, or choose an effort: How an effort is mapped. Claude Opus 5.5, Sonnet 5.5 and Fable 5.1 also cannot be forced to call a tool: a tool_choice that forces one is served as auto and named as tool_choice->auto, so the answer may come without a tool call.
• Moonshot AI's own API, one provider of the Kimi models such as moonshotai/kimi-k3, takes no temperature, top_p, top_k, frequency_penalty or presence_penalty: llm.buzz drops them there, names them in x-sgr-ignored-parameters, and the model answers at its fixed settings. A tool_choice that names one function goes to another provider of the model that takes it, or is served as auto and named as tool_choice->auto. To force a tool call there, send tool_choice: "required". The Kimi models' other providers keep these settings.

Retries and fallbacks per request

The gateway object sets bounds for one request. Every field is optional.

extra_body={"gateway": {
    "retry": {"max_attempts_per_route": 2, "max_total_attempts": 3,
              "backoff": {"type": "exponential", "base_delay_ms": 500, "max_delay_ms": 8000}},
    "routing": {"allow_fallbacks": False},
}}

These are ceilings: the request's time limit, your spending limits and a provider's health can stop it sooner. Once output has reached you, the request stays on the provider that sent it.

Tool search

With many tools, mark most of them defer_loading: true and declare a tool search tool. The model then sees only the other tools and a search; the tools a search finds join the request. Where every provider of the model searches natively, the provider does it; otherwise llm.buzz runs the search, up to 3 rounds per request.

Usage counts the searches in server_tool_use_details.tool_search_requests (server_tool_use.tool_search_requests on Messages).

Responses

• usage.cost is the request's cost in US dollars, on every surface, when every part of it is known.
• Chat Completions and Embeddings bodies, and every Chat stream chunk, carry provider: the name of the provider that answered, llm.buzz for llm.buzz's own provider.
• Cached input shows in usage.prompt_tokens_details.cached_tokens on Chat Completions and usage.input_tokens_details.cached_tokens on Responses, and cache writes in cache_write_tokens beside it, with cache_write_1h_tokens for the one-hour part when the provider reports it. Messages keeps Anthropic's fields, cache_read_input_tokens and cache_creation_input_tokens. Prompt caching lists them.
• Every answer carries the headers x-request-id, x-gateway-alias (the model that served), x-gateway-canonical-model, x-gateway-provider (the provider that answered), x-gateway-route-depth and x-gateway-route-reason. Image and audio answers add X-Generation-Id.
• Readable reasoning comes back beside the answer: message.reasoning (delta.reasoning in a stream) on Chat Completions, a thinking block on Messages, and a reasoning item's summary_text on Responses. reasoning.exclude: true turns it off.
• A Chat Completions model that makes images returns them in message.images[].image_url.url (delta.images in a stream), each a complete base64 image. Send one back as an assistant image_url content part to continue the conversation.

Cost of a finished request

GET /generation?id= answers the record and cost of any finished request of your organization. A request's generation ID is gen- and the 32 hex digits of its x-request-id, which is request- and the same digits. Image and audio answers also name it in X-Generation-Id, and a text-to-speech answer, which has no JSON body, has its cost only here.

curl "https://api.llm.buzz/api/v1/generation?id=gen-..." \
  -H "Authorization: Bearer $LLM_BUZZ_KEY"

The answer is OpenRouter's {"data": {...}}. total_cost and usage are what you were charged, in US dollars at your rate; api_type is completions (Chat Completions, Responses and Messages), embeddings, image, stt, tts or decisions; provider_name is the provider that served it. An ID of another organization, a malformed one, and one whose request has not finished all answer 404; a request without id answers 400. Audio lists every key.

Time limit

A request may run for 600 seconds. A stream still generating then ends with a timeout error chunk and the stream terminator, and is billed for the prompt and the output you received, not for its whole reservation. Any other request past the limit answers 504 deadline_exceeded. Usage and limits collects the limits of every API.

Browser access

A web page can call the model API from the browser with its visitor's own key, as on OpenRouter. The key travels in Authorization or x-api-key, never in a cookie, so every answer under /api/ allows any origin and none allows credentials.

• A preflight answers 204 without a key, and a browser keeps its answer for a day. It allows the headers the API reads: authorization, content-type, accept, x-api-key, anthropic-version, anthropic-beta, x-title, http-referer, idempotency-key, x-session-id, x-client-request-id, originator, openai-organization, openai-project, and any x-sgr- or x-stainless- header (the OpenAI and Anthropic SDKs send the latter). The browser refuses to send any other header.
• Every answer, errors included, lets the page read the headers x-request-id, x-generation-id, retry-after, x-ratelimit-* and x-gateway-*, and, in the body, the x-sgr-ignored-parameters key. No answer sends that name as a header.
• The keyless catalog under /public/v1 sends no CORS headers.
• A key used from a page is visible to that page's visitors. Give a browser app a key with a spending limit, or let each visitor bring their own.

App attribution

Coding agents and apps that llm.buzz recognizes get their usage counted under their own name on Rankings and their app page. Most are recognized by their User-Agent. An app can also name itself with OpenRouter's headers:

-H "X-Title: Cline" -H "HTTP-Referer: https://cline.bot"

A title or a site llm.buzz does not know counts as other usage. Neither header is ever published.

Errors

Errors on the model routes come in one envelope; metadata.gateway_code is the code to branch on. The Messages API keeps Anthropic's error body.

{"error": {"code": 404, "message": "...", "metadata": {"error_type": "not_found", "gateway_code": "model_not_found", "param": "model"}}}

Errors lists every code with what to do.