Anthropic Prompt Caching Pricing: Read & Write Costs (2026)

Anthropic prompt caching read and write costs per Claude model: 5-minute writes are 1.25x input, 1-hour writes 2x, reads 0.1x. Dollar table and break-even math.

By SandBase TeamUpdated Model Comparison

Cover image for Anthropic Prompt Caching: 5min vs 1hr Pricing

Key takeaway — Checked against Anthropic’s pricing page on October 4, 2026:

  • A 5-minute cache write costs 1.25x the model’s base input price; a 1-hour cache write costs 2x.
  • A cache read costs 0.1x base input on most models, 0.05x on Claude Opus 5.5 and 0.025x on Claude Fable 5.1 and Mythos 5.1.
  • The 5-minute cache pays for itself after one read; the 1-hour cache needs two reads.
  • Reads refresh the cache lifetime at no extra cost, so the 5-minute tier only loses when gaps between calls exceed five minutes.

An agent that resends the same 50,000-token system prompt on every step pays for those tokens again each time, unless the prefix is cached. Anthropic prompt caching pricing then splits the bill into three rates: what you pay to write the cache, what you pay to read it, and the normal rate for everything after the breakpoint. This page puts the read and write costs for current Claude models in one table, then works through when the 5-minute and 1-hour tiers save money.

An earlier version of this article listed the 1-hour write at 1.5x and a "persistent" cache type. Both were wrong for the current API: the 1-hour write is 2x, and the only cache type is "ephemeral" with an optional ttl. The numbers below were re-read from the official pages on October 4, 2026.

Read and write costs per Claude model

All prices are USD per million tokens (MTok), from Anthropic’s pricing page and the matching table in the prompt caching guide, both retrieved 2026-10-04.

ModelBase input5-min cache write1-hour cache writeCache read (hit)Output
Claude Fable 5.1$10$12.50$20$0.25$50
Claude Opus 5.5$4$5$8$0.20$20
Claude Sonnet 5.5$2$2.50$4$0.20$10
Claude Haiku 4.5$1$1.25$2$0.10$5
Claude Opus 5 (legacy)$5$6.25$10$0.50$25
Claude Sonnet 5 (legacy)$2$2.50$4$0.20$10
Claude Sonnet 4.6 (legacy)$3$3.75$6$0.30$15

The multipliers behind those dollar figures:

Cache operationMultiplier on base inputLifetime
5-minute write1.25x5 minutes
1-hour write2x1 hour
Read (hit)0.1x (0.05x on Opus 5.5; 0.025x on Fable 5.1 and Mythos 5.1)Same as the write that created it

Anthropic pricing table listing base input, output, 5-minute write, 1-hour write and cache hit prices for each Claude model

Caption: Anthropic’s model pricing table with the 5m writes, 1h writes and hits columns that the dollar table above is copied from (captured 2026-10-04).

Two details matter more than they look. Opus 5.5 has a cheaper read multiplier than the rest of the lineup, so a cached Opus 5.5 read costs the same $0.20/MTok as a Sonnet 5.5 read even though its base input is twice as high. And Anthropic notes that Claude 4.7 and later models use a newer tokenizer that produces roughly 30% more tokens for the same text, so a prompt you measured on an older model may count higher today.

Anthropic pricing page section listing the 1.25x, 2x and 0.1x prompt caching multipliers

Caption: The multiplier table and the official break-even statement: one read for the 5-minute tier, two reads for the 1-hour tier (captured 2026-10-04).

These multipliers stack with other modifiers on the same page: the Batch API’s 50% discount and the 1.1x multiplier for US-only inference (inference_geo: "us") on Claude 4.6 and later models.

How the two tiers differ in practice

Both tiers use the same mechanism. You mark the end of a stable prefix with cache_control; the first request writes everything up to that point, and later requests with an identical prefix read it.

from anthropic import Anthropic

client = Anthropic()

response = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=1024,
    system=[
        {
            "type": "text",
            "text": large_system_context,  # stable instructions + docs
            "cache_control": {"type": "ephemeral"},  # 5-minute default
            # 1-hour tier: {"type": "ephemeral", "ttl": "1h"}
        }
    ],
    messages=[{"role": "user", "content": current_question}],
)
print(response.usage)

What the official guide says about lifetime is the part most cost tables get wrong:

  • The default lifetime is 5 minutes, and “the cache is refreshed for no additional cost each time the cached content is used.”
  • The lifetime is measured from the start of the request that writes or reads the entry, so a response that streams for 4 minutes leaves about 1 minute for the next call.
  • Anthropic states that the 5-minute and 1-hour caches behave the same for latency. The choice is about cost and gaps between calls, not speed.

