Claude vs GPT vs Gemini: real cost comparison for your workload
There's no single cheapest LLM API — the winner depends on your token mix. Budget tiers across the three vendors are within pennies per million tokens of each other, so the choice is driven by whether you're input-heavy or output-heavy and which model clears your quality bar. Below is the per-token price table, then three worked examples — a chatbot, a RAG app, and a batch pipeline — showing who's actually cheapest for each.
To run the numbers on your own traffic, use the LLM cost calculator. Otherwise, here's the comparison.
Per-token price, by tier
The most useful way to compare isn't vendor-by-vendor — it's tier-by-tier. Each vendor offers a budget, a mid, and a premium model, and the tier you pick matters far more than the logo on it.
| Model | $ / 1M in | $ / 1M out |
|---|---|---|
| Gemini-class flash budget | 0.10 | 0.40 |
| GPT-class mini budget | 0.15 | 0.60 |
| Claude Haiku 4.5 budget | 1.00 | 5.00 |
| Gemini-class pro mid | 1.25 | 5.00 |
| GPT-class frontier mid/prem | 2.50 | 10.00 |
| Claude Sonnet 5 mid | 3.00 | 15.00 |
| Claude Opus 4.8 premium | 5.00 | 25.00 |
Two things jump out. First, output is ~4–5× input across the board — so a long-answer workload is priced very differently from a retrieval-heavy one. Second, the spread within a vendor is bigger than the spread between vendors: a budget model can be 10–25× cheaper than its premium sibling. Which tier you can get away with is the real cost lever — see how to cut your bill 50%+.
It's not the sticker price — it's your token mix
Because input and output are priced so differently, the "cheapest" model flips depending on the shape of your workload:
- Input-heavy (RAG, long documents, classification): input price dominates. Models with cheap input win.
- Output-heavy (drafting, long chat replies, code generation): output price dominates. Models with cheap output win.
- Balanced (general chat): both matter; the blended rate decides.
That's why a per-token table alone can't answer "which is cheapest for me." The three worked examples below make it concrete.
Worked example 1 — high-volume support chatbot
Balanced, real-time, huge volume
5,000,000 requests/mo · ~800 input · ~250 output tokens each
A customer-support bot handles millions of short exchanges. Volume is enormous but each answer is small, and quality needs to be solid but not frontier. This is the textbook case for a budget tier: the flash/mini models answer these well, and at 5M requests the difference between $0.10 and $5.00 per million input tokens is thousands of dollars a month. Reserve a premium model only for escalations the bot can't handle.
Cheapest: a budget model (flash/mini), with routing to a mid model for hard tickets. Running this on a premium model would multiply the bill by 10× or more for no user-visible gain.
Worked example 2 — RAG knowledge assistant
Input-heavy, moderate volume, quality-sensitive
500,000 requests/mo · ~6,000 input (retrieved context) · ~400 output each
An internal knowledge assistant stuffs several retrieved chunks into each prompt, so input tokens dominate — 6,000 in vs 400 out. Here the input price is what you're really paying, and answer quality on nuanced questions matters. A mid tier (Gemini pro / Claude Sonnet class) is usually the sweet spot: good reasoning, input priced far below premium. Prompt caching helps a lot if the system prompt and instructions are fixed — see lever 02.
Cheapest that's good enough: a mid tier, plus prompt caching and tighter retrieval to shrink the 6,000-token input. A budget model may pass on easy lookups; test it and route.
Worked example 3 — batch document extraction
Input-heavy, not real-time, structured output
2,000,000 docs/mo · ~3,000 input · ~300 output each · results within 24h are fine
Pulling structured fields out of documents overnight is the cheapest workload to run well, because two discounts stack: a budget model handles extraction reliably, and the work isn't real-time so it goes through the Batch API at 50% off. The vendor barely matters here — pick the budget model that extracts your fields most accurately on a sample, then batch it.
Cheapest: a budget model via the Batch API. This can be an order of magnitude cheaper than doing the same extraction real-time on a premium model.
Run these numbers on your traffic
Plug your requests, input and output tokens into the calculator, edit any price to match today's rates, and see every model ranked cheapest-first for your workload.
Open the calculator →When the pricier model is worth it
Cheaper isn't free if it fails. A premium model earns its price when a mistake is expensive or the task is genuinely hard:
- Complex, multi-step reasoning or long-horizon agents where a wrong turn compounds.
- Code generation and review where subtle bugs are costly.
- High-stakes outputs (legal, medical, financial) where an error carries real liability.
- Anywhere a cheaper model measurably fails your evals.
The right mental model isn't "which vendor is cheapest" — it's "what's the cheapest tier that passes my quality bar on each task," then route accordingly.
Bottom line
Don't choose a vendor on sticker price. Choose the tier per task, verify quality on your own data, and route the easy majority of traffic to a budget or mid model. That decision moves your bill far more than Claude-vs-GPT-vs-Gemini ever will — and all three vendors reward it.
Automate the routing
A routing layer picks the cheapest capable model per request, so you get the tiering benefit above without hand-choosing a model each call.
Compare routing tools →FAQ
Which LLM API is cheapest overall?
None universally — budget tiers across the vendors are within pennies per million tokens, so the cheapest for you depends on your input/output ratio and which model meets your quality bar.
Is Claude more expensive than GPT?
At the premium tier they're broadly comparable per token. The bigger decision is which tier you use — a budget model can be 10–25× cheaper than a premium one from the same vendor.
Why does output cost more than input?
Generating tokens is more compute-intensive than reading them, so all three vendors price output roughly 4–5× higher. Output-heavy workloads are therefore dominated by output cost.