Models and routing

Every model Zabio serves has a vendor (anthropic, openai, google, deepseek, xai, mistral, together, typesafe, alibaba-us or alibaba-intl), a class (fast, balanced, powerful or frontier, a label for the pages, not a routing rule), a set of capabilities, a processing location and a dated price. You can ask for a model by name or let Zabio choose with one of the auto models.

For the exact shape of every request and response, with curl, Python and Node examples, see the API reference.

Vendors and where they process data

Vendor	Models	Processed in
Anthropic, OpenAI, Google	their own models	United States
xAI	Grok, through xAI’s US endpoint	United States
DeepSeek	DeepSeek through DeepSeek’s own API, labelled “DeepSeek (China)”	China
Together AI	open-weight models (Llama, Qwen, gpt-oss) and copies of the DeepSeek models labelled “DeepSeek (North America, via Together AI)”, with ids ending in @together	North America
Mistral AI	Mistral models, through Mistral’s global API	not guaranteed: Mistral does not commit to an inference location there
TypeSafe AI	Jev (jev-1.13.0), a decision model: typed answers with calibrated probabilities, called by name or chosen by auto for a classification job, see Decision models	United States
Alibaba Cloud (US)	Qwen and GLM models through Alibaba Cloud Model Studio’s Virginia workspace, with ids ending in @alibaba-us	US (Virginia): data stored and processed only in the United States
Alibaba Cloud (International)	Qwen models and DeepSeek V4 Flash through Alibaba Cloud Model Studio’s Singapore workspace, and copies of DeepSeek V4.1 Flash, GLM and Qwen 3.8 2.4T with ids ending in @alibaba-intl	Outside mainland China: data stored in Singapore and processed anywhere outside mainland China

Every vendor is on by default. Owners and admins can turn a whole vendor off, or single models, on the Models page of the web app; a vendor that is off never receives your requests. The DeepSeek models exist twice so you can choose: turn DeepSeek off and keep Together AI on to use the DeepSeek models processed in North America only.

auto chooses among the models with a measured skill for the request’s kind of work (see How routing picks a model), from the vendors and models your organization and key allow. Every model in the catalog can also be named. The decision model jev-1.13.0 is never a candidate, but auto may answer a classification job with it (see Classification jobs on auto). When you want a narrower field, name a line (auto/best, auto/balanced), disable vendors or models for your organization, or set an allow list on the key.

When a vendor announces that a model will be retired, the model carries retires_at with that date. auto stops choosing it 10 days before the date; requests that name it keep working until the vendor’s date.

The three lines

A line says how skilled the model must be. The classifier says what the request is: its kind of work, how hard it is and what is at stake. Every candidate has a skill score for that kind of work, and the line sets the floor; the cheapest model at or above the floor answers.

Model id	What you get
auto/best	the cheapest model whose skill for this kind of work is in the top third of the candidates
auto/balanced	the cheapest model whose skill for this kind of work is in the middle third of the candidates or above
auto/cheap	the cheapest model skilled enough for the job: any candidate with a skill score for this kind of work
auto	the same as auto/cheap. Name another line when you want a stronger model on every request

A hard request, or one with high stakes, moves one step up: auto and auto/cheap to the middle third, auto/balanced to the top third; auto/best is already at the top. When the cheapest model already meets the higher floor, nothing changes. zabio.routing.line shows the tier as you asked for it (auto for plain auto), and zabio.routing.floor the floor applied after any step up (none, middle or top). You can also name any model directly.

How routing picks a model

1. The job. A small, fast model reads the request (the first part of your system prompt, the last user message, the names of your tools, whether images are attached) and names the job: its kind of work (zabio.routing.task_type, one of the tags in Kinds of work), a difficulty from 1 to 5, whether the stakes are high, with a confidence and a one line reason. You see all of it in zabio.routing. It never sees a price or a model name. When it is unsure, it rounds the difficulty up.
2. Constraints. zabio.vendors limits the candidates to the vendors you list. Models switched off for your organization or missing from the key’s allow list are out.
3. Capabilities. A request with images needs a vision model, tools need a tool capable model, response_format: json_schema needs structured output support, and the prompt plus max_tokens must fit the context window. Models that fail a check are skipped.
4. Skill and price. Every candidate has a skill score for the kind of work, measured for that kind of work and ranked against the other current models. Only models with a score are candidates. The line sets a floor on that score (none, the middle third or the top third of the candidates), and the cheapest candidate at or above it answers. The price is this request’s: the size of your prompt, the output the model is expected to write with its reasoning, and a session’s warm prompt cache. Equal prices go to the model with the earlier id.
5. Difficulty and stakes. A hard request, or one with high stakes, moves the floor one step up. A job is high stakes when acting on a wrong answer could cost more than asking again (harm to health or safety, money, a legal position or security, an action that cannot be undone, or a change to a live production system). Urgency, strong feelings, a support setting or an upset customer do not make a job high stakes by themselves. Before a job is marked high stakes, a second, narrower question asks what a mistake would actually cost. Its answer is used only on those jobs. On streamed calls and calls with tools it is asked together with the first question, so the answer does not wait for it; when it is not needed, Zabio pays for it.
6. Attempts. If the chosen provider fails or does not answer in time, Zabio moves to the next source of the same model, or to the next model by the same rule, up to 3 attempts in total. zabio.attempts tells you how many were needed.

When no skill is measured. A request of kind other, or of a kind of work with no skill scores yet, is routed by Zabio’s earlier rule. For the job and its difficulty, Zabio knows how well each model does and how sure that knowledge is; sorted by the price of this request, the candidates form a curve, and a model that a cheaper one matches is never chosen. auto/best stops climbing when nothing pricier is probably better, auto/cheap stops at the first model that is not clearly worse than the top, auto/balanced sits between them, and plain auto takes the cheapest model on an easy job, the best rule on a high-stakes one and balanced otherwise. Under this rule a high-stakes job runs cheap as balanced and balanced as best, and frontier models are candidates on auto/best only. zabio.routing.cell names the knowledge it used. Where that knowledge comes from is described on the benchmarks page.

The account, the organization, a project and the key each choose which models they allow, and a call may use only what every level allows; auto only picks from those models. See Model access.

Reasoning levels and effort inside auto

reasoning_effort on chat completions and reasoning.effort on the Responses API take one scale for every vendor: none, minimal, low, medium, high and xhigh, OpenAI’s names, so OpenAI clients work unchanged. Each model has a row in Zabio’s reasoning table, shown in the Reasoning column of the tables below and in zabio.reasoning on GET /v1/models: named levels (OpenAI, Anthropic, DeepSeek), Google’s thinking levels (Gemini: low, medium and high), on or off (Together AI’s thinking models), always on (grok-4.7), or no reasoning at all. A level the model does not have maps to the closest one it has, the lower of two equally close, and a request never fails because of the level. A level sent to a model without reasoning is ignored, listed in zabio.ignored_parameters, and zabio.reasoning.applied says not supported. DeepSeek and Together AI’s thinking models always run with reasoning off when the request carries tools. Every response reports zabio.reasoning: requested (what you sent) and applied (default for the vendor’s own default, off, the vendor’s level name, budget N, on, always on or not supported).

