LLM Pricing Comparison 2026: The Real Cost Per Token

Sticker price per million tokens is not your bill. Output tokens cost five to eight times more than input tokens on every major provider's 2026 rate card, so the real cost of a workload depends on your input-to-output ratio, your prompt cache hit rate, and whether the job can run through a batch queue instead of live.

I have watched a team pick a model because its input price looked cheapest on the vendor's pricing page, then get a bill three times higher than the model one tier up. Their workload was output-heavy, long summaries, not short lookups, and nobody ran the arithmetic before signing off. The framework for picking a model on task fit is a separate problem, covered in how to choose an LLM. This piece is about what you actually pay once a model has cleared that bar.

Key takeaways

If you read nothing else, read these.

• Output tokens cost five to eight times more than input tokens across OpenAI, Anthropic, and Google's 2026 pricing, so an output-heavy workload can flip which model is actually cheapest.
• Prompt caching cuts repeated input to roughly a dime on the dollar on all three providers, but the write cost only pays for itself after enough re-reads inside the cache's TTL.
• The Batch API is the one discount that's genuinely uniform: 50 percent off input and output, on OpenAI, Anthropic, and Google, for jobs that don't need a synchronous response.
• OpenAI's cached-input discount is not a flat rate. It runs from 50 percent off on GPT-4o to roughly 90 percent off on the GPT-5 family, so check per model before you assume.
• Model your monthly bill from real input and output token counts and cache hit rate, not the headline price per million tokens. A six-model comparison on one identical workload below shows an 8.5x spread.

What the major providers actually charge per million tokens

Here is what each provider's own pricing documentation listed as of late August 2026, per million tokens, before any discount.

• OpenAI: GPT-5.6-Sol runs $4 input, $0.40 cached input, $20 output. GPT-5.5 runs $5 input, $0.50 cached, $30 output. The budget tier, GPT-5-nano, runs $0.05 input, $0.005 cached, $0.40 output (OpenAI API pricing).
• Anthropic: Claude Opus 5 runs $5 input, $0.50 cache-hit, $25 output. Claude Sonnet 5 runs $2 input, $0.20 cache-hit, $10 output. Claude Haiku 4.5 runs $1 input, $0.10 cache-hit, $5 output (Anthropic model pricing).
• Google: Gemini 3.5 Flash runs $1.50 input, $0.15 cached, $9 output. Gemini 3.5 Flash-Lite, the cheapest tier and without caching at standard rates, runs $0.30 input, $2.50 output. Gemini 3.7 Flash carries a promotional rate of $0.75 input, $0.075 cached, $3.75 output through the end of 2026, stepping up to $1.50, $0.15, and $7.50 on January 1, 2027 (Gemini API pricing).

These numbers move. Providers cut prices, add tiers, and retire models on a schedule measured in weeks, not years. Pull the current numbers from the source before you commit a budget to them, not from a comparison article, including this one.

Why output tokens cost five to eight times more than input

The ratio is not a coincidence, and it holds across providers that compete hard on price. Input tokens process in parallel during the prefill pass. Output tokens generate one at a time, each one waiting on the last, which is slower and more expensive per token to produce. That is the mechanical reason output costs more everywhere, not a pricing quirk of any one vendor.

Run the ratios: Claude Sonnet 5 and Claude Opus 5 both price output at 5x input. Claude Haiku 4.5 and GPT-5.6-Sol do the same, 5x. Gemini 3.5 Flash prices output at 6x input. Gemini 3.5 Flash-Lite prices output at roughly 8.3x input, the widest spread of any tier above.

The business consequence is direct. A product that retrieves and returns a short answer is input-heavy, and the model with the cheapest input price usually wins. A product that drafts, summarizes, or explains at length is output-heavy, and the same comparison can flip entirely. Know which one your product is before you shop on price.

Prompt caching: close to free re-reads, if the write pays for itself

Caching works the same way on all three platforms. Store a prefix once, then read it back at a steep discount instead of reprocessing it on every call. The read discount is consistent, close to 90 percent off the base input price, on Anthropic, Google, and most of OpenAI's current lineup.

Anthropic's own documentation is precise about the break-even math. A 5-minute cache write costs 1.25x the base input price; a 1-hour write costs 2x. A cache read costs 0.1x base. That means caching "pays off after one cache read for the 5-minute duration, or after two cache reads for the 1-hour duration" (Anthropic pricing docs). Below that reuse count, caching costs more than paying the base rate every time.

OpenAI is the exception worth flagging, and it is the trade-off most teams miss. The cached-input discount is not a flat rate across their catalog. GPT-5-nano and GPT-5.6-Sol get roughly 90 percent off. GPT-4o gets exactly 50 percent off. GPT-4.1-nano gets 75 percent off. If you are modeling cost from a single "caching saves 90 percent" assumption and your workload runs on GPT-4o, your estimate is off by a wide margin. Check the number per model, every time.