So the 5-minute cache does not expire every five minutes of wall-clock time. It expires when five minutes pass without a hit. A busy agent loop can keep a 5-minute cache alive for hours.

Break-even math

For a prefix of P tokens at base input price B, one write followed by N reads costs P × B × (write multiplier + N × read multiplier). Without caching, the same N+1 calls cost P × B × (N + 1).

Tier (read multiplier 0.1x)1 write + 1 read1 write + 2 readsNo cache, same calls
5-minute (1.25x write)1.351.452 / 3
1-hour (2x write)2.102.202 / 3

Units are multiples of P × B. The 5-minute tier already wins at one read (1.35 versus 2). The 1-hour tier loses slightly at one read (2.10 versus 2) and wins from the second read (2.20 versus 3). That matches the statement on Anthropic’s pricing page. The lower read multipliers on Opus 5.5 and Fable 5.1 do not change these break-even points; they only make each later read cheaper.

Worked examples with current prices

All three examples price only the cached prefix. The uncached question tokens and the output tokens cost the same with or without caching, so they are left out. Each call is assumed to hit when it starts inside the lifetime window.

Example 1: a fast agent loop on Sonnet 5.5

A 50,000-token prefix, 10 calls, each starting within a few seconds of the previous one finishing.

ApproachCalculationPrefix cost
No cache10 × 50K × $2/MTok$1.00
5-minute cache50K × $2.50 + 9 × 50K × $0.20 (per MTok)$0.215
1-hour cache50K × $4 + 9 × 50K × $0.20 (per MTok)$0.29

The 5-minute tier is cheapest. The extra $0.075 for the 1-hour write buys nothing because no gap is long enough to expire the cheaper cache.

Example 2: a user-paced session on Sonnet 5.5

The same 50,000-token prefix, 12 calls, one every 10 minutes (a support chat or a reviewer who thinks between turns).

ApproachWhat happensPrefix cost
No cache12 × 50K × $2/MTok$1.20
5-minute cacheEvery gap exceeds 5 minutes, so all 12 calls write: 12 × 50K × $2.50/MTok$1.50
1-hour cache1 write (50K × $4) + 11 reads (11 × 50K × $0.20), per MTok$0.31

Here the 5-minute cache is worse than no cache at all, because you pay the write premium twelve times and never read. The 1-hour tier cuts the prefix cost by about 74% versus no caching.

Example 3: a burst on Opus 5.5

A 100,000-token prefix, 20 calls in one burst.

ApproachCalculationPrefix cost
No cache20 × 100K × $4/MTok$8.00
5-minute cache100K × $5 + 19 × 100K × $0.20 (per MTok)$0.88
1-hour cache100K × $8 + 19 × 100K × $0.20 (per MTok)$1.18

Opus 5.5’s 0.05x read rate is what makes this so steep: 19 reads of 100K tokens cost $0.38 in total. On legacy Opus 5 ($5 input, 0.1x read) the same 5-minute pattern costs $0.625 + 19 × $0.05 = $1.575, against $10.00 uncached.

Which tier to pick

Your traffic patternTierWhy
Calls arrive less than 5 minutes apart (tool loops, CI agents, batch steps)5-minuteEach read refreshes the lifetime; the cheaper write is enough
Gaps of 5 to 60 minutes (human-paced chats, side agents that run longer than 5 minutes)1-hourAvoids paying a fresh write after every pause
A single call with a unique prefixNo cacheA write with no read costs 25% or 100% more than plain input
Prefix below the model’s minimumNo cache possibleThe request is processed uncached and no error is returned

Anthropic’s guide gives the same rule: if a prompt is used more often than every 5 minutes, stay on the 5-minute cache. Use the 1-hour cache for prompts reused less often than every 5 minutes but more often than hourly.

Minimum cacheable length, from the same guide: 512 tokens for Fable 5.1, Mythos 5.1, Opus 5.5, Opus 5, Sonnet 5.5, Fable 5 and Mythos 5; 1,024 for Opus 4.8, Sonnet 5, Sonnet 4.6 and Sonnet 4.5; 4,096 for Haiku 4.5.

Checking the bill in the response

Every response reports the split in usage. If both cache_creation_input_tokens and cache_read_input_tokens are 0, nothing was cached. The cache_creation object separates 5-minute and 1-hour writes, which is the field to log if you mix tiers.

Tested on 2026-10-04 (UTC) through SandBase

We sent four requests to anthropic/claude-sonnet-5.5 through SandBase’s Anthropic-compatible POST https://api.sandbase.ai/v1/messages route, with Authorization: Bearer $SANDBASE_API_KEY. Each used a synthetic system prompt of numbered support rules (no real customer data) marked with cache_control, max_tokens: 16, and the same short question. Requests 1 and 2 used the 5-minute default; requests 3 and 4 used a different prefix with "ttl": "1h". Request body shape:

{
  "model": "anthropic/claude-sonnet-5.5",
  "max_tokens": 16,
  "system": [
    {
      "type": "text",
      "text": "<about 3,000 tokens of numbered support rules>",
      "cache_control": {"type": "ephemeral", "ttl": "1h"}
    }
  ],
  "messages": [{"role": "user", "content": "Which rule covers E007? Answer with the rule number only."}]
}

The usage objects returned for request 3 (msg_011CfgUpGiuaeS6vhjYru8eV, 1-hour write) and request 4 (msg_011CfgUpm7bJx471S9VtwoZl, read three seconds later), with the output_tokens_details, service_tier and inference_geo keys omitted:

{"input_tokens": 25, "cache_creation_input_tokens": 3012, "cache_read_input_tokens": 0, "cache_creation": {"ephemeral_5m_input_tokens": 0, "ephemeral_1h_input_tokens": 3012}, "output_tokens": 3}
{"input_tokens": 25, "cache_creation_input_tokens": 0, "cache_read_input_tokens": 3012, "cache_creation": {"ephemeral_5m_input_tokens": 0, "ephemeral_1h_input_tokens": 0}, "output_tokens": 3}

The 5-minute pair behaved the same way, with the write reported under ephemeral_5m_input_tokens. Both tiers passed through, and the response model field read claude-sonnet-5-5. These are observed fields from four requests, not a documented SandBase guarantee.

On SandBase pricing: GET https://api.sandbase.ai/v1/models/anthropic/claude-sonnet-5.5 (same Bearer key) returned $2/MTok input, $10/MTok output, cache_write_multiplier 1.25 and cache_read_multiplier 0.1 on October 4. Its cache_write_1h_multiplier field was empty, so we have not confirmed how SandBase bills 1-hour writes, and we did not reconcile these four requests against an invoice. The public Claude Sonnet 5.5 model page shows the same input, output, cache read and cache write prices without needing a key.

SandBase model page for Claude Sonnet 5.5 showing $2 input, $10 output, $0.20 cache read and $2.50 cache write per million tokens

Caption: SandBase’s Claude Sonnet 5.5 page lists $2/M input, $10/M output, $0.20/M cache read and $2.50/M cache write, matching Anthropic’s 5-minute rates (captured 2026-10-04).

To try it, use the Claude Sonnet 5.5 model page for the model id and prices, and get a SandBase API key.

Implementation notes

Cache what does not change. Tool definitions, system instructions, loaded documents and the older part of a conversation are good candidates. The cache prefix is built in the order tools, system, messages, and any change at or before the breakpoint produces a different hash.

Put the breakpoint on the last stable block. A timestamp or the incoming user message after the breakpoint is fine; inside it, every request becomes a fresh write and nothing is ever read. You can set up to 4 breakpoints, and the lookback for earlier entries checks at most 20 blocks.

Mixing tiers is allowed, in order. A 1-hour entry must come before any 5-minute entry in the same request, for example a 1-hour breakpoint on tools and system, then a 5-minute breakpoint on the conversation.

Watch for silent misses. Changes to tool_choice, adding or removing images, or a different thinking configuration all invalidate the cache. Track the share of input billed as reads; if writes keep appearing on a prefix you think is stable, something before the breakpoint is changing.

For a broader view of cutting Claude spend in agents, see Anthropic prompt caching for agents. For prices across providers, see the LLM API pricing guide.

FAQ

How much does an Anthropic prompt cache write cost?

A 5-minute write costs 1.25x the model’s base input price and a 1-hour write costs 2x. On Claude Sonnet 5.5 that is $2.50 and $4 per million tokens; on Opus 5.5, $5 and $8 (Anthropic pricing page, October 4, 2026).

How much does a cache read cost?

0.1x base input on most models, which is $0.20/MTok on Sonnet 5.5 and $0.10/MTok on Haiku 4.5. Opus 5.5 reads cost 0.05x ($0.20/MTok) and Fable 5.1 or Mythos 5.1 reads cost 0.025x ($0.25/MTok).

Is the 1-hour cache worth the higher write price?

Only when gaps between calls are longer than five minutes but shorter than an hour. If calls come faster, each read refreshes the 5-minute cache for free, and the 1-hour write premium buys nothing.

Do caches persist across API keys?

Caches are isolated between organizations, and on the Claude API also per workspace within an organization. Bedrock and Google Cloud use organization-level isolation. Identical prompts in two workspaces do not share a cache.

Does caching change the output or the context limit?

No. Anthropic states the response is identical with or without caching, and cached tokens still count toward the model’s context window. Caching changes what you pay for repeated input and how quickly long prompts start responding.