When you set no level on auto, Zabio chooses the reasoning setting together with the model. On easy and medium jobs the cheap and balanced lines use the model’s lowest setting: off where the model can stop reasoning, its lowest level otherwise. Zabio’s own tests found that on those jobs more thinking did not change the answers, only the cost and the wait, and reasoning tokens are often most of what a reasoning model bills. The best line, high-stakes jobs, and hard and frontier jobs keep the model’s default. Calculations always reason: on a math job, a model whose reasoning is off by default runs at its lowest setting that reasons, and a model that cannot reason answers only when no candidate can. Reasoning that Zabio turns on needs room: when max_tokens is too small for it on every candidate, the math job runs at the models’ default settings instead. If an answer still comes back empty because the reasoning Zabio chose spent the whole budget, that call is not billed, and the request goes once more to the next candidate that reasons by default and fits your max_tokens (on the skill rule, the floor one step up first); when there is none, the same model answers again without reasoning. You pay only for the answer you receive. A streamed answer that comes back empty this way is always answered again by the same model without reasoning. zabio.routing.effort says what was chosen and zabio.routing.effort_reason why. A level you set always wins. Thinking tokens count inside max_tokens, so leave room above the thinking: set max_tokens to the answer you need plus the thinking you allow, or a reasoning model can spend the whole budget thinking and return an empty answer with finish_reason: "length", billed when the level was yours or the model’s own default.

Sessions and stickiness

Send zabio.session_id (any string up to 128 characters; the header x-zabio-session-id also works) on calls that belong together. Within a session the job is classified once per user message and reused across the tool-result turns that follow, so those calls do not pay for a new classification. Zabio classifies again on a new user message and when a signal fires:

Trigger (as reported in zabio.routing.trigger)	Meaning
no_prior_decision	first call of the session
cache_hit	the previous decision was reused
low_confidence_prior	the earlier decision had confidence below 0.7
long_idle	more than 30 minutes since the last call
tool_failure_streak	three tool results in a row looked like errors
customer_feedback	the user wrote something like “that is wrong” or “try again”
new_human_message	a new user message in the session; the job is classified again
explicit	a model was named; no routing
escalation	the model asked for a stronger model (see below)

Session state is metadata only (line, model, confidence, a few counters, the size of the last prompt and the cache lifetime applied to it). It lives for one hour after the last call and at most 24 hours. Prompts are never stored for it.

Within a session, routing counts the prompt cache. After a turn, the model that served it holds your context in its vendor’s cache for a while (Anthropic: the 5 minute or 1 hour lifetime that was applied; OpenAI, DeepSeek, xAI and Mistral: about five minutes, since they cache without markers). On the next turn Zabio prices that model with the cached part of the prompt at its cache read rate, and every other candidate with the same part at the fresh rate plus the cache write it would pay, and the line applies its usual rule to those prices. So a conversation stays on its model when moving would cost more than it saves, and still moves when another model is cheaper by more than the cost of warming it, when the job changes on a new message, or when the model asks to escalate. There is no pin: the cheapest honest price wins. Google and Together AI models get neither the discount nor the write, because Zabio has no cache to count there. When the cache decided the pick, zabio.routing.sticky names the model kept and the one cold pricing would have chosen; otherwise the field is absent.

Split and route

A request under auto that carries a large source (a contract, a log, a support thread, a set of reviews or records) together with a question that needs only part of it can be answered in two steps when that is cheaper than sending the whole source to the model routing chose. Zabio calls this split and route. Version 1 does one kind of split, distill then answer:

1. Who qualifies. Only a virtual model (auto, auto/best, auto/balanced, auto/cheap, or no model); a named model is never split. The last user message must be plain text of at least about 4,000 tokens on Zabio’s estimate, with no image parts and no tool results, the request must carry no tools, and Zabio’s free estimate of the unsplit call must be at or above 0.010 USD. Cheaper calls run exactly as before.
2. The questions. A second call to Jev (TypeSafe’s decision model, the one that classifies the job, on Zabio’s key and at Zabio’s cost) reads the same excerpt the classifier reads and says whether the request is a large source plus a separate question that needs at most about half of it.
3. The price check. Zabio prices both paths: the whole request on the routed model, and the extract on the cheap model plus the check plus the answer on the excerpt. The split goes ahead only when it is estimated at 70 percent of the unsplit call or less.
4. The extract. A cheap model (gpt-5.4-nano, or gemini-3.5-flash-lite when the first declines or returns nothing) copies the lines of the source the question needs, word for word and in their order. Its output is streamed and cut off past 40 percent of the source. Every line that does not occur in the source is dropped, so nothing the extractor rewrote or invented reaches the answering model. An extract with fewer than half of its lines found in the source, an empty one, or one above 40 percent of the source stops the split.
5. The check. Jev reads the beginning and the end of your message and the excerpt and says whether the excerpt holds what the question names; below 0.5 the split stops.
6. The answer. The routed model, at the setting routing chose, receives your message with its first 2,000 and last 2,000 characters kept verbatim (on line boundaries, where the instructions usually live) and the source between them replaced by the excerpt under this line: [Zabio excerpt: the material between these markers was shortened by a preprocessing step to the lines relevant to the request (K of N lines kept, in their original order). If you need more of the original material to answer well, reply with exactly the line NEED_MORE_SOURCE and nothing else.], followed by the excerpt and [end of excerpt]. Everything else about the call (the system prompt, earlier messages, max_tokens, response_format) is unchanged.
7. The way back. When the model answers with the line NEED_MORE_SOURCE, Zabio sends the full request to the same model and returns that answer. On a stream the reserved line is read on the first frames, before anything reaches you, and the full-source stream replaces it, so the first tokens may take a moment longer.

Every guard that fails sends the request whole to the routed model, as if nothing had happened, and zabio.split.fallback says which one: extractor_declined (the extractor said the task needs the whole material), empty_extract, extract_too_big, low_verbatim, check_rejected, need_more_source, extract_failed, check_failed. A split that fell back never costs you more than the unsplit call; see Billing.

What you see: zabio.split on every response while the feature is on, with applied, the reason when the request was not split (named_model, opt_out, not_eligible, below_threshold, jev_no, jev_failed, price_check), the two estimates, every call of the split (steps: the questions, the extract, the check and the answer, each with its vendor, model, tokens, list price and whether it was billed), the excerpt’s size and how much of the extractor’s output was found verbatim in your source, and the check’s probability. zabio.model_served and zabio.routing keep naming the model that answered and how it was chosen. To send a request whole, set zabio.split: "off" or the header x-zabio-split: off; there is no per-key default, the choice lives in the request.

Not covered in version 1: only the last user message is split. A large source that lives in earlier turns or in a stored conversation’s history is not distilled (compaction handles size there), nor are several large messages, images, tool results, or a previous_response_id chain whose source arrived turns ago. Within a session, the turn after a split prices no warm cache, because what the vendor cached was the rewritten message.

Flex tier