I cover cache-key design and TTL strategy in more depth in prompt caching, including the failure mode where concurrent sessions evict a cache entry before it gets reused.

Batch API: the one discount every provider agrees on

Batch processing is the cleanest lever in this comparison, because it is uniform. OpenAI, Anthropic, and Google all cut both input and output pricing by 50 percent for batch jobs, in exchange for asynchronous processing instead of a live response.

The arithmetic is simple because the discount is simple. Claude Sonnet 5's standard $2 input and $10 output drop to $1 and $5 in batch. GPT-5.6-Sol's $4 and $20 drop to $2 and $10. Anthropic's discounts stack, too: batch and prompt caching apply together, so a cached, batched request can run at a fraction of the live, uncached price.

The catch is the one you would expect. Batch is not for anything a user is waiting on. It fits backfills, nightly summarization runs, eval suites, and bulk classification, work that can sit in a queue for a while. It does not fit a chat interface. Route the right traffic to the right mode and the discount is close to free money; route a live product through it and you have shipped a broken feature.

How to actually model your monthly bill

Sticker price answers the wrong question. The right question is: for my real input tokens, my real output tokens, and my real cache hit rate, what does a month cost? Here is a worked, illustrative example, not a real client workload, using the verified per-token rates above.

Assume 100,000 requests a month. Each request sends 1,500 tokens of repeated context that hits the cache, 500 tokens of fresh user input, and generates 500 tokens of output.

Same workload, six models, an 8.5x spread between the cheapest and the most expensive. Output tokens are 68 percent or more of the bill in every row. The model that looks cheapest on a bare input-price comparison is not automatically the model that wins here. Run your own numbers on your own token counts before you decide; my piece on LLM inference cost walks through the unit economics behind why generation costs what it does.

If this job can run overnight instead of live, batch halves every number in that table again, and stacking batch with caching on Anthropic's models compounds further. A workload that costs $630 a month live can drop toward $300 or lower once it moves to a batch queue.

The trade-off: your cache hit rate assumption is where this breaks

Every number above assumes a close-to-100-percent hit rate on the repeated 1,500-token block. That is optimistic. Real traffic has cold starts, concurrent sessions that evict each other's cache entries before reuse, and content that is not as static as it looked in the design doc.

Model two scenarios, not one: your optimistic hit rate, and something closer to 50 percent, then price both. The gap between them is the number that should worry you, not the marketing claim about "up to 90 percent savings" on a vendor's homepage.

This is also where the bigger, more expensive model sometimes wins on total cost, not just quality. A frontier model that needs fewer retries and less scaffolding around it can beat a cheaper model that fails more often and burns extra output tokens on error correction. Chasing the lowest per-token number in isolation, the way raw scale gets credited for winning every argument, is a common misreading of what the actual bitter lesson about learning at scale claims. I untangle where that argument does and doesn't apply to a purchasing decision in The Bitter Lesson Revisited.

Which LLM is cheapest in 2026?

There is no single answer, because "cheapest" depends on your input-to-output ratio. For short, input-heavy lookups, the lowest input-priced tier usually wins, currently Gemini 3.5 Flash-Lite or a comparable budget model. For longer, output-heavy generation, the ranking changes because output pricing dominates the bill. Model your own token counts before naming a winner.

Do all major LLM providers offer prompt caching?

OpenAI, Anthropic, and Google all offer some form of prompt or context caching in 2026, and the read discount lands close to 90 percent off the base input price on most of their models. The mechanics differ: cache duration, write cost, and whether caching is available at all on the cheapest tiers vary by provider, so check the current docs for the specific model you are pricing.

Is the batch API worth using for a production app?

Only for the parts of your workload that do not need a synchronous response. Batch processing runs asynchronously and is priced at roughly half of live API rates on every major provider. It fits nightly jobs, bulk classification, and backfills well. It does not fit a chat interface or anything a user is actively waiting on.

How much does output length actually affect LLM cost?

More than most teams assume. Output tokens price at five to eight times the input rate across the providers compared here, and in the worked example above, output accounted for the majority of the bill in every case, even with a generous cache hit rate on the input side. Shortening your output format, or capping generation length, is often a bigger cost lever than switching models.

Pricing pages change monthly, and workload shape is specific to your product, which is why a spreadsheet beats a vendor comparison chart every time. If you want a second set of eyes on the real economics before you commit a budget to a model, ViitorCloud's technology consulting team can help you model the workload and pressure-test the assumptions before the first invoice arrives.