Billing

Zabio is prepaid. You add credits in US dollars, every call is debited from the balance, and requests stop when the balance runs out. There are no subscriptions and no fees on top-ups.

What a call costs

Every call is billed at the provider’s list price plus Zabio’s fees, each shown as its own line:

• a service fee of (see the pricing page) on the provider price of every call;
• on every auto request, a fixed (see the pricing page), the price of automatic model choice. It is paid once per request, whatever happens inside it: a classification reused from the same session, Smart Splitting’s two calls, a check that moved the answer up a band, zabio_escalate, or an answer by Jev. Every auto line of a batch and every auto background response is one request.

A call to a model you name also pays (see the pricing page). A call to a model you name pays the service fee only.

We take no cut of what routing saves you: every cent of the saving stays with you. The fees in force, and any change that is coming, are on the pricing page. A fee that goes up is announced at least 30 days ahead, by email to every organization owner; a fee that goes down can take effect at once.

The saving. Every response also shows what the same call would have cost going direct, so you can see what routing saved:

• for a model you named, that same model at the same price, so there is no saving and the fees show as a small negative saving;
• for auto, your key’s baseline model with the same tokens, cache reads and cache writes at that model’s own rates, whatever vendor served the call. Where the baseline model’s vendor has no prompt cache (Google and Together AI today), the baseline is priced uncached, because that is what you would have paid there. The baseline model is the one your key used at the 95th percentile of list price per token over the last 30 days: your calls are ordered by that price, the most expensive 5 percent are set aside so a burst does not count, and the next one sets the baseline. It is recomputed every night from your own traffic, so it follows what your hardest jobs needed. The rule needs 20 successful calls before it sets a baseline: under 20, the 5 percent set aside is zero calls, and one expensive call would set your baseline on its own. Until then a new key’s calls are their own baseline and show no saving; the dashboard and zabio.cost.baseline show how many calls are done, and the baseline is set usually within an hour of the 20th call.

A cache discount is never counted as a saving: the baseline keeps the cache you would have had there too.

Every response shows the numbers in zabio.cost: vendor_micros, service_fee_micros, call_fee_micros (the fixed fee of an auto request, the price of automatic model choice), direct_micros (the baseline) and saved_micros (left out while a new key’s baseline is pending; such calls count no saving in any total either, even after the baseline is set). savings_fee_micros and classifier_micros always read 0 (see The classifier); they stay so code that reads them keeps working. Amounts are in micros: 1,000,000 micros is one US dollar.

Worked example

You send a short request with model: "auto". The classifier finds an easy job and the balanced line takes a cheap model; your key’s baseline over the last 30 days is GPT-5.5. The fee lines follow the plan in force.

Line	Amount
Provider list price of the call (vendor_micros)	0.0100 USD
Service fee on the provider price (service_fee_micros)	(see the pricing page)
Automatic model choice (call_fee_micros)	(see the pricing page)
Billed (cost_micros)	(see the pricing page)
Baseline: the same tokens on your key’s baseline model, GPT-5.5 (direct_micros)	0.0500 USD
You saved (saved_micros)	(see the pricing page)

The same request sent with model: "gpt-5.5" directly would bill (see the pricing page), with the service fee as a small negative saving.

A cached call, with illustrative prices. Ten turns into the same conversation, 18,000 tokens of history sit in the provider’s prompt cache and are read at a tenth of the input price:

Line	Amount
Provider list price of the call, 18,000 cached tokens at the cache read rate plus the new tokens (vendor_micros)	0.0040 USD
Billed (cost_micros)	(see the pricing page)
Baseline: the same tokens on GPT-5.5 with the same 18,000 tokens read from its cache, at its cache rates (direct_micros)	0.0200 USD
You saved (saved_micros)	(see the pricing page)

The baseline keeps the cache because you would have had it on GPT-5.5 too. Priced without it, the same tokens on GPT-5.5 would be 0.0900 USD, and the saving would look larger only because of a discount the provider gave you.

A split request

Under auto, a big request whose question needs only part of its source can be answered in two steps, an extract on a cheap model and an answer on the routed model (see Split and route). The two calls are billed at their providers’ list prices as two calls of one request: the service fee on both, and the request’s one fee for automatic model choice. The saving is measured against the whole request as you sent it, on your key’s baseline model, with no cache, because the source was never in any cache. While your key has no baseline yet, the model that answered stands in for it, so a split shows its own saving. The classifier, the questions and the check Zabio ran to decide the split are Zabio’s own cost and never billed.

