Every "which model is cheapest" post compares price per million tokens. That number is easy to find and almost useless for deciding what to run.

So I measured the thing that actually shows up on a bill: what one request costs, on three task shapes, across three model families. Everything below comes from the usage fields the API returned, not from a price list.

Method

Same endpoint, same key, same three prompts, three runs each, reporting the median.

• short — "In one sentence, what is a prompt cache?" (a chat reply you'd get from any assistant)
• code — "Write a Python function that validates an email with a regex. Only code." (a small, well-scoped generation)
• long — a ~400-token input asking for a three-sentence summary (input-heavy, output-light)

Cost per request = input tokens × input rate + output tokens × output rate.

The numbers

Finding 1: the "cheap" model cost 70% more

On paper deepseek-flash is $0.68 in / $2.75 out per million. glm-5.3 is $3.50 / $11.00 — 5x on input and 4x on output in the price table.

On the code task, the expensive model was half the price per request.

The reason is in the output column: 509 tokens versus 68 for the same prompt, producing a function of similar length. The cheap-per-token model simply wrote more — explanation, alternatives, a docstring you didn't ask for. You pay for all of it at the output rate, which is 4× the input rate.

Per-million pricing assumes every model emits the same number of tokens for the same request. They don't.

Finding 2: output is the bill, not input

Take the two extremes:

• deepseek-flash, code task: 45 input tokens, 509 output. 97% of the cost was output.
• glm-5.3, long task: 378 input tokens, 70 output. 37% of the cost was output.

So "input is cheap, right?" depends entirely on what the model does after reading it. A 400-token input is almost free; a model that answers it in 700 tokens is not.

This is also why "summarise this document" and "write me a function" have completely different economics even though both are one API call.

Finding 3: latency follows output too

Median wall time on the short task: 1.0s (deepseek-flash), 2.2s (glm-5.3), 1.3s (kimi-k2.6). On the code task, 1.5–2.9s.

The slow requests were always the ones emitting a lot of tokens, never the ones with a long input. If a call feels like it's hanging, look at the output length before you blame the network.

What I'd actually do with this

1. Measure your own three shapes. Take three prompts that represent the bulk of your traffic — a short one, a generation one, an input-heavy one — and log usage for each. Ten minutes of work, and it replaces every "cheapest model" list you've read.
2. Route by task, not by model ranking. A short classification call and a 2,000-token refactor are different purchases. One model winning the first says nothing about the second.
3. Watch output length, not just rate. If a prompt starts producing noticeably longer answers after a model update, your bill moves even though the price per million didn't.
4. Check variance before you trust a number. On one model, the code task varied 2.5× across consecutive runs of the identical prompt. A single measurement is an anecdote, which is why the table above is medians of three.

Reproduce it

Any OpenAI-compatible endpoint returns the fields you need:

curl https://api.switchllm.net/v1/chat/completions \
  -H "Authorization: Bearer $SWITCHLLM_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-flash",
    "messages": [{"role": "user", "content": "In one sentence, what is a prompt cache?"}]
  }'

The usage object in the response has prompt_tokens and completion_tokens. Multiply by your provider's rates and you have the real cost of that request. Log those two numbers for a day and you'll know more about your bill than any comparison table can tell you.

Caveats

• One run per cell, three repetitions, medians. Variance is real — see point 4 above.
• Rates are the ones on the endpoint I used, at the time of writing. Your provider's rates will differ; the shape of the finding is what generalises.
• The prompts are synthetic and small. Real application prompts are longer and messier, and a single number per task hides a wide distribution.
• Provider-side caching, if enabled, changes input costs substantially and is not reflected here.

Disclosure

I run SwitchLLM — the OpenAI-compatible endpoint these measurements were taken on. One key for DeepSeek, GLM and Kimi, prepaid from $9.9, sign-up with an email address.

Everything above is the advice I'd give you on someone else's platform: the point is that per-million pricing doesn't tell you what a request costs, and the only way to know is to measure yours.

The models stopped being the hard part a while ago. Signing up is the hard part, and it fails in three separate places:

1. A phone number you don't have. Some platforms only accept a mobile number registered in one country. Virtual numbers get flagged within minutes, and then you're locked out of the account you were trying to create.
2. An identity check before billing. Some platforms won't let you add credit until you've uploaded an ID document. Reasonable if you're in that market, a dead end if you're not.
3. A card that gets declined. Even where signup works, AI and API merchants are routinely declined on foreign cards — especially on smaller banks and on prepaid or virtual cards.

Any one of those is enough to stop you. They tend to arrive together.

The four routes that actually exist

People jump straight to the last row, which is the most expensive way to get a worse answer. Work down the table instead.

Six things to check before you prepay anyone

This applies to us as much as to anyone else.

1. What's the minimum top-up? If the cheapest way to evaluate a provider is $20, keep looking. You should be able to test the latency from your own city for pocket change.
2. Prepaid, or subscription? Subscriptions fail at renewal for reasons that have nothing to do with you: an expired card, a re-authentication rule, a merchant flagged as high-risk. A prepaid balance cannot fail at renewal.
3. Is it genuinely OpenAI-compatible? "Compatible" should mean you change base_url and the key, and nothing else. Ask for the exact endpoint before you pay.
4. What happens if the credit doesn't land? The honest answer is "email us and we check the payment record against your account". The suspicious answer is "it's fully automatic, don't worry".
5. Does the balance expire? Look for the exact wording, not the marketing version of it.
6. Can you spend it down and leave? No minimum commitment, no auto-renew, no cancellation maze. If you can't leave, you're not a customer, you're a subscriber.

The integration is the boring part, which is good

If the endpoint is OpenAI-compatible, migration is two lines:

curl https://api.switchllm.net/v1/chat/completions \
  -H "Authorization: Bearer $SWITCHLLM_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-flash",
    "messages": [{"role": "user", "content": "hello"}]
  }'

Or with the standard SDK:

from openai import OpenAI
import os

client = OpenAI(
    base_url="https://api.switchllm.net/v1",
    api_key=os.environ["SWITCHLLM_KEY"],
)

print(client.chat.completions.create(
    model="deepseek-flash",
    messages=[{"role": "user", "content": "hello"}],
).choices[0].message.content)

Everything downstream keeps working, because they all speak this format: Cursor, Cline, LangChain, your own loop.

The cost math, without the marketing

Credit packs are one-time purchases from $9.9. Nothing renews.

A project making 300 calls a day costs about $0.36 a month on the cheapest model listed, about $10 a month on deepseek-flash, and about $45 a month on the largest model on the site. Those figures are just the published per-million rates multiplied out — 9,000 calls a month times the cost per request. You can redo the arithmetic from the pricing page instead of trusting me.

The point isn't that it's cheap. It's that the bill is small enough to predict, and you can stop by simply not topping up.

Disclosure

I run SwitchLLM — the third row of that table. One key for DeepSeek, GLM and Kimi behind an OpenAI-compatible endpoint, prepaid from $9.9, sign-up with an email address. New accounts get a small trial balance to test the integration before paying anything.

If a card works for you and the providers you want don't put a phone check and an ID check in your way, buying direct is cheaper and you should do that. This post is for the case where they do.

If you want your own numbers

Send me the shape of your sessions — turn counts, or a sample of request logs with the text stripped out — and I'll run the same three variants against your distribution and send back the table.

It costs me an afternoon and a few cents of tokens, and it's the only way I get to see sessions that aren't mine. support@switchllm.net