OpenAI and Google serve some models on a flex tier: the same model at about half the price, slower (their own latency target is up to 15 minutes) and with best-effort capacity. A request that can wait says so with zabio.deadline (or the header x-zabio-deadline), a duration of 15 minutes or more; under 15 minutes, or with no deadline, nothing changes. The models with a flex price are OpenAI’s GPT-5, GPT-5.x and GPT-6 chat models together with o3 and o4-mini, and every Google Gemini model; the GPT-4 family, o1, o3-mini, chat-latest and every other model is served and priced at standard, deadline or not.

With a deadline, auto prices every candidate that has a flex tier at its flex price and the rest at standard, then runs the line rule as usual, so a model can win because it is cheaper in flex. A named model with a flex price is served at flex. When the vendor refuses a flex request for capacity, Zabio retries the same model at the standard tier at once and bills the price actually used. The pre-steps of a split (the extract and the checks) run at the standard tier; only the answer can be flex. zabio.tier on the response says what was requested, what served the call and whether capacity forced the standard tier. See Chat completions for the field and Billing for the fee.

Escalation

On auto turns of the Responses API, Zabio gives the model a hidden tool it can call when a task is beyond it. When that happens, Zabio re-runs the same turn on a stronger model, with the full history, and returns that answer: the cheapest model one step up the skill floor for the kind of work, or, for a request routed by the earlier rule, the next model up the curve that its knowledge says is probably better. The response carries zabio.escalated_from with the line and model that gave up (for example cheap/gpt-5.4-nano). The escalation itself never appears in your output. Escalation is not offered on /v1/chat/completions.

Checked answers

On a request that is not streamed, Zabio checks the answer against what the request asked for before it reaches you:

• with response_format json_schema: the answer is JSON, and nothing else, that matches your schema (types, required fields, enums, lengths, numeric bounds, patterns);
• with response_format json_object: the answer is one JSON object;
• with tools: every tool call names one of your tools and its arguments are JSON that matches that tool’s parameters, and a tool_choice of required or a tool’s name gets a call;
• on any request: the answer is not empty because the model spent its whole output budget thinking (finish_reason length with no content).

When the answer to an auto request fails and auto chose the model by its skill score, it sends the request once more to the cheapest model one step up the skill floor, the failed model left out, and you receive that answer. An answer left empty because the model spent its whole output budget thinking goes instead to the cheapest other model at the same skill floor, and only when there is none to the cheapest one step up; on any line but best, never to the strongest model auto can pick for that kind of work. When Zabio chose the reasoning, only models that reason by default are candidates, under either rule, and with none the same model answers once more without reasoning (see Reasoning levels and effort inside auto); when you or the model chose it and no model is left, you receive the answer as it came. You pay only for the answer you receive: the failed attempt is Zabio’s cost and is not in zabio.cost. When another model answers, zabio.escalated_from names the one that failed; zabio.attempts counts both attempts. A request is retried once at most; when the second answer fails too, you receive it as it is. Named models are checked and never retried: you chose the model. Streamed requests are not checked, because the answer reaches you while it is being written. A schema is read with references inside the schema only; Zabio never fetches a referenced file or URL.

Explicit models

Name any model id from the table below, for example claude-sonnet-5 or gpt-5.4. The request goes to that model. If the model is unhealthy or unavailable, or does not answer within Zabio’s deadline (3 minutes for fast and balanced class models, 10 minutes for powerful and frontier; a stream must send its first data within 60 seconds on fast and balanced, 10 minutes on powerful and frontier, and Zabio keeps the connection alive meanwhile, see Long calls), zabio.fallback decides what happens:

zabio.fallback	Behaviour
same_vendor (default)	another model of the same vendor and class
cross_vendor	any model of the same class
none	fail instead of falling back

The default comes from the key setting fallback_policy. The response always tells you what was served in zabio.model_served and zabio.vendor.

A max_tokens too large for the model you named does not move you to another model: Zabio lowers it to what the model can produce beside your input and keeps the model. The call falls back only when the input itself does not fit the model’s context window.

Decision models: Jev

jev-1.13.0 is Jev, TypeSafe AI’s “System One” model. It does not write text. It answers typed questions about a conversation and returns, with every answer, the calibrated probability of each option. That makes it a fit for the jobs where you want a label, a yes or no, or a score and nothing else: tagging, routing, moderation, sentiment, language detection, urgency. It answers in well under a second and costs 0.042 USD per million input tokens, with output free; Zabio adds the service fee of (see the pricing page), as on any call (see Billing).

You call it through /v1/chat/completions like any other model, with response_format set to json_schema. Each property of the schema’s object becomes one question:

Property in your schema	Jev question	What you get back
a string with an enum of 2 to 255 values	a choice	one of the values, with the probability of every value
a boolean	a yes or no	true or false, with the probability of yes
an integer with minimum and maximum 2 to 10 levels apart	a score	the weighted level rounded to the nearest whole number, with the probability of every level
a number with minimum and maximum 2 to 10 levels apart	a score	the weighted level itself, for example 0.27 on a 0 to 1 scale

usage.completion_tokens is the count TypeSafe reports for its answers; those tokens are free. Give every property a description: Jev reads it as the question. The schema’s own description is read as the shared instructions. The answer keeps your property order. What Jev reads is the whole conversation: the system prompt and every user and assistant message.

What Jev cannot answer is refused with 400 unsupported_for_model before anything is sent, and param names the field: a request without json_schema, a free text string, a nested object, an array, a number without bounds or with more than 10 levels, a nullable or anyOf property, tools, images, tool results, and stream: true (Jev answers in one piece).

A worked example: a support ticket into one of five categories, with a boolean for urgency and a 1 to 5 priority.

curl https://api.zabio.ai/v1/chat/completions \
  -H "Authorization: Bearer $ZABIO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "jev-1.13.0",
    "messages": [
      {"role": "system", "content": "You triage support tickets for a hosting company."},
      {"role": "user", "content": "My card was charged twice this month. Please fix it today, I am about to travel."}
    ],
    "response_format": {"type": "json_schema", "json_schema": {"name": "ticket", "strict": true, "schema": {
      "type": "object",
      "description": "Classify the support ticket in the conversation.",
      "properties": {
        "category": {"type": "string", "enum": ["billing", "bug", "feature_request", "account", "other"], "description": "The kind of request."},
        "urgent": {"type": "boolean", "description": "The customer needs an answer today."},
        "priority": {"type": "integer", "minimum": 1, "maximum": 5, "description": "How important the ticket is, 5 the most."}
      },
      "required": ["category", "urgent", "priority"],
      "additionalProperties": false
    }}}
  }'

The answer is the assistant message’s content, valid against your schema, and zabio.decision carries the probabilities behind it:

{
  "id": "chatcmpl-01a0e9d47c4d75d385ba714a2736ca34",
  "object": "chat.completion",
  "model": "jev-1.13.0",
  "choices": [{"index": 0, "message": {"role": "assistant", "content": "{\"category\":\"billing\",\"urgent\":true,\"priority\":4}"}, "finish_reason": "stop", "logprobs": null}],
  "usage": {"prompt_tokens": 484, "completion_tokens": 83, "total_tokens": 567},
  "zabio": {
    "vendor": "typesafe",
    "model_served": "jev-1.13.0",
    "routing": {"reason": "explicit model", "trigger": "explicit"},
    "cost_micros": 21,
    "cost": {"vendor_micros": 20, "service_fee_micros": 1, "call_fee_micros": 0, "savings_fee_micros": 0, "classifier_micros": 0, "direct_micros": 20, "saved_micros": -1},
    "decision": {
      "category": {"type": "choice", "probabilities": {"billing": 1, "bug": 0, "feature_request": 0, "account": 0, "other": 0}, "confidence": 1},
      "urgent": {"type": "noul", "probability": 0.84},
      "priority": {"type": "score", "value": 4.01, "probabilities": {"1": 0, "2": 0.02, "3": 0.11, "4": 0.71, "5": 0.16}, "confidence": 0.75}
    },
    "cache": {"read_tokens": 0, "write_tokens": 0, "ttl_applied": "none"}
  }
}

Read zabio.decision when you want to act on confidence: send the ticket to a person when the top category is under 0.7, or pick your own threshold for urgent instead of the 0.5 that decides the boolean.

Health, fallback and cost work as for any named model. TypeSafe has one model, so under the default same_vendor policy a TypeSafe outage fails the call with 503 no_provider_available; under cross_vendor a fast text model with structured output answers the same schema instead, without zabio.decision, and zabio.model_served says so. Jev is never a fallback for a text model. A request to Jev is sent whole to TypeSafe AI in the United States, like a request to any vendor you name; see Privacy.

Classification jobs on auto

Under auto (and auto/best, auto/balanced, auto/cheap), Zabio may answer a classification job with Jev instead of the text model routing chose, when that is cheaper. A request qualifies when its response_format is a json_schema whose every property is one Jev can answer (a string with an enum, a boolean, an integer or number with minimum and maximum 2 to 10 levels apart), with no tools, no images and no stream. Everything else routes exactly as always. Zabio then compares its estimate of Jev’s price with the routed model’s for the same request and asks Jev only when Jev is cheaper: on a short request to the cheapest models Jev often is not, so the text model answers; on a longer ticket, email or review it usually is.

A safety net: Jev returns the probability of every answer, and when any field of its answer is under 0.5 (the option it chose is less likely than not), Zabio discards the answer and sends the request to the text model as always. That Jev call is Zabio’s cost, never yours. On the study set behind this feature Jev was right on 92 percent of fields against 75 percent for the routed text models, and its answers came back in about 0.15 seconds.

How you can tell: zabio.model_served is jev-1.13.0, zabio.vendor is typesafe, and zabio.decision carries the probabilities, as when you name Jev. The answer keeps your schema’s shape and property order. zabio.routing still describes the job the classifier saw. Billing is as for any auto call: Jev’s price plus the service fee and the fee for automatic model choice, with the saving measured against your key’s baseline model on the request as you sent it (see Billing). Using Jev never costs you more than not using it: when Jev’s answer is discarded, you pay exactly what the text model’s call costs.

Naming a model keeps full control: a request to gpt-5.4-nano or any other named model is never answered by Jev, and a request that names jev-1.13.0 is always answered by Jev. A request to Jev on auto is sent whole to TypeSafe AI in the United States, like a request that names it; see Privacy.

Listing models

GET /v1/models returns the auto models followed by the catalog, priced for your organization:

{
  "object": "list",
  "data": [
    {"id": "auto", "object": "model", "created": 1757808000, "owned_by": "zabio",
     "zabio": {"tier": "balanced", "auto_eligible": true, "virtual": true}},
    {"id": "claude-sonnet-5", "object": "model", "created": 1757808000, "owned_by": "anthropic",
     "zabio": {"tier": "balanced", "auto_eligible": true,
               "capabilities": {"vision": true, "tools": true, "json_schema": true, "context_window": 1000000, "max_output": 128000},
               "pricing": {"input": 2.10, "output": 10.50, "cache_read": 0.21, "cache_write": 2.63, "currency": "USD"},
               "residency": "global"}}
  ]
}

GET /v1/models/{id} returns one model; auto/cheap style ids work (percent encode the slash if your client needs it). Keys with an allow list only see their models. Unknown ids return 404 model_not_found.

pricing is the provider list price plus your plan’s service fee, rounded up to the cent, in USD per million tokens. cache_write is the 5 minute cache write rate. See Billing for how fees work.

zabio.free_tier is true on the models of the free model list, the ones a Free account can name; GET /v1/public/free-tier serves that list with no key. While your organization runs on the Free limits, every model also carries zabio.availability: available, or locked for a model off the list, which a request may not name until a top-up (403 free_tier_model). The auto ids are always available and choose among the free models. See Billing, “The Free plan”.

Prices

The table below is generated from the catalog in the code. Prices are the provider list prices in USD per million tokens. Zabio bills this price plus the service fee of (see the pricing page), and on every auto request a fixed (see the pricing page), the price of automatic model choice; Zabio takes no cut of what routing saves (see Billing). Cache write rates: Anthropic charges 1.25 times the input price for a 5 minute cache and 2 times for a 1 hour cache; OpenAI and Google charge nothing extra to write. Google’s 3.x Flash promotional prices end on 2026-12-31. On the models with a flex tier (OpenAI’s GPT-5, GPT-5.x and GPT-6 chat models, o3 and o4-mini, and every Google Gemini model) a call with a zabio.deadline of 15 minutes or more is billed at half the listed input, output and cache read prices (the cached input of gpt-5.4 at 0.13 USD per million and of o4-mini at 0.138, as OpenAI lists them); see Flex tier.

The Auto column says whether auto can pick the model today: it has a skill score for at least one kind of work, or the earlier rule can choose it for a request of kind other (see How routing picks a model). It follows the daily skill data, so the page reads it live when it loads; zabio.auto_eligible in GET /v1/models and GET /v1/public/auto-models carry the same answer. Every model can be named. Most of the models marked no were added so that every model you can reach through other routers is also reachable here, at the vendor’s own list price.

Fast