Illustrative prices. You send a 30,000-token contract with a question about one clause; routing picks a model at 4 USD per million input tokens, which is also your key’s baseline; the extract runs on a model at 0.20 USD per million; the answer is the same length on both paths, say 0.0100 USD of output.

Line	Amount
Provider list price of the extract: 30,000 tokens in at 0.20 USD per million, plus a short output	0.0070 USD
Provider list price of the answer on the excerpt: about 2,000 tokens in at 4 USD per million, plus the output	0.0180 USD
Provider price of the request, both calls (vendor_micros)	0.0250 USD
Billed (cost_micros)	(see the pricing page)
Baseline: the whole request, 30,000 tokens in plus the output, on your baseline model, no cache (direct_micros)	0.1300 USD
You saved (saved_micros)	(see the pricing page)

The same request sent whole would bill (see the pricing page). zabio.cost on a split request reports these totals, and zabio.split.steps lists each call with its price; the questions and the check appear there with billed: false.

When a split falls back to the full source, whatever the reason, you pay exactly what the unsplit call costs: the extract and the check Zabio ran are Zabio’s cost, listed in zabio.split.steps with billed: false, and zabio.cost is the ordinary breakdown of the one call that answered. With your own vendor key, the extract runs on it when the key covers the extractor’s vendor, like any call.

A classification job answered by Jev

Under auto, a classification job with a strict JSON schema may be answered by Jev (jev-1.13.0) instead of the routed text model, when Zabio’s estimate says Jev is cheaper (see Classification jobs on auto). The call is billed as any auto call: Jev’s list price (0.042 USD per million input tokens, output free), the service fee on it, and the request’s one fee for automatic model choice. The saving is measured against your key’s baseline model on the request as you sent it, its input and the answer’s length, not on TypeSafe’s own token count, which includes the questions Zabio builds from your schema.

When Jev’s answer is discarded (a field under the threshold, or a failed call), you pay exactly what the text model’s call costs, as if Jev had never been asked; the Jev call is Zabio’s cost and does not appear in zabio.cost.

A flex call

A request with a zabio.deadline of 15 minutes or more can be served on the vendor’s flex tier where the model has one (see Flex tier): the same model at about half the list price. The call is billed at the flex price the vendor charged, plus the usual fees. The saving is measured against the flex price of your key’s baseline model, or against its standard price when that model has no flex tier, because that is what you would have paid there: the vendor’s own discount is never counted as a saving.

When the vendor refuses a flex request for capacity, Zabio serves the same model at the standard tier and bills the standard price, measured against your baseline model at its standard price; zabio.tier.fallback says capacity.

A batched line

A line of a batch is billed like a call served at the vendor’s batch price, the rate the vendor’s batch API charges, about half of the list price, plus the usual fees: every auto line is one request and pays the fee for automatic model choice once. The saving is measured against the batch price of your key’s baseline model, or its standard price when that model has no batch tier, because that is what you would have paid there.

When the batch is accepted, an estimate of its cost, fees included, is set aside on your balance, the hold, and released as lines are billed; the hold is only the estimate, and each line is billed for the tokens it really used. If the estimate exceeds your available balance, the batch is refused at creation with insufficient_credits and nothing is billed. A running batch is never stopped for money.

The classifier

When you send auto, a small, fast model reads the request and names the job: its task type, difficulty and stakes. The fee for automatic model choice is the price of that step and of picking the model; the classifier’s own call is never passed on to you. The response names the classifier that ran in zabio.routing.classifier. classifier_micros stays in zabio.cost and always reads 0, so code that reads it keeps working. Before version 1.2.6 the classifier’s cost was passed on to you at the provider’s price, and the dashboard still shows that line for those days.

Calls served with your own vendor keys pay no service fee; their auto requests pay the fee for automatic model choice. See Own keys.

Every fee and the minimum top-up are a versioned pricing plan. The plan in force is on the pricing page, on the Billing page and in zabio billing. A plan change never rewrites past calls or top-ups: each keeps the version it was billed under.

Answers Zabio checks

On a request that is not streamed, Zabio checks the answer against what the request asked for: JSON that matches your response_format schema, a JSON object for json_object, tool calls that name one of your tools with arguments that match its parameters, and an answer that is not empty because the model used its whole output budget thinking. When auto sends a failed answer once more, to a stronger model or to a model that reasons by default, you pay only for the answer you receive: the failed attempt is Zabio’s cost and is not in zabio.cost. zabio.escalated_from then names the first model. Streamed requests are not checked, because the answer reaches you while it is being written. See Checked answers.

