/v1/responses, or a GPT model with the
Anthropic SDK: Verlon translates your request into the serving provider’s API
and its answer back into the format you called with — buffered or streamed.
When the model’s provider speaks your format, the request passes through as
sent. When it doesn’t, nothing is changed silently: every response says what
the gateway did.
Response headers
What the gateway serves itself
Where a provider lacks a feature, or implements it differently, Verlon serves it and names it inx-verlon-emulated.
- Stop sequences (
stop). On models whose provider refusesstop, or applies it in a way your client can’t use — OpenAI’s reasoning models, xAI’s Groks (some return the sequence in the text), Meta’s Muse, and Fireworks models that meet the sequence inside their reasoning — Verlon sends the request without it and cuts the answer at the first sequence itself. A Messages client getsstop_reason: "stop_sequence"and the matchedstop_sequence. A streamed chat completion withoutstream_options.include_usageends at the cut; the request is still billed from the provider’s own usage. - Forced tool choice (
tool_choice). Atool_choicenaming a tool, orrequired, on a model that refuses one: DeepSeek’s thinking models serve it with thinking off for that request; Anthropic’s 5.5 generation and Meta’s Muse get it best-effort — the named tool only, with an instruction to call it. When an Anthropic model still answers without the call, the header saystool_choice(unmet). - Several choices (
n). For a chat-completions client,nabove 1 on a model or endpoint that gives one choice per call is served asnparallel calls, joined into one response. Each call is billed, sonprompts are billed, as with a provider’s ownn. - Prompt caching (
prompt_cache). OpenAI caches the start of a prompt on its own; Anthropic caches only where a request asks it to. So a chat-completions or Responses request to a Claude model is sent with Anthropic’s automatic caching on, and a conversation or a repeated system prompt is read back from the cache. Anthropic bills the first write of a prompt at 1.25 times the input price and each read after it at about a tenth, so a one-off prompt costs 25% more on its input, and every later request that repeats it within 5 minutes costs much less. Prompts below the model’s cacheable minimum (512 to 4,096 tokens, depending on the model) aren’t cached and cost nothing extra. Cached tokens are reported inusage.prompt_tokens_details.cached_tokens(chat completions) orusage.input_tokens_details.cached_tokens(Responses). - One tool call per turn (
parallel_tool_calls).parallel_tool_calls: false(Messages:disable_parallel_tool_use: true) on a model or API without that switch returns only the answer’s first tool call, buffered and streamed. - Gemini 3 thought signatures (
thought_signature). Gemini 3 needs the signature it returned on each function call sent back with the next turn. A chat-completions client gets it on each tool call asextra_content.google.thought_signature, where Google’s own OpenAI-compatible API puts it — send the assistant turn back as you received it. A Messages or Responses client has no field for it, so Verlon supplies Google’s documented placeholder and names it in the header.
Reasoning and citations across shapes
A model’s visible reasoning and its web citations come back in your format, whichever provider answered, streamed or not.
The reasoning is Claude’s thinking, Gemini’s thought summaries, an OpenAI
reasoning summary, or the
reasoning_content an open-model host returns. When
your request would show reasoning, Verlon asks the serving model to show it.
A thinking block or reasoning item written from another provider’s reasoning
carries a marker of Verlon’s own: a thinking signature of verlon:reasoning,
or a reasoning item id starting rs_verlon_. So does a Messages web citation
written from another provider’s: its encrypted_index starts vrln-cite-.
Send them back with the conversation as usual. Verlon takes them out before
the request reaches any provider, because Anthropic and OpenAI accept only
reasoning and citation indexes they issued themselves. They aren’t named in
x-verlon-dropped.
Files, audio and tool images across shapes
A file, audio clip or image reaches the serving model in that provider’s own form, whichever SDK sent it:- PDFs and documents. A Messages
documentblock reaches a GPT, Grok or open model as a file part (input_fileon the Responses API,fileon chat completions) and a Gemini model as inline data. A document by URL goes by URL to the Responses API and Gemini. The chat-completions file part takes a file inline only, so a URL document there is named inx-verlon-dropped. A plain-text document is sent as text, under its title. A chatfilepart reaches Gemini as inline data. - Audio. A chat
input_audioclip reaches Gemini as inline audio. Inline wav or mp3 from a Gemini request reaches a chat-completions model asinput_audio. - Images a tool returned. A screenshot inside a Messages
tool_resultreaches the Responses API inside the function output, and Gemini right after the function response. On chat completions, where a tool message holds text only, it follows the tool messages as a labelled user image.
context, is named in x-verlon-dropped.
Served on the Responses API
Some requests one provider’s chat-completions endpoint refuses, its Responses API serves. Verlon sends them there automatically, recorded asx-verlon-translated: chat->responses:
- OpenAI models served only on Responses (gpt-5-pro, gpt-5.3-codex), and reasoning models that take function tools only there;
- PDF input on xAI’s Groks;
- a strict JSON schema on DeepSeek, which enforces it only on its Responses API.
Dropped fields
A field the serving model has no equivalent for —seed on Claude, OpenAI’s
reasoning items on another provider, top_k on a chat-completions provider
— is left out of the request and named in x-verlon-dropped. A field a
provider refuses outright, such as a reasoning_effort value a model doesn’t
take, is dropped and the request sent again. A DeepSeek tool loop whose history
lacks the model’s own reasoning is served with thinking off for that turn
(x-verlon-dropped: thinking).
Requests refused up front
A few requests get a400 (unsupported_capability) before any provider call,
because no translation would give you something usable — and only when the
serving provider itself lacks the capability:
- a strict JSON schema the model cannot enforce;
- an input the model cannot read (an image, a PDF, audio);
- tools on a model with no tool calling at all;
- an output modality the model cannot produce;
- inference pinned to a region the model cannot serve in;
- a model whose answer is a song (Lyria) on
/v1/messagesor/v1/responses, whose formats have no audio output. Call it through/v1/chat/completions(the song comes back asmessage.audio) or Gemini:generateContent. Nothing is sent to the provider and nothing is charged.
capabilities
object lists each model’s support.
Batch and files: not served yet
Verlon does not serve batch jobs or file uploads yet. Their paths answer501
in the error format your SDK reads, naming the path, so the SDK raises a clear
error instead of a “not found”:
Until then, send each request on its own route, and send files inline (a base64
file, document or image part).
GET /v1/registry/endpoints lists which
providers sell batch and files, and which don’t, with the provider page each
answer was read from.