Model	Vendor	Processed in	Auto	Context window	Max output	Input	Output	Cache read	Reasoning	Off-peak input / output
claude-haiku-4-5	Anthropic	United States	yes	200K	64K	1.00	5.00	0.10	no	-
gpt-5.4-nano	OpenAI	United States	yes	400K	128K	0.20	1.25	0.02	levels, none to xhigh, default off	-
gpt-5-mini	OpenAI	United States	yes	400K	128K	0.25	2.00	0.025	levels, minimal to high, default the vendor’s, always reasons	-
gpt-4.1-mini	OpenAI	United States	no	1M	32768	0.40	1.60	0.10	no	-
gpt-4o-mini	OpenAI	United States	no	128K	16384	0.15	0.60	0.075	no	-
gemini-3.5-flash-lite	Google	United States	yes	1M	65536	0.30	2.50	0.03	levels, none to high, default the vendor’s	-
mistral-small-2603	Mistral AI	Not guaranteed	yes	256K	256K	0.15	0.60	0.015	no	-
qwen3.5-9b	Together AI	North America	yes	262144	262144	0.17	0.25	0.00	on or off, default off	-
gpt-6-luna	OpenAI	United States	no	400K	128K	0.10	0.50	0.01	levels, none to xhigh, default the vendor’s	-
gpt-5.6-luna	OpenAI	United States	no	400K	128K	0.20	1.20	0.02	levels, none to xhigh, default the vendor’s	-
gpt-5-nano	OpenAI	United States	no	400K	128K	0.05	0.40	0.005	levels, minimal to high, default the vendor’s, always reasons	-
gpt-4.1-nano	OpenAI	United States	no	1M	32768	0.10	0.40	0.025	no	-
gemini-3.1-flash-lite	Google	United States	no	1M	65536	0.25	1.50	0.025	levels, none to high, default the vendor’s	-
ministral-3b-2512	Mistral AI	Not guaranteed	no	131072	131072	0.10	0.10	0.01	no	-
ministral-8b-2512	Mistral AI	Not guaranteed	no	262144	262144	0.15	0.15	0.015	no	-
ministral-14b-2512	Mistral AI	Not guaranteed	no	262144	262144	0.20	0.20	0.02	no	-
glm-5.3-flash	Together AI	North America	no	1048575	1048575	0.15	0.50	0.03	always on	-
muse-glimmer-30b	Together AI	North America	no	131072	131072	0.35	1.50	0.04	always on	-
deepseek-v4-flash-0731	Together AI	North America	no	1048576	1048576	0.14	0.28	0.03	on or off, default off	-
minimax-m3	Together AI	North America	no	524288	524288	0.30	1.20	0.06	always on	-
claude-haiku-5-5	Anthropic	United States	no	1M	128K	0.10	0.50	0.01	levels, none to xhigh, default the vendor’s	-
qwen3.8-omni-flash	Alibaba Cloud (International)	Outside mainland China	no	1M	131072	0.15	0.47	0.016	budgets, none to high, default off	-
qwen3.8-flash	Alibaba Cloud (International)	Outside mainland China	no	1M	131072	0.15	0.47	0.03	budgets, none to high, default off	-
qwen3.7-plus	Alibaba Cloud (International)	Outside mainland China	no	1M	131072	0.32	1.28	0.064	budgets, none to high, default off	-
qwen3.5-plus-2026-04-20	Alibaba Cloud (International)	Outside mainland China	no	1M	65536	0.40	2.40	0.00	budgets, none to high, default off	-
qwen3.5-plus-2026-02-15	Alibaba Cloud (International)	Outside mainland China	no	1M	65536	0.40	2.40	0.00	budgets, none to high, default off	-
qwen3.5-flash-2026-02-23	Alibaba Cloud (International)	Outside mainland China	no	1M	65536	0.10	0.40	0.00	budgets, none to high, default off	-
qwen3.6-flash	Alibaba Cloud (International)	Outside mainland China	no	1M	65536	0.25	1.50	0.05	budgets, none to high, default off	-
qwen3.6-35b-a3b	Alibaba Cloud (International)	Outside mainland China	no	262144	65536	0.375	2.25	0.00	budgets, none to high, default off	-
qwen3.5-35b-a3b	Alibaba Cloud (International)	Outside mainland China	no	262144	65536	0.25	2.00	0.00	budgets, none to high, default off	-
qwen3.5-27b	Alibaba Cloud (International)	Outside mainland China	no	262144	65536	0.30	2.40	0.00	budgets, none to high, default off	-
qwen3.5-122b-a10b	Alibaba Cloud (International)	Outside mainland China	no	262144	65536	0.40	3.20	0.00	budgets, none to high, default off	-
qwen3-vl-235b-a22b-thinking	Alibaba Cloud (International)	Outside mainland China	no	131072	32768	0.40	4.00	0.00	always on	-
qwen3-vl-235b-a22b-instruct	Alibaba Cloud (International)	Outside mainland China	no	262144	32768	0.40	1.60	0.00	no	-
qwen3-next-80b-a3b-thinking	Alibaba Cloud (International)	Outside mainland China	no	262144	32768	0.15	1.20	0.00	always on	-
qwen3-next-80b-a3b-instruct	Alibaba Cloud (International)	Outside mainland China	no	262144	32768	0.15	1.20	0.00	no	-
qwen3-30b-a3b-thinking-2507	Alibaba Cloud (International)	Outside mainland China	no	262144	32768	0.20	2.40	0.00	always on	-
qwen3-30b-a3b-instruct-2507	Alibaba Cloud (International)	Outside mainland China	no	262144	32768	0.20	0.80	0.00	no	-
qwen3-235b-a22b-thinking-2507	Alibaba Cloud (International)	Outside mainland China	no	262144	131072	0.23	2.30	0.00	always on	-
qwen3-235b-a22b-instruct-2507	Alibaba Cloud (International)	Outside mainland China	no	262144	131072	0.23	0.92	0.00	no	-
deepseek-v4-flash DeepSeek V4 Flash (outside mainland China, via Alibaba Cloud)	Alibaba Cloud (International)	Outside mainland China	no	1M	393216	0.20	0.40	0.04	on or off, default off	-
qwen3.7-plus@alibaba-us Qwen3.7 Plus (US, via Alibaba Cloud)	Alibaba Cloud (US)	US (Virginia)	no	1M	131072	0.32	1.28	0.064	budgets, none to high, default off	-
qwen3.6-flash@alibaba-us Qwen3.6 Flash (US, via Alibaba Cloud)	Alibaba Cloud (US)	US (Virginia)	no	1M	65536	0.25	1.50	0.00	budgets, none to high, default off	-
deepseek-v4-flash-0731@alibaba-intl	Alibaba Cloud (International)	Outside mainland China	no	131072	32768	0.44	1.32	0.088	no	0.22 / 0.66

Balanced