The Free plan

A new organization starts on the Free plan: no credit card, no trial credit, and no expiry. Free is one organization per person: the first organization you create has the Free allowance; a second one needs a top-up before its first call. A Free organization has one member and two API keys (the keys of connected AI apps do not count). Every feature paid accounts have is included: streaming, tools, JSON output, Smart Splitting, Jev, batches, flex and background responses.

The limits, per organization:

Limit	Value
Requests a day	100 successful requests, reset at 00:00 UTC. Failed calls do not count
Requests a minute	20
Request size	16,000 input tokens and 2,000 output tokens. An unset max_tokens is capped at 2,000; a larger one is refused
Batches	each line of a batch counts as one request, with the same size limit

Free accounts also have a daily fair-use limit on what their calls cost Zabio. Normal use never reaches it; when it is reached the API answers 429 free_tier_limit with param: daily_cost, says when it resets, and resumes at 00:00 UTC. Over any limit the response names the limit in param and in the x-zabio-free-limit header, carries Retry-After when the limit resets, and ends with the one thing that removes every limit: a top-up. See Errors.

The free models. Free calls run on the free model list: today gpt-oss-120b and DeepSeek Flash at Together AI (North America), mistral-small-2603, gpt-5.4-nano, qwen3.5-9b and gemini-3.5-flash-lite, served by the vendors themselves under their standard API terms, which do not train on your data. The list is live at GET https://api.zabio.ai/v1/public/free-tier, with no key, and GET /v1/models marks each model with zabio.free_tier. auto, auto/cheap, auto/balanced and auto/best keep working and choose among the free models; on auto, the response’s zabio.plan.paid_would_use says which model a paid account would have been given, when it differs.

Locked models. Every other model stays visible, in the dashboard, in the Playground and in GET /v1/models (zabio.availability: locked), and is locked: a request that names one answers 403 free_tier_model, “Top up your account to unlock this model”. Named models you serve with your own vendor key are not locked.

What every Free response says. x-zabio-plan: free, the day’s requests in x-ratelimit-limit-requests-day, x-ratelimit-remaining-requests-day and x-ratelimit-reset-requests-day, the minute bucket in x-ratelimit-*-requests, and a zabio.plan object (tier: free, reason: free_plan, paid_would_use on auto, topup_url). The dashboard shows today’s requests against the limit and the time to the reset.

Any credit removes every limit. From the first top-up on, or from any other credit in your balance (a referral reward, the match, credit we add to your account), every model is unlocked, there are no daily request or size limits, the member and key caps are lifted, and you pay as you go at the prices above. There is no plan to pick and nothing to cancel.

When a paid account’s balance reaches zero, it falls back to the Free limits instead of stopping: zabio.plan.reason is zero_balance, the dashboard shows a banner, and the owners and admins get an email. Nothing is taken away: your keys and members stay; only the usage limits apply until the next top-up. If you would rather have requests stop at zero, the organization’s settings offer “stop all requests until the next top-up” (zero_balance: stop on the API). A small negative balance from the last call overshooting counts as zero and is settled from the next top-up.

Adding credits

Credits are bought through Stripe from the Billing page (the payment form opens inside the page) or with zabio billing topup --amount 50, which opens Stripe’s payment page. Rules:

• minimum (see the pricing page) per top-up, maximum 5,000.00 USD per payment;
• amounts in whole cents;
• no fee on top-ups: 50.00 USD paid is 50.00 USD of credit;the top-up fees on the pricing page are taken off the credit, and the payment form shows the fee and the credit before you pay;
• new accounts can add up to 50.00 USD per payment until two payments have cleared or the account is 30 days old; the form says so while it applies;
• the balance updates as soon as Stripe confirms the payment, usually within seconds. If your browser lost the confirmation page, the Billing page checks the payment when you return;
• the payer receives a receipt by email with the amount, the new balance and the billing details.

Billing details

Your first top-up asks for the billing name (a person or a company), the country, the address, the city, the state or region where the country has one, and the postal code, plus an optional tax ID (VAT, EIN) for your invoices. Stripe keeps them on your customer record and Zabio prints them on every receipt. You can see and edit them any time in Billing settings; nothing is asked at sign-up or on the Free plan.

Saved cards and one-click top-ups

