Open the pricing page for almost any frontier model and you’ll see two numbers, with the output (generation) price several times higher than the input (prompt) price. It’s not arbitrary, and it’s remarkably consistent. From our 2026-07-14 snapshot:
| Model | Input / 1M | Output / 1M | Output ÷ Input |
|---|---|---|---|
| GPT-5.6 Terra | $2.50 | $15.00 | 6.0× |
| GPT-5.6 Luna | $1.00 | $6.00 | 6.0× |
| Gemini 3.1 Pro Preview | $2.00 | $12.00 | 6.0× |
| Gemini 3.5 Flash | $1.50 | $9.00 | 6.0× |
| Claude Opus 4.8 | $5.00 | $25.00 | 5.0× |
| Claude Sonnet 5 | $2.00 | $10.00 | 5.0× |
| Claude Haiku 4.5 | $1.00 | $5.00 | 5.0× |
OpenAI and Google cluster at 6×, Anthropic at a flat 5×. Different labs, same shape. Why?
The technical reason: output is serial, input is parallel
When you send a prompt, the model processes the entire thing in one forward pass — all the input tokens are read together, in parallel, and the hardware stays busy. This is the “prefill” phase, and it’s cheap per token because it’s efficient.
Generating a response is different. The model produces one token at a time, and each new token requires another full pass through the network that depends on every token before it. This is “decode,” and it’s inherently serial. Each output token holds expensive accelerator memory and can’t be batched as tightly as prefill. You’re paying for time on hardware that can’t be kept as full.
So the price gap is really a compute-shape gap: reading is parallel and cheap, writing is sequential and expensive. The 5–6× multiplier is the market pricing that difference in.
Why the ratio is so uniform
If the cause were purely technical you’d expect more variation — different architectures, different serving stacks. The tight clustering (everyone at 5× or 6×) suggests the labs are also anchoring to each other. Once the category settled on “output is a handful of times pricier than input,” each new model priced into that expectation. It’s part physics, part convention. Either way, it’s stable enough to plan around.
What it means for what you build
The multiplier isn’t trivia — it should change design decisions, because the expensive stream is the one you control least directly.
1. Verbose outputs are where your money leaks. A model that pads answers with restatements and boilerplate is burning your most expensive tokens. “Answer in one sentence” or a tight output schema isn’t just UX — on Claude Opus 4.8 it’s the difference between $25 and a fraction of it per million generated tokens. Trimming 200 wasted output tokens per call saves more than trimming 1,000 input tokens.
2. Input-heavy workloads are cheaper than they look. RAG and long-context summarization feel expensive because you’re shoving huge documents into the prompt. But that’s the cheap stream. Stuffing 20,000 tokens of context to get a 300-token answer, on GPT-5.6 Terra, costs $0.05 for the input and less than half a cent for the output. The context you fretted about is nearly all of the tokens — but billed at the low input rate, the whole call still lands around a nickel. Caching that context (below) makes it cheaper still.
3. Reasoning models invert the assumption. Models that “think” before answering bill that hidden reasoning as output. A short visible answer can hide thousands of expensive output tokens. If you use one, your bill is driven by the pricey side of the ledger — watch it closely, and don’t assume a terse reply means a cheap call.
4. Structured extraction is the sweet spot. Classification, tagging, routing, and field extraction take large input and emit tiny output — they sit on the favorable side of the ratio. If you can turn a task into “big prompt in, small structured answer out,” you’re optimizing for how these APIs are actually priced.
The exceptions worth knowing
The 5–6× rule holds for mainstream chat and reasoning models, but the extremes break it:
- Premium “pro” tiers widen the gap. OpenAI’s o1-pro sits at $150 input / $600 output — a 4× input-to-output ratio, but an absolute output price 40× higher than GPT-5.6 Terra’s $15. At that tier you pay for every generated token dearly.
- Budget models compress it. The cheapest models in our index — Llama 3.1 8B, Mistral Nemo, Ling-2.6-flash — sit near $0.02–0.03 for both input and output, roughly 1:1. When compute is cheap enough, the serial/parallel gap stops mattering to the price.
The takeaway
Output is the expensive half of every major LLM API, by a factor the whole industry agrees on. Design as if generated tokens cost 5–6× what you pay to read — because they do. Cap your outputs, lean into input-heavy and extraction-shaped tasks, and treat any reasoning model’s hidden tokens as the real cost driver.
Prices and ratios shift as new models land; the tables here are from 2026-07-14. Each model’s page on computetrail tracks its input and output prices separately, day by day, so you can see when a lab breaks from the 5–6× pattern.
Figures from computetrail’s 2026-07-14 price snapshot. See our methodology for how prices are collected and normalized.