Model	Vendor	Processed in	Auto	Context window	Max output	Input	Output	Cache read	Reasoning	Off-peak input / output
claude-sonnet-5	Anthropic	United States	yes	1M	128K	2.00	10.00	0.20	levels, none to xhigh, default the vendor’s	-
claude-sonnet-4-6	Anthropic	United States	no	1M	128K	3.00	15.00	0.30	levels, none to xhigh, default off	-
gpt-5.4-mini	OpenAI	United States	yes	400K	128K	0.75	4.50	0.075	levels, none to xhigh, default off	-
gpt-5.4	OpenAI	United States	yes	400K	128K	2.50	15.00	0.25	levels, none to xhigh, default off	-
gpt-4.1	OpenAI	United States	no	1M	32768	2.00	8.00	0.50	no	-
gemini-3.8-flash	Google	United States	yes	1M	65536	0.75	3.75	0.075	levels, low to high, default the vendor’s, always reasons	-
gemini-3.5-flash	Google	United States	no	1M	65536	0.75	3.75	0.075	levels, none to high, default off	-
deepseek-flash DeepSeek (China)	DeepSeek	China	yes	1M	393216	0.30	1.20	0.006	levels, none to xhigh, default off	0.15 / 0.60
mistral-large-2512	Mistral AI	Not guaranteed	yes	256K	256K	0.50	1.50	0.05	no	-
codestral-2508	Mistral AI	Not guaranteed	yes	128K	128K	0.30	0.90	0.03	no	-
llama-3.3-70b-instruct-turbo	Together AI	North America	yes	131072	131072	1.04	1.04	0.00	no	-
gpt-oss-120b	Together AI	North America	yes	131072	131072	0.15	0.60	0.00	always on	-
deepseek-flash@together DeepSeek (North America, via Together AI)	Together AI	North America	yes	1M	1M	0.30	1.20	0.006	on or off, default off	-
gpt-5.2	OpenAI	United States	no	400K	128K	1.75	14.00	0.175	levels, none to xhigh, default off	-
gpt-5.1	OpenAI	United States	no	400K	128K	1.25	10.00	0.125	levels, none to high, default off	-
gpt-5	OpenAI	United States	no	400K	128K	1.25	10.00	0.125	levels, minimal to high, default the vendor’s, always reasons	-
o4-mini	OpenAI	United States	no	200K	100K	1.10	4.40	0.275	levels, low to high, default the vendor’s, always reasons	-
o3-mini	OpenAI	United States	no	200K	100K	1.10	4.40	0.55	levels, low to high, default the vendor’s, always reasons	-
gpt-3.5-turbo	OpenAI	United States	no	16385	4096	0.50	1.50	0.00	no	-
claude-sonnet-5-5	Anthropic	United States	no	1M	128K	2.00	10.00	0.10	levels, low to xhigh, default the vendor’s, always reasons	-
claude-sonnet-4-5	Anthropic	United States	no	200K	64K	3.00	15.00	0.30	no	-
gemini-3.7-flash	Google	United States	no	1M	65536	0.75	3.75	0.075	levels, low to high, default the vendor’s, always reasons	-
gemini-3.6-flash	Google	United States	no	1M	65536	0.75	3.75	0.075	levels, none to high, default off	-
gemini-3-flash-preview	Google	United States	no	1M	65536	0.50	3.00	0.05	levels, none to high, default off	-
glm-5.3	Together AI	North America	no	1048575	1048575	1.40	4.40	0.26	always on	-
inkling	Together AI	North America	no	524288	524288	1.00	4.05	0.17	always on	-
glm-5.2	Together AI	North America	no	1048575	1048575	1.40	4.40	0.26	on or off, default off	-
mistral-large-4-0	Mistral AI	Not guaranteed	no	524288	524288	0.68	2.09	0.07	on or off, default off	-
qwen3.8-27b	Alibaba Cloud (International)	Outside mainland China	no	1M	131072	0.50	3.00	0.10	budgets, none to high, default off	-
qwen3.6-max-preview	Alibaba Cloud (International)	Outside mainland China	no	262144	65536	1.30	7.80	0.26	budgets, none to high, default off	-
qwen3.6-27b	Alibaba Cloud (International)	Outside mainland China	no	262144	65536	0.60	3.60	0.00	budgets, none to high, default off	-
qwen3.6-plus	Alibaba Cloud (International)	Outside mainland China	no	1M	65536	0.50	3.00	0.00	budgets, none to high, default off	-
qwen3.5-397b-a17b	Alibaba Cloud (International)	Outside mainland China	no	262144	65536	0.60	3.60	0.00	budgets, none to high, default off	-
deepseek-flash@alibaba-intl DeepSeek (outside mainland China, via Alibaba Cloud)	Alibaba Cloud (International)	Outside mainland China	no	1M	393216	0.30	1.20	0.03	on or off, default off	0.15 / 0.60
glm-5.3@alibaba-intl GLM 5.3 (outside mainland China, via Alibaba Cloud)	Alibaba Cloud (International)	Outside mainland China	no	202752	131072	1.40	4.40	0.00	always on	-
glm-5.2@alibaba-intl GLM 5.2 (outside mainland China, via Alibaba Cloud)	Alibaba Cloud (International)	Outside mainland China	no	202752	131072	1.40	4.40	0.00	budgets, none to high, default off	-
glm-5.2@alibaba-us GLM 5.2 (US, via Alibaba Cloud)	Alibaba Cloud (US)	US (Virginia)	no	202752	131072	1.40	4.40	0.00	budgets, none to high, default off	-
deepseek-v4-pro-0813	Alibaba Cloud (International)	Outside mainland China	no	131072	32768	1.32	3.96	0.264	no	0.66 / 1.98

Powerful

Model	Vendor	Processed in	Auto	Context window	Max output	Input	Output	Cache read	Reasoning	Off-peak input / output
claude-opus-5-5	Anthropic	United States	yes	1M	128K	4.00	20.00	0.20	levels, low to xhigh, default the vendor’s, always reasons	-
claude-opus-5	Anthropic	United States	yes	1M	128K	5.00	25.00	0.50	levels, low to xhigh, default the vendor’s, always reasons	-
claude-opus-4-8	Anthropic	United States	no	1M	128K	5.00	25.00	0.50	levels, none to xhigh, default off	-
gpt-5.5	OpenAI	United States	yes	400K	128K	5.00	30.00	0.50	levels, none to xhigh, default the vendor’s	-
gemini-3.1-pro-preview	Google	United States	yes	200K	65536	2.00	12.00	0.20	levels, low to high, default the vendor’s, always reasons	-
deepseek-v4-pro DeepSeek (China)	DeepSeek	China	yes	1M	393216	1.32	3.96	0.044	levels, none to xhigh, default off	0.66 / 1.98
grok-4.7	xAI	United States	yes	500K	500K	2.20	6.60	0.55	always on	-
mistral-medium-3-5	Mistral AI	Not guaranteed	yes	256K	256K	1.50	7.50	0.15	no	-
deepseek-v4-pro@together DeepSeek (North America, via Together AI)	Together AI	North America	yes	1048576	1048576	1.32	3.96	0.13	on or off, default off	-
gpt-6.1-sol	OpenAI	United States	no	400K	128K	2.00	10.00	0.10	levels, low to xhigh, default the vendor’s, always reasons	-
gpt-6-sol	OpenAI	United States	no	400K	128K	2.00	10.00	0.20	levels, none to xhigh, default the vendor’s	-
gpt-5.6-sol	OpenAI	United States	no	400K	128K	4.00	20.00	0.40	levels, none to xhigh, default the vendor’s	-
gpt-5.6-terra	OpenAI	United States	no	400K	128K	2.00	12.00	0.20	levels, none to xhigh, default the vendor’s	-
o3	OpenAI	United States	no	200K	100K	2.00	8.00	0.50	levels, low to high, default the vendor’s, always reasons	-
gpt-4o	OpenAI	United States	no	128K	16384	2.50	10.00	1.25	no	-
chat-latest	OpenAI	United States	no	400K	128K	5.00	30.00	0.50	no	-
claude-opus-4-7	Anthropic	United States	no	1M	128K	5.00	25.00	0.50	levels, none to xhigh, default off	-
claude-opus-4-6	Anthropic	United States	no	1M	128K	5.00	25.00	0.50	levels, none to xhigh, default off	-
claude-opus-4-5	Anthropic	United States	no	200K	64K	5.00	25.00	0.50	no	-
grok-4.6	xAI	United States	no	500K	500K	2.20	6.60	0.55	always on	-
qwen3.8-2.4t-a95b	Together AI	North America	no	1010K	1010K	2.00	6.00	0.25	always on	-
kimi-k3	Together AI	North America	no	1048576	1048576	2.70	13.50	0.27	on or off, default off	-
qwen3.8-max-0902	Alibaba Cloud (International)	Outside mainland China	no	1M	131072	2.00	6.00	0.40	budgets, none to high, default off	-
qwen3.8-2.4t-a95b@alibaba-intl Qwen3.8 2.4T (outside mainland China, via Alibaba Cloud)	Alibaba Cloud (International)	Outside mainland China	no	1M	131072	2.00	6.00	0.40	always on	-
qwen3.7-max	Alibaba Cloud (International)	Outside mainland China	no	1M	131072	2.50	7.50	0.50	budgets, none to high, default off	-
qwen3.7-max@alibaba-us Qwen3.7 Max (US, via Alibaba Cloud)	Alibaba Cloud (US)	US (Virginia)	no	1M	131072	2.50	7.50	0.50	budgets, none to high, default off	-

