Claude Sonnet 5.5 Cache Read Price Cut to $0.10: What You Save

Claude Sonnet 5.5 cache reads now cost $0.10 per million tokens, down from $0.20. The change took effect October 7, 2026, according to Anthropic's API release notes. The cache read rate is now 0.05x the $2 base input price instead of 0.1x. Input ($2), output ($10), 5-minute cache writes ($2.50) and 1-hour cache writes ($4) did not move.

What that does to your bill depends on one number: the share of your old Sonnet 5.5 spend that was cache reads. Only that line halved, so your percentage saving is half of that share. Anthropic's "around 20%" is its estimate for most agentic tasks. A cache-heavy coding agent at high effort can save closer to 30%; a short chat with a small cached prompt saves a few percent.

Three conditions change the figure you should expect:

• Where you run it. Batch, US-only inference and some cloud regions use a different cache read rate ($0.05, $0.11, $0.11). The surface table below lists each one.
• Which model. Claude Sonnet 5 still charges $0.20 for cache reads. Opus 5.5 charges $0.20, which now makes it exactly twice Sonnet 5.5 on every price line.
• How you pay. The cut is API-only. Claude Pro, Max and Team plan limits in Claude Code did not change.

Sonnet 5.5 price table after October 7: only the cache read line moved

Anthropic's Claude API pricing page lists the cache read line as "Cache hits and refreshes", because a read also resets the cache entry's time-to-live. The multiplier table on the same page calls it "Cache read (hit)". Google Cloud labels it "Cache Hit", and Amazon Bedrock's Converse API reports it as cacheReadInputTokens. They are the same line, and "cached input" usually means it too.

All prices are USD per million tokens on the Claude API with default global routing, as of October 12, 2026.

Two details in that table explain most of the confusion. Sonnet 5 and Sonnet 5.5 share every other price, so a $0.20 cache read figure for "Sonnet" is correct for Sonnet 5 and outdated for Sonnet 5.5. Opus 5.5 already used the 0.05x multiplier; its $0.20 is 5% of a $4 input price. The Claude Sonnet 5 pricing breakdown covers Sonnet 5's rates after its canceled September increase.

The release note dates the change to October 7, 2026 and says nothing about re-rating earlier usage. Expect cache reads billed before that date to stay at $0.20.

Which surfaces get $0.10: Batch, US-only, Bedrock and Vertex AI

Anthropic's pricing page says cache multipliers "stack with other pricing modifiers, including the Batch API discount and data residency." Applying that rule gives the rates below. Rows marked "derived" are calculations from Anthropic's published multipliers, not a figure printed on a price list.

A few of those rows need context:

• Amazon Bedrock runs its own price list. DevelopersIO's Bedrock cache read article pulled the us-east-1 rates for "Claude Sonnet 5.5 (Amazon Bedrock Edition)" on October 9, 2026, and reports a note on the Amazon Bedrock pricing page about the 50% cut from October 7. Geographic cross-Region inference carries a 10% premium on every line, so its cache read is $0.11. Other regions may differ.
• Google Cloud prices Claude by endpoint on its Vertex AI generative AI pricing page, with tabs for Global, US Multi-Region, EU Multi-Region, us-east5, europe-west1, asia-southeast1 and asia-east1. Going by the order of the tables on that page, the Global endpoint charges $0.10 per cache hit and $0.05 per batch cache hit for Sonnet 5.5. Multi-region and regional endpoints are 10% higher on every line: $0.11 cache hit, $0.055 batch cache hit, $2.20 input and $11 output.
• Claude Platform on AWS and Foundry bill in Claude Consumption Units. Anthropic rates usage in USD at standard rates, applies any negotiated discount, then converts at $0.01 per CCU. A private offer changes the CCU count, not the multiplier.

Why Anthropic says about 20% and your saving may be 2% or 30%

Your saving rate is half the share cache reads took of your spend at the old price. The formula follows from the price change itself: only the cache read line halved, and every other line stayed the same.

percent saved = 0.5 × (cache read cost at $0.20 ÷ total Sonnet 5.5 cost at old prices)

Anthropic's Claude Haiku 5.5 launch post gives the reason for its estimate: "cache reads make up a large share of models' token consumption, this reduces the cost of Sonnet 5.5 on most agentic tasks by around 20%." By the formula above, a 20% saving means cache reads were about 40% of the old bill. The @ClaudeDevs account on X repeated "~20% cheaper on most agentic work" on October 9.

The one public measurement of a real workload fits the formula exactly. DevelopersIO ran a 20-turn chat on Bedrock with a roughly 16,400-token system document cached and 300-token answers. At the old price, cache reads were 40.1% of the cost; at the new price, the 20 turns cost $0.1399 instead of $0.1750, a 20.0% saving. The cumulative saving was only 3.3% after turn 2, because the first turn is all cache write.