When you add credits you can tick “Save this card for one-click top-ups and automatic recharge”. Stripe keeps the card; Zabio stores only the brand, the last four digits and the expiry, and lists the card on the Billing page, where owners and admins can make it the default or remove it. With a saved card, Add credits offers “Pay with Visa 4242” and charges the card at once; if your bank asks you to confirm the payment (3D Secure), the confirmation opens in the page and the credits are added when it completes. A declined payment says why (insufficient funds, expired card, and so on) and nothing is charged.

Card numbers never touch Zabio. The payment form and the saved cards are Stripe’s; Zabio sees the result of each payment and your Stripe customer id.

Automatic recharge

Off unless you turn it on. On the Billing page an owner or admin sets the balance below which Zabio recharges, the amount it adds each time (at least the minimum top-up) and a monthly cap (200.00 USD unless you change it), and picks the saved card. Automatic recharge can be turned on after your first top-up, with a saved card. It is checked after each billed call, so a recharge usually lands before the balance reaches zero; when it cannot, your organization runs on the Free limits until it does. Each recharge sends you a receipt by email. If your bank asks you to confirm a charge, you get a link to confirm it and nothing else is attempted until you do; if a charge fails, Zabio retries once an hour later, then pauses automatic recharge and emails you; reaching the monthly cap pauses it until the next month and emails you. A disputed payment switches it off. You can change the settings, pause or turn it off at any time; the Billing page shows what was added this month.

Disputes

If a card payment is disputed with the bank, the organization is suspended at once, its API keys stop working and the Zabio team reviews the dispute before anything else happens. If you believe a charge was wrong, write to support first: a refund through Stripe reduces your balance and nothing is suspended.

Moving credit between your organizations

Balances are per organization. If you own more than one, you can move paid credit from one to another on the Billing page of the sending organization (owners only, from the web app). The rules:

• only paid credit moves: credit you bought with a top-up, or credit moved to you. Trial, promotional, referral and match credit stays where it was granted;
• only paid credit at least 7 days old moves, and credit you receive waits its own 7 days before it can move on;
• the amount is at most what is left of that credit within your balance. When a balance mixes paid and promotional credit, your spending is taken to have used the promotional credit first, so what can move is never more than the paid credit you still hold;
• one transfer a day per sending organization, at least 1.00 USD;
• nothing moves while either organization is suspended or has a payment under review.

A transfer is not a payment: nothing is charged, the receiving organization’s “added in total” does not change, and it does not count as a first top-up for the limits on new accounts. The receiving organization runs on the paid plan while it holds the credit, with every model and no Free limits. Both ledgers show the movement as transfer_out and transfer_in, and the recent transfers are listed on the Billing page of each side.

The ledger

Every movement is a line in the ledger (Billing page, or zabio billing ledger): topup, trial, usage (the day’s calls, written daily), refund, adjustment, transfer_out and transfer_in. Each line carries the signed amount, the balance after it, and a reference such as the Stripe session id. Call level usage can be exported as CSV from the dashboard.

Low balance warnings

Owners and admins receive an email when the balance falls below 20 percent of the last top-up and again below 5 percent. At zero, an organization that continues on the free tier gets the free-tier email (what the limits are, how to top up) and another when a top-up takes it back; one set to stop gets the exhausted notice instead. Each level mails once; any credit added resets the warnings.

What happens at zero

When the balance is at or below zero, the organization runs on the Free limits described above: auto and the free models keep answering, within the daily limits, and every response says so in zabio.plan. A single call already admitted may take the balance slightly negative; that counts as zero. Calls to a named model that your own vendor key serves keep working without limits, because Zabio has no provider cost on them.

Requests are refused with 402 insufficient_credits only in two cases: the organization is set to stop at zero, or it is a person’s second organization, which has no Free allowance. In both, named models on your own vendor keys still work; auto does not, because the classifier runs on Zabio’s key, and neither does a stored conversation that needs compaction, whatever model the turn names, because the summary runs on Zabio. Add credits, or move paid credit from another organization you own, and everything resumes immediately.

Refunds

Refunds are handled through Stripe. When a payment is refunded, the ledger receives a refund line for the amount and the balance goes down accordingly. Write to support with the Stripe session id or the ledger reference if you need a refund.

Spend controls

Beyond the balance, you can cap spend where it happens:

• a spend limit per API key, reset every day, week or month, or set for the key’s whole life;
• a monthly quota per member, applied to every key that member created;
• requests per minute and tokens per minute limits per key.

When a cap is reached, calls on that key return 429 quota_exceeded until the next calendar month. See Teams and Errors.