Frontier (chosen by auto/best only)

Model	Vendor	Processed in	Auto	Context window	Max output	Input	Output	Cache read	Reasoning
claude-fable-5-1	Anthropic	United States	yes	1M	128K	10.00	50.00	0.25	levels, low to xhigh, default the vendor’s, always reasons
gpt-6-astra	OpenAI	United States	yes	400K	128K	10.00	50.00	1.00	levels, low to xhigh, default the vendor’s, always reasons
o1	OpenAI	United States	no	200K	100K	15.00	60.00	7.50	levels, low to high, default the vendor’s, always reasons
gpt-4-turbo	OpenAI	United States	no	128K	4096	10.00	30.00	0.00	no
gpt-4	OpenAI	United States	no	8192	8192	30.00	60.00	0.00	no
claude-fable-5	Anthropic	United States	no	1M	128K	10.00	50.00	1.00	levels, low to xhigh, default the vendor’s, always reasons

Decision models

Model	Vendor	Processed in	Max input tokens	Input	Output
jev-1.13.0	TypeSafe AI	United States	32K	0.042	0.00

Decision models answer typed questions (fixed choices, yes or no, scores) with calibrated probabilities instead of writing text. They are never chosen by auto; call them by name with response_format: json_schema. Output tokens are free. See Decision models.

Embeddings

Model	Vendor	Processed in	Max input tokens	Input
text-embedding-3-small	OpenAI	United States	8192	0.02
text-embedding-3-large	OpenAI	United States	8192	0.13
gemini-embedding-001	Google	United States	8192	0.20
mistral-embed-2312	Mistral AI	Not guaranteed	8K	0.10

Off-peak: DeepSeek bills half its list price outside peak hours. Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday to Friday, except Chinese public holidays; weekends and those holidays are off-peak all day. Zabio bills the price in force when the call is made.

Off-peak: Alibaba Cloud (International) bills half its list price outside peak hours. Peak hours are 00:00 to 14:00 UTC, Monday to Friday, except Chinese public holidays; weekends and those holidays are off-peak all day. Zabio bills the price in force when the call is made.

Long context: when the prompt of a gpt-5.4 request exceeds 272K tokens, every token of that request is billed at 5.00 input, 22.50 output and 0.50 cache read.

Long context: when the prompt of a gpt-5.5 request exceeds 272K tokens, every token of that request is billed at 10.00 input, 45.00 output and 1.00 cache read.

Long context: when the prompt of a gpt-6-astra request exceeds 272K tokens, every token of that request is billed at 20.00 input, 75.00 output and 2.00 cache read.

Long context: when the prompt of a gemini-3.1-pro-preview request exceeds 200K tokens, every token of that request is billed at 4.00 input, 18.00 output and 0.40 cache read.

Long context: when the prompt of a grok-4.7 request reaches 200K tokens, every token of that request is billed at 4.40 input, 13.20 output and 1.10 cache read.

Long context: when the prompt of a gpt-6.1-sol request exceeds 272K tokens, every token of that request is billed at 4.00 input, 15.00 output and 0.20 cache read.

Long context: when the prompt of a gpt-6-luna request exceeds 272K tokens, every token of that request is billed at 0.20 input, 0.75 output and 0.02 cache read.

Long context: when the prompt of a gpt-6-sol request exceeds 272K tokens, every token of that request is billed at 4.00 input, 15.00 output and 0.40 cache read.

Long context: when the prompt of a gpt-5.6-sol request exceeds 272K tokens, every token of that request is billed at 8.00 input, 30.00 output and 0.80 cache read.

Long context: when the prompt of a gpt-5.6-terra request exceeds 272K tokens, every token of that request is billed at 4.00 input, 18.00 output and 0.40 cache read.

Long context: when the prompt of a gpt-5.6-luna request exceeds 272K tokens, every token of that request is billed at 0.40 input, 1.80 output and 0.04 cache read.

Long context: when the prompt of a grok-4.6 request reaches 200K tokens, every token of that request is billed at 4.40 input, 13.20 output and 1.10 cache read.

Long context: when the prompt of a claude-haiku-5-5 request exceeds 100K tokens, every token of that request is billed at 0.50 input, 2.50 output and 0.05 cache read.

Long context: when the prompt of a qwen3.7-plus request exceeds 256K tokens, every token of that request is billed at 0.96 input, 3.84 output and 0.192 cache read.

Long context: when the prompt of a qwen3.5-plus-2026-04-20 request exceeds 256K tokens, every token of that request is billed at 0.50 input, 3.00 output and 0.00 cache read.

Long context: when the prompt of a qwen3.5-plus-2026-02-15 request exceeds 256K tokens, every token of that request is billed at 0.50 input, 3.00 output and 0.00 cache read.

Long context: when the prompt of a qwen3.6-flash request exceeds 256K tokens, every token of that request is billed at 1.00 input, 4.00 output and 0.20 cache read.

Long context: when the prompt of a qwen3.6-max-preview request exceeds 128K tokens, every token of that request is billed at 2.00 input, 12.00 output and 0.40 cache read.

Long context: when the prompt of a qwen3.6-plus request exceeds 256K tokens, every token of that request is billed at 2.00 input, 6.00 output and 0.00 cache read.

Long context: when the prompt of a qwen3.7-plus@alibaba-us request exceeds 256K tokens, every token of that request is billed at 0.96 input, 3.84 output and 0.192 cache read.

Long context: when the prompt of a qwen3.6-flash@alibaba-us request exceeds 256K tokens, every token of that request is billed at 1.00 input, 4.00 output and 0.00 cache read.

Retired on 2026-10-12, no longer served by the vendor: claude-sonnet-4-5.

Retired on 2026-10-11, no longer served by the vendor: qwen3.6-max-preview, qwen3-vl-235b-a22b-thinking, qwen3-vl-235b-a22b-instruct, qwen3-next-80b-a3b-thinking, qwen3-next-80b-a3b-instruct, qwen3-30b-a3b-thinking-2507, qwen3-30b-a3b-instruct-2507, qwen3-235b-a22b-thinking-2507, qwen3-235b-a22b-instruct-2507, deepseek-v4-flash.