Artificial Analysis prices its Intelligence Index runs at each effort level, which shows how the saving grows with longer tool loops. Its October 5, 2026 figures used the old $0.20 cache price; its October 12 figures use $0.10. Scores are identical in both snapshots. The percentages and implied cache shares below are LaoZhang calculations (new ÷ old − 1, and share = 2 × saving).

Higher effort runs longer tool loops, and every extra loop re-reads the cached context. That is why max effort saves more than low. One benchmark mix is not your workload, though. A support bot turn that reads a 2,000-token cached prompt, adds 100 new input tokens and writes an 800-token answer cost $0.0086 at the old price. Cache reads were $0.0004 of that, under 5%, so the turn saves about 2%. The Artificial Analysis Sonnet 5.5 vs Opus 5.5 comparison shows the current per-task costs.

How to calculate your own Sonnet 5.5 saving from the usage fields

Every Claude API response already carries the counts you need. The Anthropic prompt caching guide defines them:

• cache_read_input_tokens: tokens read from the cache (billed at $0.10 now, $0.20 before)
• cache_creation_input_tokens: tokens written to the cache on this request, split in the cache_creation object into ephemeral_5m_input_tokens and ephemeral_1h_input_tokens
• input_tokens: only the uncached tokens after your last cache breakpoint, not your whole prompt
• output_tokens: billed at $10

Total input is cache_read_input_tokens + cache_creation_input_tokens + input_tokens. The dollar saving on any request is simply cache_read_input_tokens × $0.10 ÷ 1,000,000. To get the percentage, price the same usage twice:

# Claude Sonnet 5.5 list prices, USD per million tokens (Claude API, global routing)
PRICE = {"input": 2.00, "write_5m": 2.50, "write_1h": 4.00, "output": 10.00}
CACHE_READ_OLD, CACHE_READ_NEW = 0.20, 0.10  # before / from October 7, 2026

def sonnet_55_cost(usage, cache_read_price, batch=False, us_only=False):
    cc = usage.get("cache_creation") or {}
    # Without the cache_creation split, all writes are treated as 5-minute writes
    w5 = cc.get("ephemeral_5m_input_tokens", usage.get("cache_creation_input_tokens", 0))
    w1 = cc.get("ephemeral_1h_input_tokens", 0)
    dollars = (
        usage["input_tokens"] * PRICE["input"]
        + w5 * PRICE["write_5m"]
        + w1 * PRICE["write_1h"]
        + usage.get("cache_read_input_tokens", 0) * cache_read_price
        + usage["output_tokens"] * PRICE["output"]
    ) / 1_000_000
    if batch:
        dollars *= 0.5
    if us_only:
        dollars *= 1.1
    return dollars

usage = {  # one response's usage object
    "input_tokens": 0,
    "cache_read_input_tokens": 100_000,
    "cache_creation_input_tokens": 3_000,
    "cache_creation": {"ephemeral_5m_input_tokens": 3_000, "ephemeral_1h_input_tokens": 0},
    "output_tokens": 2_000,
}
old = sonnet_55_cost(usage, CACHE_READ_OLD)
new = sonnet_55_cost(usage, CACHE_READ_NEW)
print(f"before: ${old:.4f}  now: ${new:.4f}  saved: {1 - new / old:.1%}")
# before: $0.0475  now: $0.0375  saved: 21.1%

Run it over a day of logged usage objects, summing old and new, and you have your own number instead of Anthropic's average. On Bedrock, map cacheReadInputTokens and cacheWriteInputTokens from the Converse response, and use the 10%-higher geographic prices if you call a geographic inference profile. Taxes, credits and negotiated discounts are not included.

The example above is one agent turn with illustrative token counts: 100,000 tokens read from cache, 3,000 written to the 5-minute cache and 2,000 output tokens. It saves 21%. A read-heavy turn with 500,000 tokens read, 1,000 written and 1,000 output goes from $0.1125 to $0.0625, a 44% saving.

Sonnet 5.5 vs Opus 5.5 and Sonnet 5 for cache-heavy work after the cut

The cut widens Sonnet 5.5's lead over Opus 5.5 on cached work and erases most of Sonnet 5's cost advantage at max effort.

Opus 5.5 now costs exactly twice Sonnet 5.5 on every line: input $4 vs $2, output $20 vs $10, cache writes $5 and $8 vs $2.50 and $4, cache reads $0.20 vs $0.10. Before October 7 the cache read line was $0.20 on both, so read-heavy workloads narrowed the gap. With the same illustrative token counts as above:

Per-token price is not the whole choice. On Artificial Analysis's index, Opus 5.5 at high effort scores 54 for $1.82 per task, while Sonnet 5.5 at xhigh scores 52 for $2.01. If you were pushing Sonnet 5.5 to xhigh or max to match Opus quality, compare the two at equal scores rather than equal effort labels.

Claude Sonnet 5 keeps the $0.20 cache read, so the cut also changes the Sonnet 5 versus 5.5 math. Using Artificial Analysis's per-task costs (Sonnet 5 figures from October 5, 2026; its price has not changed since), Sonnet 5.5 is now 31% cheaper per task at low, 52% at medium, 51% at high and 30% at xhigh. At max it costs 7% more ($5.46 vs $5.09), down from 51% more at the old cache price. It also scores 12 to 18 points higher at every effort level.

If the real question is whether to move work off Sonnet altogether, Claude Haiku 5.5 vs Sonnet 5.5: When the 20x Price Gap Pays Off covers which jobs can go to Haiku.

Should you change cache TTL or breakpoints? Break-even is still one or two reads

The break-even points for caching on Sonnet 5.5 did not change. What changed is how much each re-read saves and how expensive a miss looks next to a hit.

For a prefix of P tokens, caching costs the write plus 0.05P per later read. Not caching costs P on every request:

• 5-minute cache: 1.25P + 0.05P × n versus (1 + n) × P. Caching wins from the first read.
• 1-hour cache: 2P + 0.05P × n versus (1 + n) × P. Caching wins from the second read (n > 1.05).

Those are the same thresholds as at 0.1x. Each re-read is now 95% off base input instead of 90%. Cache writes did not get cheaper, so a miss stands out more: rewriting a prefix to the 5-minute cache costs 25 times reading it ($2.50 vs $0.10, was 12.5x), and a 1-hour write costs 40 times a read (was 20x). Your hit rate now matters more than your TTL choice.

Three checks give the most return on Sonnet 5.5:

1. Confirm the prompt is cached at all. The minimum cacheable prefix on Sonnet 5.5 is 512 tokens; Sonnet 5's is 1,024. Shorter prefixes are processed without caching and no error is returned. If cache_creation_input_tokens and cache_read_input_tokens are both 0, nothing was cached.
2. Keep the prefix stable. Caching works on an exact prefix in the order tools, system, messages. Changing an early block invalidates everything after it.
3. Append instructions instead of editing system. On Sonnet 5.5 you can add a {"role": "system"} message partway through a conversation without invalidating the cache. Sonnet 5 does not support this.

Does Claude Code get cheaper? Only when it bills to an API key

Claude Code and the Agent SDK get the new price only when they run on an API key, because then every token bills at API rates. The @ClaudeDevs post put it directly: "API only, no change to Claude Code usage limits." A Claude Pro, Max or Team subscription in Claude Code gets the same usage limits as before October 7.

The same October 7 release added a separate item: monthly API credits for Claude Max and Team plans. Anthropic's launch post lists $100 for Max 5x, $200 for Max 20x and up to $500 pooled for Team, usable on Claude Platform with any model. Those credits are an API balance. Requests you pay with them get the $0.10 cache read like any other API call; the plan's own usage limits stay the same. The Claude API release notes link to the claim instructions.

FAQ about the Claude Sonnet 5.5 cache read price

Is the Claude Sonnet 5 cache read price also $0.10?

No. Claude Sonnet 5 still charges $0.20 per million tokens for cache reads (0.1x its $2 input price) on the Claude API. Only Sonnet 5.5 moved to 0.05x. On Bedrock us-east-1, Sonnet 5 is $0.20 with global and $0.22 with geographic cross-Region inference.

Did Sonnet 5.5 cache write prices change?

No. The 5-minute cache write is still $2.50 per million tokens and the 1-hour write is still $4. Base input ($2) and output ($10) are also unchanged. The October 7, 2026 release note says "Cache writes and all other prices are unchanged."

What is the Sonnet 5.5 cache read price with the Batch API?

$0.05 per million tokens on the Claude API, because the Batch discount stacks with the 0.05x cache multiplier. Google Cloud Vertex AI prints the same $0.05 batch cache hit for its Global endpoint; multi-region and regional endpoints charge $0.055. With US-only inference, a batch cache read works out to $0.055.

Is Sonnet 5.5 now 20% cheaper overall?

Only if cache reads were about 40% of your Sonnet 5.5 spend at the old price. Your saving is half that share. On Artificial Analysis's benchmark tasks the saving ranges from 17% at low effort to 29% at max. On workloads with little caching it can be a few percent.