How API Token Cache Pricing Works (And Why It Decides Your Real Bill)

API token caching lets a model reuse a previously processed chunk of a prompt instead of reprocessing it from scratch, and providers charge a fraction of the standard input rate for that reused chunk. The catch: this cache-read rate, not the advertised input or output price, is what actually determines your bill once you're running agents that resend growing context on every turn.

Anthropic's Claude Fable 5.1 release makes the point unusually well. The headline numbers look unchanged: $10 per million input tokens, $50 per million output tokens, identical to Fable 5.¹ But cache-read pricing dropped 75%, from $1.00 to $0.25 per million tokens.¹²³ Anthropic says that single line-item change cuts effective cost by roughly 25% for typical workloads and up to about 45% for heavily agentic ones, based on four weeks of real August 2026 usage data.¹⁴ Nothing on the pricing page looks different. The bill does.

How does prompt caching actually work?

Prompt caching lets a model store the computed state of a prompt prefix, the part of the input that stays the same call to call, so it doesn't have to reprocess that text from zero every time.⁵ There are two charges to know, plus a rule that decides whether either one applies:

• Cache writes. The first time a prefix is cached, you pay a premium over standard input pricing, typically 1.25x for a short-lived cache and up to 2x for a longer-lived one on Anthropic's platform.⁵ OpenAI charges 1.25x the standard input rate for a cache write as well.⁶
• Cache reads. Every subsequent call that reuses that same prefix pays a steeply discounted rate. On Anthropic's standard pricing, that's 10% of the base input price.⁵ With Fable 5.1, it drops further, to 2.5% of base input.⁵
• TTL and prefix matching. Caches expire after a set window, five minutes or one hour on Anthropic's platform, and the discount only applies if the prefix is byte-identical to what was cached. Change a timestamp, reorder a tool definition, or alter a session ID, and the cache misses entirely.⁷⁵

The economics only work in your favor if a prefix gets reused enough times to amortize the write premium. Ask a model one question and cache it, and you've paid extra for nothing. Ask it forty questions against the same 150,000-token document, and the write cost becomes a rounding error next to what you save on the other thirty-nine reads.

Why cache reads, not input or output, run the bill for agents

A one-shot chat query barely touches caching. You send a question, get an answer, done. An agent doesn't work that way. Every turn in an agent loop resends the accumulated transcript, the tool definitions, the system prompt, and whatever context has piled up so far, then appends the new turn on top.⁷ Output stays comparatively small and flat. Input balloons with every step, and most of that input is the same prefix you sent last turn.

That's why the cache-read rate quietly becomes the dominant cost driver in agentic and internal-tool workloads, even though it's the line item almost nobody checks when comparing providers. Teams sizing up models by headline input/output price alone are pricing the wrong 90% of their actual token volume.

What does a 75% cache-read cut actually buy you?

Merito ran the numbers on a realistic coding-agent setup: a 150,000-token cached prefix, hit 40 times in a session, producing 6 million cache-read tokens per session.³ At the old $1.00 per million rate, that's $6.00. At the new $0.25 rate, it's $1.50, a 75% drop on that portion of the bill, matching the sticker cut exactly.³

Scale that to a real team: 50 engineers, 4 sessions a day, 20 working days a month, 4,000 sessions monthly. Cache-read spend alone falls from roughly $24,000 to about $6,000.³ That's an $18,000 monthly swing driven entirely by a price change that never touched the input or output rate anyone would notice on a pricing page.

The blended savings percentage Anthropic quotes, 25% to 45%, is just the cache-read share of the total bill multiplied by 0.75.³ A workload where a third of tokens are cache reads saves about 25%. A workload where 60% of tokens are cache reads, typical of heavy agentic use, saves closer to 45%. The range isn't a marketing flourish. It's arithmetic on cache share.

Not all cache discounts are equal

Here's where sticker-price comparisons get dangerous. Cache-read discounts vary wildly across the market:

• Claude Fable 5.1 now offers a 98% discount versus fresh input.⁷⁸
• gpt-oss-120b offers zero discount; cached tokens cost the same as fresh ones.⁷
• Most providers cluster around a 90% discount as the informal industry norm.⁷⁸⁶
• OpenAI's own cached-input discount sits at roughly 50%, notably smaller than Anthropic's structure.⁹

Two models can post identical headline input prices and produce very different real bills once you factor in how much traffic is cached and at what discount. Comparing two APIs on input/output rate alone, without checking the cache-read line, is comparing the wrong number, the same trap teams fall into when routing agent workloads without checking what markup sits between them and raw compute.

Why this matters most for teams building their own tools

SaaS subscribers never see this line item. Whatever caching economics the vendor captures on the back end, the customer pays a flat seat price regardless.¹⁰ It's teams building internal agents directly on top of provider APIs, the shadow AI builders assembling their own tools with LLM calls, who are directly exposed to cache pricing and directly able to benefit from a cut like this one.

That exposure cuts both ways. A well-structured internal tool with stable prompt prefixes captures nearly all of a 75% cache-read cut automatically. A poorly structured one, where a timestamp or session token gets baked into the cached portion of every call, invalidates the cache on every single turn and pays full price regardless of what the provider's pricing page promises.⁷⁵ The same nominal discount can be worth close to nothing depending on how carefully the prompt was engineered. That governance gap, where nobody is watching cost per task as a single request quietly multiplies into dozens of model calls, is exactly the kind of blind spot that shows up when employees build their own AI tools without a budget owner watching the API bill.¹⁰

Build vs. buy: who actually captures the cache discount?

This is a build-vs-buy question dressed up as a pricing footnote. If you build your own integration, you own the cache-read line item and every optimization decision that shapes it: prefix stability, TTL choice, session structure. If you rent a SaaS wrapper over the same model, the vendor captures that 75% cut and decides whether any of it reaches your invoice. Given that the intelligence inside most B2B software now costs pennies per million tokens while subscription prices haven't moved, there's little reason to assume the vendor is passing the savings through.

Teams evaluating whether to run their own AI tooling on raw API access, rather than through a platform like Remy, should treat cache-read economics as a first-class line item in that decision, not an afterthought buried three rows down on a pricing page.

How do you audit your own cache bill?

A few checks turn this from theory into a number you can act on:

1. Find the cache-read rate. It's a third price beyond input and output. If a vendor's pricing page doesn't list one, ask, because a missing line item doesn't mean a missing charge.
2. Check your actual hit rate. Most providers expose cache hit and miss counts in usage logs. A theoretical 90% discount is worthless if your prefixes rarely match.
3. Keep prefixes byte-identical. Move timestamps, session IDs, and dynamic content to the end of the prompt, after the cached portion, not inside it.
4. Measure cost per task, not cost per token. An agent that takes eight turns to finish a job and one that takes forty look identical on a per-token rate sheet but produce wildly different bills.¹⁰

The sticker price tells you what a provider wants you to compare. The cache-read rate, and how disciplined your prompts are about protecting it, tells you what you'll actually pay.