Claude API Pricing: What Caching and Batch Really Save

Claude API pricing in October 2026 runs from $0.10 per million input tokens (Haiku 5.5) to $10 (Fable 5.1), with output costing five times input on every current model. The three levers that cut the bill are prompt caching (cached input is billed at 2.5% to 10% of the normal input price), the Batch API (half price for anything that can wait up to a day), and moving the routine calls to a smaller model. OpenAI’s API has the same three levers with slightly different rules, covered further down.

All prices here are from Anthropic’s pricing page and OpenAI’s API pricing page, checked on October 21, 2026, standard (global) processing, per million tokens.

The price table, with the columns that matter

Model	Input	5-min cache write	Cache read	Output	Batch input / output
Claude Fable 5.1	$10	$12.50	$0.25	$50	$5 / $25
Claude Opus 5.5	$4	$5	$0.20	$20	$2 / $10
Claude Sonnet 5.5	$2	$2.50	$0.10	$10	$1 / $5
Claude Haiku 5.5 (prompts up to 100k tokens)	$0.10	$0.125	$0.01	$0.50	$0.05 / $0.25
Claude Haiku 4.5	$1	$1.25	$0.10	$5	$0.50 / $2.50

Two details in that table people miss. Cache reads on Sonnet 5.5 and Opus 5.5 are billed at 0.05x input, not the 0.1x most blog posts still quote, and Fable 5.1 reads at 0.025x. And Haiku 5.5 is the only current model priced by prompt length: once a single request’s prompt goes over 100,000 tokens (cache reads included), the whole request is billed at $0.50 in and $2.50 out. Every other current model bills a 900k-token request at the same per-token rate as a 9k one.

Also worth knowing: setting US-only inference with inference_geo multiplies every line by 1.1. If you don’t need it, don’t set it.

Where the money actually goes

Take a hypothetical support assistant on Claude Sonnet 5.5. It gets 200,000 requests a month. Each request sends 6,000 input tokens, 5,000 of which never change (the system prompt, the tool definitions, a policy document), and gets back 400 tokens.

Without caching, that’s 1,200 million input tokens at $2 ($2,400) and 80 million output tokens at $10 ($800). $3,200 a month.

With the fixed 5,000 tokens cached, 1,000 million tokens are cache reads at $0.10 ($100), the other 200 million are normal input ($400), and output stays $800. Cache writes add a few dollars: the 5-minute cache stays warm while requests keep arriving, and a read refreshes it for free, so you only pay the 1.25x write after quiet spells. About $1,300 a month, and nothing about the product changed.

Look at what’s left, though. Output is now $800 of the $1,300. Once caching is in, the bill is mostly what the model writes, and that’s set by max_tokens, by how long you let answers run, and by thinking settings on models that think. Asking for a three-sentence answer instead of a three-paragraph one is a pricing decision.

The same workload on the other models, cached the same way:

• Opus 5.5: $800 uncached input + $200 cache reads + $1,600 output = about $2,600
• Haiku 5.5: $20 + $10 + $40 = about $70

That gap is why model routing is the lever with the biggest number on it. If the cheap model handles the “where’s my order” questions and only the hard ones go to Sonnet, most of the traffic is priced like the bottom row. Test it on your own transcripts first; a cheaper call that needs a second try isn’t cheaper.

Caching rules that decide whether you get the discount

Caching is a prefix match. Claude caches everything up to a cache_control breakpoint, and any byte that changes before that point (a timestamp in the system prompt, tools listed in a different order, the user’s name near the top) makes every later request a cache write instead of a read. You can see it in the response: cache_read_input_tokens should be large on repeat requests. If it’s zero, something near the top of the prompt is changing.

The 5-minute write costs 1.25x input and pays for itself on the first read. The 1-hour write costs 2x and only makes sense when the gap between requests is between 5 minutes and an hour. Anthropic’s prompt caching docs have the full rules, including the up-to-4 breakpoints per request.

Batch: half price if it can wait

The Batch API takes 50% off input and output. Results come back asynchronously, so it only fits work nobody is waiting on: nightly summaries, tagging a backlog, re-embedding, evals, generating product descriptions. A hypothetical 500,000 ticket-tagging calls a month on Sonnet 5.5, 1,500 tokens in and 100 out each, cost $2,000 at normal prices and $1,000 through Batch. Caching multipliers stack on top of the batch price, so a shared prompt in a batch gets both discounts.

Fast mode goes the other way: $8 in and $40 out on Opus 5.5, double the standard rate, and it can’t be used with Batch.

The same levers on OpenAI

OpenAI’s newer models now charge for cache writes too, which they didn’t used to. On GPT-5.6 and later, a write with the default 30-minute lifetime costs 1.25x input and a 12-hour write costs 2.5x; reads cost 0.1x input on most of these models and 0.05x on gpt-6.1-sol. The minimum cacheable prefix is 1,024 tokens, and in explicit mode you mark the breakpoints yourself, which lets you keep the changing tail of a prompt out of the write. The details are in OpenAI’s prompt caching guide.

OpenAI model	Input	Cached input	30-min write	Output	Batch input / output
gpt-6-astra	$10	$1	$12.50	$50	$5 / $25
gpt-6.1-sol	$2	$0.10	$2.50	$10	$1 / $5
gpt-6-luna	$0.10	$0.01	$0.125	$0.50	$0.05 / $0.25

Those are short-context prices (up to 272,000 input tokens); above that, OpenAI doubles the input price and adds half again to output. OpenAI’s Batch tier is half price like Anthropic’s, and its Flex tier lists the same half prices for the same models.

So at list price, gpt-6.1-sol and Claude Sonnet 5.5 cost the same per token, and so do gpt-6-luna and Haiku 5.5. The difference in a real bill comes from how many tokens each model uses for the same job and how well your prompts cache, not from the price sheet.

What we’d check first on a bill like this

In order: is the fixed part of the prompt actually being read from cache (look at the usage fields, not the code), how long are the outputs and do they need to be, which calls could go to the smaller model, and which jobs could go through Batch. Our LLM API cost calculator prices your traffic on Claude, OpenAI and Gemini models side by side with a cache share and a batch switch, so you can see which lever moves your number before touching code.

If your AI features were built with Lovable and run through Lovable’s AI gateway, those calls are billed in Lovable credits rather than on an API key you control, which is a different bill with its own fixes: lovable2live’s breakdown of Lovable Cloud pricing covers it.