Start from the bill you already have

A model bill has fewer lines than it looks like

Almost every invoice for a language model resolves to three numbers multiplied by three rates: tokens you sent, tokens you sent again, and tokens the model wrote back. Everything else on the page is a subtotal of those. That is unusually good news, because it means the bill can be re-priced exactly rather than estimated — you do not need a pilot, a trial quarter or a migration to find out what a different rate card would have charged you for the month that already happened.

The reason the bill can drop at all is narrower than it sounds. We resell open-weight models only, which means the licence permits somebody other than the publisher to host the weights, which in turn means the cost base is inference capacity rather than a wholesale contract with a markup on top. Capacity bought in volume and run at high utilisation costs less than the publisher's list price, and most of that difference is passed through instead of held as margin.

That is the whole mechanism, and it has a ceiling. It applies to open-weight models and to nothing else: there is no version of this that makes a closed frontier model cheaper, because no licence exists that would let us host one. If your bill is mostly closed-model traffic, the honest answer is that only the portion you could move to an open-weight model is addressable here, and the calculator further down will tell you what that portion is worth.

The same month, at both rate cards

Below is every text model we can actually serve today, priced against its own publisher's list rate. Kimi K3 is $1.85/M input and $9.00/M output where the publisher charges $3.00/M and $15.00/M. GLM-5.2 is $0.82/M and $2.55/M against $1.40/M and $4.40/M. Neither figure is a promotional rate, and neither expires.

The output column is where the difference compounds, because output is billed several times higher than input on every model in the catalogue and a generation-heavy application spends most of its money there. The input column matters more if you are summarising, retrieving or classifying, where the prompt dwarfs the completion.

The table excludes cached input entirely, so it understates what a repeated-prefix workload would pay. The cached column is published per model on the pricing page and is applied automatically — there is no header to set and no plan to be on.

Put your own numbers in

The figures above are ours. The ones that matter are yours, so the calculator takes the two numbers you can read off any invoice — input tokens and output tokens for the month — and prices them across every model we serve, against the publisher's rate and against whichever third-party rate we hold a verified figure for.

The cache slider is the control worth spending a minute on. Set it to zero for a workload where every prompt is different. Push it up if you resend a fixed system prompt, a tool schema or a document on every call, because that prefix is billed at the cached rate and it is usually the largest single line on the bill.

From this page to a lower bill, in three steps

Nothing here requires a rewrite, a meeting or a contract. The API is OpenAI-compatible, so the SDK you already have is the SDK you keep.

1. 1

   Point the client at a different base URL

   One constructor argument in Python or Node, one flag in cURL. Request shapes, streaming frames, the usage block and the error envelope all match what your code already parses, so nothing downstream of the client has to be touched.

2. 2

   Change the model id

   Model ids are namespaced by publisher — z-ai/glm-5.2, moonshotai/kimi-k3 — and the bare name is accepted too, so an id you already had keeps resolving. Every model page carries a snippet with the id filled in.

3. 3

   Run it beside the old path before you cut over

   Send a slice of traffic to the new base URL, compare outputs and cost per request in the dashboard, and move the rest when the numbers hold. Your prepaid balance is a hard ceiling while you do it, so an experiment cannot become an invoice.

from openai import OpenAI

client = OpenAI(
    api_key="YOUR_API_KEY",
    base_url="https://router.xark.io/api/v1"   # ← the only line that changes
)

response = client.chat.completions.create(
    model="z-ai/glm-5.2",
    messages=[{"role": "user", "content": "Hello"}]
)

New accounts start with $5 in credit and no card, which is enough to run the comparison above before you decide anything.

What this page is not claiming

We are not claiming to be the cheapest API you can find. Someone will always be running a promotional rate on a model this week, and a claim like that would be false by the time the ad had finished serving. The claim is narrower and checkable: every model here is priced below what its own publisher charges for it, and both numbers are printed on the same row so you can verify it rather than trust it.

The floor under that is published rather than implied. We guarantee at least 20% below the model publisher's own rate on every model we serve. The smallest discount in the catalogue today is 36%, so the guarantee has room in it by design.

Availability is stated, not discovered

24 models are catalogued and 7 are callable right now. The rest carry a published price and a marker saying no upstream serves them yet, because finding that out from a runtime error after you have written the integration is worse than reading it here.

No cross-model substitution

If a model is unavailable the request fails with the upstream status and a machine-readable code. We do not silently answer with a different model, because that changes the output, the price and the licence terms of what you receive.

No platform fee

The per-model rate is the whole price. No fee on credit purchases, no minimum spend, no charge for failed requests.

Where the money actually goes

Take the reference workload this site quotes its agent figure on — 400M input tokens a month with a 60% repeated prefix, and 8M output. Priced on GLM-5.2, that month costs $190, and the largest slice of it is not the output. It is the same prompt prefix, sent again on every turn, billed at the cached rate of $0.16/M instead of the standard $0.82/M.

That is why a bill can look mysterious. Teams reason about model spend in terms of what the model writes, because that is the part they read, and then find the invoice dominated by the part they never look at. If your application resends a system prompt, a tool schema, a few retrieved documents or a conversation history on every call, most of your bill is already prefix — and the cached rate is the lever with the most travel in it.

The questions that come next

Written to be read in order, from the quickest objection to the most expensive one.