Anthropic Compatibility¶
Verda Inference speaks the Anthropic Messages API. Anthropic SDKs and tools work with Verda once you change two settings:
| Setting | Value |
|---|---|
| Base URL | https://inference.verda.com |
| API key | Your inference API key |
The base URL has no /v1 at the end: Anthropic SDKs add the path themselves. If you set ANTHROPIC_BASE_URL and ANTHROPIC_API_KEY in your environment, the SDKs pick them up without code changes.
Send the key the way Anthropic clients do, in the x-api-key header. Authorization: Bearer <your key> works as well. The anthropic-version header is optional for messages. The model list needs it.
Make a call¶
The examples call Kimi K3.1 Pro. To call another model, change model to its model ID.
Install the SDK with pip install anthropic, then run:
import os
from anthropic import Anthropic
client = Anthropic(
base_url=os.environ["VERDA_INFERENCE_BASE_URL"],
api_key=os.environ["VERDA_INFERENCE_API_KEY"],
)
message = client.messages.create(
model="kimi-k3-1-pro",
max_tokens=8192,
messages=[{"role": "user", "content": "What is the best viewpoint in Helsinki?"}],
)
for block in message.content:
if block.type == "text":
print(block.text)
print(message.usage)
Install the SDK with npm install @anthropic-ai/sdk, then run:
import Anthropic from "@anthropic-ai/sdk";
const client = new Anthropic({
baseURL: process.env.VERDA_INFERENCE_BASE_URL,
apiKey: process.env.VERDA_INFERENCE_API_KEY,
});
const message = await client.messages.create({
model: "kimi-k3-1-pro",
max_tokens: 8192,
messages: [{ role: "user", content: "What is the best viewpoint in Helsinki?" }],
});
for (const block of message.content) {
if (block.type === "text") console.log(block.text);
}
console.log(message.usage);
VERDA_INFERENCE_BASE_URL is https://inference.verda.com, as in the Quickstart.
Endpoints¶
Verda Inference serves these Anthropic endpoints:
| Endpoint | What it does |
|---|---|
POST /v1/messages |
Generates a message, with and without streaming |
POST /v1/messages/count_tokens |
Returns the number of input tokens a request would use, without generating anything |
GET /v1/models |
Lists the models your API key can call. See Models. |
GET /v1/models/{model_id} |
Returns one model |
Other Anthropic endpoints, such as message batches, return 404 with the code endpoint_not_supported.
Models¶
GET /v1/models lists the models your API key can call. Send the anthropic-version header to get the answer in Anthropic's format. The Anthropic SDKs always send it. Without the header, the same path answers in the OpenAI format. See Inference Endpoint API.
The answer holds the models in data, with has_more, first_id and last_id for paging:
{
"data": [
{
"type": "model",
"id": "kimi-k3-1-pro",
"display_name": "kimi-k3-1-pro",
"created_at": "1970-01-01T00:00:00Z"
}
],
"has_more": false,
"first_id": "kimi-k3-1-pro",
"last_id": "kimi-k3-1-pro"
}
Verda doesn't know every field of a model:
display_nameis the model name.created_atis always1970-01-01T00:00:00Z. It doesn't tell you when the model was released.capabilities,max_input_tokens,max_tokens,line,deprecated_atandretires_atarenull. The example above leaves them out. Each model page lists what the model can do.
Three query parameters page through the list:
| Parameter | What it does |
|---|---|
limit |
How many models to return, from 1 to 1000. The default is 20. |
after_id |
Returns the models that come after this model ID |
before_id |
Returns the models that come before this model ID |
Send after_id or before_id, not both. lifecycle[] is accepted too. Every listed model is active.
Get one model¶
GET /v1/models/{model_id} returns one model, with the same fields as in the list.
If the model doesn't exist, or your API key can't call it, you get 404 with error.type not_found_error.
Model IDs for Claude Code¶
Claude Code and the Claude desktop app only show models whose ID looks like one of Anthropic's. Send the header x-maas-model-namespace: anthropic to get IDs they keep:
curl "https://inference.verda.com/v1/models" \
-H "x-api-key: <your key>" \
-H "anthropic-version: 2023-06-01" \
-H "x-maas-model-namespace: anthropic"
Each model is then listed as anthropic/ followed by its model ID written backwards, with the plain model ID as display_name. Kimi K3.1 Pro is anthropic/orp-1-3k-imik, shown as kimi-k3-1-pro. The ID is written backwards because the desktop app also hides IDs that name another model maker.
Requests that carry the header accept both forms as model: the listed ID and the plain model ID. Usage and billing are the plain model's. Any other value of the header is rejected with 400.
You only need this for the model picker. See Claude Code for the setup.
Request parameters¶
You can send the usual Messages parameters, including model, max_tokens, messages, system, stop_sequences, stream, tools, tool_choice, thinking, metadata and output_config. Tool use and structured output work on models that list them under features on their model page.
A few things work differently:
- Tools are the ones you define. Server tools that Anthropic runs for you, such as web search or code execution, are rejected with
400. So ismcp_servers. cache_controlis accepted and has no effect. Prompt caching is automatic:usage.cache_read_input_tokensreports the input tokens read from the cache.- Other parameters the API doesn't support are ignored.
Streaming¶
Set "stream": true to receive the response as server-sent events. The events follow the Anthropic order: message_start, then content_block_start, content_block_delta and content_block_stop for each content block, then message_delta and message_stop. message_delta carries the stop reason and the final usage. No ping events are sent.
The same timeouts apply as for the OpenAI endpoints: stream long generations.
Thinking¶
Reasoning models think before they answer. Their thinking comes back as thinking content blocks, before the text blocks that hold the answer. Thinking counts as output tokens and is billed like them.
The thinking field of the request controls it:
{"type": "enabled", "budget_tokens": 2048}turns thinking on.{"type": "disabled"}turns it off, on models where reasoning is optional.- Without the field, the model's default applies. A reasoning model then thinks, and its answer includes
thinkingblocks. This differs from Anthropic's API, where thinking is off unless you enable it.
max_tokens caps the thinking and the answer together. If the model uses it all while thinking, the answer has no text block and stop_reason is max_tokens. Raise max_tokens, or turn thinking off.
Errors¶
Errors use the Anthropic error format, so Anthropic SDKs raise them as usual:
{
"type": "error",
"error": {"type": "not_found_error", "code": "model_not_found", "message": "model \"example\" not found"},
"request_id": "01a1e8da-cbbb-7117-a338-8c3cf4a2479a"
}
error.type is Anthropic's name for the status. error.code is the same code the OpenAI endpoints return, and the same table says what to do about each. The request-id response header carries the request ID.
| Status | error.type |
|---|---|
400 |
invalid_request_error |
401 |
authentication_error |
402 |
billing_error |
403 |
permission_error |
404 |
not_found_error |
413 |
request_too_large |
429 |
rate_limit_error |
503, 529 |
overloaded_error |
504 |
timeout_error |
Other 5xx |
api_error |