Reasoning: the column says how reasoning_effort maps onto each model (levels the vendor names, a thinking budget per level, on or off, always on, or no reasoning) and what Zabio applies when a request sets nothing; auto chooses the setting with the model. See Models.

Generated on 2026-10-14 from the launch catalog; do not edit.

Some vendors price by time or by request size:

• DeepSeek off-peak. DeepSeek charges half its list price outside peak hours. Peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday to Friday; weekends and Chinese public holidays are off-peak all day. The table shows both prices, and zabio.pricing.off_peak in GET /v1/models carries the off-peak price and the peak hours. Zabio bills the price in force when the call is made, and auto prefers DeepSeek more when it is off-peak. The copies served by Together AI have no off-peak price.
• OpenAI and Google long context. gpt-5.4, gpt-5.5 and gpt-6-astra bill a request whose prompt exceeds 272K input tokens at twice the input and cache rates and 1.5 times the output rate, for the whole request. gemini-3.1-pro-preview bills a request whose prompt exceeds 200K tokens at 4.00 input, 18.00 output and 0.40 cache read. The tiers are shown under the table and in zabio.pricing.long_context, and auto prices every candidate at your prompt’s size, so a long prompt is steered to a model without a surcharge when one is as capable.
• Sales. When a provider sells a model below its list price to everyone, the table shows the sale price and Zabio bills it. When the sale ends, the price returns to the list price.
• Anthropic long context. claude-haiku-5-5 is priced by prompt length: a request whose prompt exceeds 100K tokens (fresh plus cached input) is billed at 0.50 input, 2.50 output and that band’s cache rates (0.05 to read, 0.625 for a 5 minute write, 1.00 for a 1 hour write), for the whole request. The tier is shown under the table and in zabio.pricing.long_context.
• xAI long context. When the prompt of a grok-4.7 request (fresh plus cached input) reaches 200K tokens, every token of that request is billed at the long-context rate, shown under the table and in zabio.pricing.long_context. The prices are those of xAI’s US endpoint, 1.1 times xAI’s list price.

The same data is available as JSON at generated/models.json in the documentation source. Every row carries the list prices above and two objects, flex and batch, one per vendor processing tier. When the model has the tier, the object is {"applies": true, "input_per_mtok": 1.25, "output_per_mtok": 7.5, "cache_read_per_mtok": 0.13} with the prices Zabio bills on it, in USD per million tokens before the fee; when it does not, the object is {"applies": false} and carries no prices. Flex is the slower tier a zabio.deadline of 15 minutes or more asks for (see Flex tier); batch is the price of a line in a batch.

Notes on the 1.1 vendors

• DeepSeek thinking. DeepSeek models think before answering unless told not to. When you send no reasoning_effort, Zabio turns thinking off; send a level to turn it on. DeepSeek knows none, low, high and max: none is off, xhigh is sent as max, and medium and minimal, which it does not have, become low and none. Requests that declare tools, or carry tool calls and results, always run with thinking off, because DeepSeek then requires the model’s earlier reasoning to be sent back, which Zabio does not keep. deepseek-flash accepts images; deepseek-v4-pro does not. Neither supports response_format: json_schema; json_object works.
• grok-4.7 always reasons and bills its reasoning tokens as output tokens, which Zabio includes in usage.completion_tokens. xAI does not take stop on it, so Zabio applies your stop sequences itself; presence_penalty and frequency_penalty are never sent to any model. It refuses images smaller than 8 by 8 pixels or 512 pixels in total.
• Mistral AI. Mistral’s chat models do not reason, except mistral-large-4-0: a reasoning_effort you send to the others is ignored, listed in zabio.ignored_parameters, and zabio.reasoning.applied says not supported. mistral-large-4-0 thinks before answering when asked. Zabio turns its thinking off when you send no reasoning_effort; it knows only off and on, so none turns thinking off and any other level turns it on (zabio.reasoning.applied says on). A conversation can move to a Mistral model mid-way: tool call ids from other vendors are accepted as they are.
• Together AI. Some Together AI models think by default (qwen3.5-9b and the DeepSeek copies). As with DeepSeek’s own API, Zabio turns thinking off unless you send reasoning_effort, and always when the request carries tools; these models only know on and off, so none turns thinking off and any other level turns it on (zabio.reasoning.applied says on). gpt-oss-120b always reasons, whatever the level, so leave room in max_tokens for it.

A note on Gemini output budgets

Gemini models can spend output tokens on internal thinking before they answer. low, medium and high are Google’s own thinking levels, and xhigh maps to high. When you send no reasoning_effort or send none, Zabio turns thinking off where the model allows it (gemini-3.5-flash, gemini-3.6-flash, gemini-3-flash-preview) so your max_tokens goes to the answer; the flash-lite models do not think unless asked. Three models always think, and you should budget for it:

• gemini-3.8-flash and gemini-3.7-flash think at Google’s medium when you set nothing, and none gives their lowest level, low.
• gemini-3.1-pro-preview thinks at Google’s high when you set nothing and needs a few hundred output tokens even for a short answer.

A response with empty content and finish_reason: "length" means the budget was too small.

Sampling parameters by model

temperature, top_p and stop reach the model when it takes them. A model that does not take one never makes the request fail: Zabio leaves the parameter out and names it in zabio.dropped_parameters and the x-zabio-dropped-params header. stop is always honored: where the provider does not take it, Zabio cuts the answer at the first sequence itself, streamed or not. Every model was checked with each parameter on 2026-10-07, and each model added since on the day it was added.

Models	temperature	top_p	stop
OpenAI gpt-5, gpt-5-mini, gpt-5-nano, gpt-5.5, gpt-5.6-sol, gpt-5.6-terra, gpt-5.6-luna, gpt-6-astra, gpt-6-luna, gpt-6-sol, gpt-6.1-sol, o3, o4-mini, chat-latest	dropped	dropped	applied by Zabio
OpenAI o1, o3-mini	dropped	dropped	yes
OpenAI gpt-5.4, gpt-5.4-mini, gpt-5.4-nano, gpt-5.2, gpt-5.1	dropped while reasoning	dropped while reasoning	applied by Zabio
Anthropic Claude 5 models, claude-opus-4-8, claude-opus-4-7	dropped	dropped	yes
Anthropic claude-haiku-4-5, claude-opus-4-5, claude-sonnet-4-5	yes	dropped when temperature is also sent	yes
Anthropic claude-opus-4-6, claude-sonnet-4-6	dropped while thinking	dropped when temperature is also sent, and below 0.95 while thinking	yes
Google Gemini models	dropped (no effect on these models)	dropped (no effect on these models)	yes
xAI grok-4.7 and grok-4.6; Together AI gpt-oss-120b	yes	yes	applied by Zabio
Together AI kimi-k3	yes	dropped below 0.95	yes
Mistral mistral-large-4-0	yes	yes	applied by Zabio while thinking
Every other model	yes	yes	yes

“While reasoning” and “while thinking” mean the setting sent reasons: a reasoning_effort above none, or the setting auto chose for the job.