# Claude Haiku 5.5 pricing: the 100k cliff and Sonnet 5.5 cache cut > Claude Haiku 5.5 pricing steps up 5x on the whole request above 100k prompt tokens, cache reads included. Per-turn cost tables from the rate card, our own Claude Code transcript, and a routing table for subagents and compaction. **Author:** LAXIMA Team **Published:** 2026-10-12 **Updated:** 2026-10-12 **Reading time:** 19 min **Category:** technology **Tags:** claude haiku 5.5, claude code, Claude API pricing, prompt-caching, subagents, anthropic **Canonical URL:** https://laxima.tech/blog/claude-haiku-5-5-pricing-100k-cliff-sonnet-5-5-cache-read-cut --- Claude Haiku 5.5 costs $0.10 input and $0.50 output per million tokens, but only while the prompt stays under 100k tokens. Above that, every price, cache reads included, is 5x for the whole request. That makes it a cheap compactor or short-lived subagent, not a cheaper main coding loop. The [pricing docs](https://platform.claude.com/docs/en/about-claude/pricing) confirm the step. It shrinks Haiku's lead over Sonnet 5.5 (2.5x cheaper per turn at 150k in our arithmetic, down from 10x at 30k) but does not reverse it, so the case against Haiku as the main loop is quality, and most of that evidence is Anthropic's own. Sonnet 5.5's cache-read cut is the other half of the story: cache reads are 86-97.5% of Claude Code tokens, but only 19% of dollars in our write-heavy session and about half on read-heavy mixes. _How we got our numbers: an offline cost model, not a live Haiku run. We summed the usage blocks from the one Claude Code session on our sandbox and priced them at the rate card on_ [_Anthropic's launch page_](https://www.anthropic.com/claude-haiku-5-5)_, fetched 2026-10-10. We had no API key, so we did not run Haiku 5.5 and measured no latency or quality._ ## Cache reads are 86-97% of Claude Code tokens but 19-60% of dollars Cache traffic, reads plus writes, is nearly all the money. In our transcript it was 97.3% of dollars (our calculation: 18.96% + 78.37%). Manpreet Singh priced his own history and put re-reading plus re-caching at 86-93% of cost. Buckets are not defined identically: our 872k write tokens over 68 calls (about 13k per call) are mostly newly appended tool output and messages, not re-caching of old context. The read-only slice is what varies: 19% in our session, 46-54% on the read-heavy mixes below, 59.6% in one GitHub issue. Our own measurement: one session, 68 de-duplicated calls, all on Sonnet 5.5, priced with cache reads at the new $0.10 and the old $0.20 per 1M tokens. It is write-heavy, so do not read 19% as typical.

Bucket

Tokens

Token share

Dollar share (read $0.10)

Dollar share (read $0.20)

Cache read

5,277,194

85.71%

18.96% ($0.53)

31.88%

Cache write

872,526

14.17%

78.37% ($2.18)

65.88%

Output

7,397

0.12%

2.66% ($0.07)

2.23%

Fresh input was 136 tokens and rounds to zero. Our calculation puts total spend at $2.78 at the new read price and $3.31 at the old one, from the rate card above. The token share looks typical. Singh counted [173 sessions and 60,454 turns](https://dev.to/manpreet171/where-your-claude-code-tokens-actually-go-output-is-02-n8e): 97.5% of tokens were re-sent context, 0.2% output. He then wrote, "So 97.5% of the tokens is not 97.5% of the money." Rulestack's 13 runs had a median 97.3% reads; we read that only through [a secondary summary](https://deniz.in/claude-code-agent-s-median-run-hit-79-8m-tokens-97-of-them-cache-reads). One [dev.to write-up](https://dev.to/ploofnexa/i-measured-where-claude-code-actually-spends-tokens-968-is-re-reading-history-my-typing-was-16gm) reports 96.8% (32 sessions) and 97.4% (13,972 turns) across two logs. Heavy users see reads take a bigger dollar slice. A Max 20x user's [GitHub issue](https://github.com/anthropics/claude-code/issues/87646) covers 12,871 Opus 5 requests: cache reads were 59.6% of effective spend, and requests over 500k context were 24.9% of requests but 52.4% of cache-read spend. That bears on the r/ClaudeAI post titled ["56% of my Claude Code usage was Claude re-reading"](https://www.reddit.com/r/ClaudeAI/comments/1wzhbfc/56_of_my_claude_code_usage_was_claude_rereading/). Reddit blocked every tool we tried, so we could not read it and do not know what it measured. The only 56% we could trace is [a LinkedIn cost split](https://www.linkedin.com/posts/ameyakanitkar_fable-51-cut-the-price-of-a-cache-read-by-activity-7500996823751483392-V5O4) on Fable 5.1 at the old $1.00 read rate. Read-heavy dollar shares of 54-60% exist in the sources above, so a dollar-share reading is plausible. For contrast, our 5.28M read tokens priced at the full $2 input rate would cost $10.55, about 82% of a naive total (our calculation), against 19% of real spend. ## Halving Sonnet 5.5 cache reads saved 11-16% on our transcript and 31-35% on read-heavy mixes Anthropic says the cut from $0.20 to $0.10 [lowers Sonnet 5.5 cost on most agentic tasks by around 20%](https://www.anthropic.com/claude-haiku-5-5). The saving depends on the mix. The table is our calculation, not a measurement of anyone's invoice, and assumes the same token counts before and after. We do not know whether our session's cache writes were 5-minute or 1-hour, so we show both.

Mix

Cost before

Cost after

Saving

Cache-read dollar share

Our transcript, 5m writes ($2.50)

$3.31

$2.78

16.0%

31.9% to 19.0%

Our transcript, 1h writes ($4.00)

$4.62

$4.09

11.4%

22.8% to 12.9%

dev.to mix, 1.37B read tokens, 5m writes

$435.8

$298.7

31.5%

62.9% to 45.9%

Rulestack median mix (secondary summary; medians from different runs do not sum exactly), per 1M tokens, 5m writes

$0.277

$0.180

35%

70% to 54%

A 20% saving from halving the read price implies reads were about 40% of prior Sonnet spend (0.4 x 0.5 = 0.2), and about 25% after (0.2 / 0.8). That is our inference from a rounded figure. It is well below the 54% and 46% read shares in the two read-heavy mixes, which suggests Anthropic's mix carries more writes or output. Anthropic does not publish it. In the dev.to and Rulestack Sonnet mixes, reads stay the largest bucket after the cut. In our write-heavy transcript they do not: writes are 78-85% of spend. Where you are on that spectrum depends on how often a prefix is rebuilt. Per [Claude Code's docs](https://code.claude.com/docs/en/costs), cache lifetime is 1 hour on a subscription and 5 minutes on an API key by default, and the first message after a longer break misses the cache. One user report relayed by [Claude Code Review](https://claudecodereview.ai/a/claude-code-s-helper-agents-reportedly-cache-context-for-5-minutes-not-1-5c7294/) says subagents cache for only 5 minutes, with a `subagentPromptCacheTtl` setting as the fix; 1-hour writes cost more ($4.00 vs $2.50 on Sonnet 5.5). We did not verify it. To apply a mix to your own volume, use the [AI savings calculator](https://laxima.tech/tools/ai-savings-calculator). ## Claude Haiku 5.5 pricing steps up 5x at 100k, on the whole request Rates per 1M tokens, from the [pricing docs](https://platform.claude.com/docs/en/about-claude/pricing) and OpenAI's [GPT-6 Luna page](https://developers.openai.com/api/docs/models/gpt-6-luna). The same models are side by side in our [LLM picker](https://laxima.tech/tools/llm-picker).

Model

Cache read

5m cache write

Input

Output

Haiku 5.5, prompt up to 100k

$0.01

$0.125

$0.10

$0.50

Haiku 5.5, prompt over 100k

$0.05

$0.625

$0.50

$2.50

Haiku 4.5

$0.10

$1.25

$1.00

$5.00

Sonnet 5.5

$0.10

$2.50

$2.00

$10.00

GPT-6 Luna, up to 272k

$0.01

$0.125

$0.10

$0.50

GPT-6 Luna, over 272k

$0.02

$0.25

$0.20

$0.75

Every Haiku 5.5 line is exactly 5x above the threshold. The docs say "A request's prompt length counts all of its input tokens, including cache reads and cache writes," and that a request over the threshold "pays the higher prices even when part of its prompt is a cache hit." So the step is per request and covers the whole request, not just the tokens past 100k. Haiku 5.5 is also the exception to Anthropic's flat long-context pricing: other Claude 4.6+ models include the full 1M window at standard rates. The launch post shows the over-100k column, but the count-includes-cache detail is in the docs. One [third-party write-up](https://threatfrontier.com/articles/claude-haiku-5-5-price-cut-real-cost-math-vs-haiku-4-5) says Anthropic's pages imply but do not state this outright, so confirm on your first invoice. ## Haiku 5.5 is 8-10x cheaper than Haiku 4.5 per turn at 30k and only 1.5-2x once the step applies This table is our calculation from the rate card above, not a measurement. Assumptions: "context" is the cache-read tokens, plus 2k newly written tokens and 500 output tokens per turn, so the prompt is context + 2k. The 5-minute write price applies. The Sonnet 5.5 and Haiku 5.5 columns use the same token counts; the docs give no Haiku-vs-Sonnet 5.5 ratio. The Haiku 4.5 column uses its own tokenizer, so the third column scales Haiku 5.5's counts by 1.3, the docs' figure for the new tokenizer. That column answers only the Haiku 4.5 migration question: the Sonnet 5.5 columns use the unscaled counts of the first column, so compare across models within the same token basis only.

Context

Haiku 5.5

Haiku 5.5, 1.3x tokens

Haiku 4.5

Sonnet 5.5 (read $0.20)

Sonnet 5.5 (read $0.10)

30k

$0.0008

$0.0010

$0.0080

$0.0160

$0.0130

90k

$0.0014

$0.0091

$0.0140

$0.0280

$0.0190

150k

$0.0100

$0.0130

$0.0200

$0.0400

$0.0250

The 150k Haiku 5.5 cell is 150,000 x $0.05 + 2,000 x $0.625 + 500 x $2.50, all per 1M: $0.0075 + $0.00125 + $0.00125 = $0.0100. The cliff itself, at 96k vs 102k of context: 96,000 x $0.01 + 2,000 x $0.125 + 500 x $0.50 = $0.00096 + $0.00025 + $0.00025 = $0.0015, and at 102k, 102,000 x $0.05 + 2,000 x $0.625 + 500 x $2.50 = $0.0051 + $0.00125 + $0.00125 = $0.0076. That is 5.2x for 6k extra tokens. The 1.3x column hides a trap. Text that is 90k tokens on Haiku 4.5 becomes about 117k cache-read tokens on Haiku 5.5, over the cliff, so that cell is billed at the 5x tier: $0.0091 vs $0.0140, only 1.5x cheaper. The same arithmetic puts the crossover at about 75k tokens of old-tokenizer context (97.5k / 1.3). The sticker-price gap of 10x at 30k and 90k survives only if your token counts do not grow. Against Sonnet 5.5 the gap narrows but stays. Over 100k, Haiku's cache read is $0.05 vs Sonnet's $0.10, only 2x, while fresh input ($0.50 vs $2.00) and output ($2.50 vs $10) stay 4x cheaper. At 150k a whole turn is $0.0100 vs $0.0250, 2.5x. Take one request with 96,000 cached, 5,000 fresh and 1,000 output tokens (a 101k prompt): Haiku 5.5 costs $0.0098, Sonnet 5.5 $0.0296, and GPT-6 Luna $0.00196, because Luna's step is 2x at 272k, not 5x at 100k. ## "75% cheaper" describes old Haiku requests, not agent sessions Anthropic's headline is about 75% cheaper than Haiku 4.5 on average. Its footnote says Haiku 5.5 is 90% cheaper up to 100k and 50% cheaper above, that 90% of Haiku 4.5 requests were under 100k, and that the new tokenizer uses "slightly more tokens per task." The 90% is a count of requests on Haiku 4.5, not a spend share or an agent-session share. Anthropic does not say what those requests were; Haiku 4.5 had a 200K window and, by our reading, was mostly used for short tasks. Our calculation: 0.9 x 0.10 + 0.1 x 0.50 = 0.14 of the old price. The [migration guide](https://platform.claude.com/docs/en/models/haiku-5-5/migration-guide) says the same text yields about 30% more tokens, so 0.14 x 1.3 = 0.182, roughly 82% cheaper, not 75%. Reaching 0.25 would take about 1.79x token inflation, or spend-weighting that favours the long requests. Anthropic does not say which it used. For over-100k requests alone, 0.5 x 1.3 = 0.65, about 35% cheaper. Agent sessions skew long. In our transcript, context per call ran from 68,281 to 135,681 tokens with a median of 90,205, and 19 of 68 calls (28%) exceeded 100k. That is a Sonnet session, not a Haiku workload, but it shows how quickly a coding loop straddles the line. wmedia's Haiku 5.5 run is the direct measurement: 36 of 48 requests over 100K, with default compaction not triggering until about 967K. One run, but that is 75% of requests, not 10%. ## Practitioner reports are mixed, and the split by job size is only a tendency goosejuice uses small models as workers under a frontier orchestrator and says ["This approach works very well for me and don't have any issue staying under 100k."](https://news.ycombinator.com/item?id=50000316) chriddyp, who wrote the Plotly benchmark and so is not a neutral party, [reports](https://news.ycombinator.com/item?id=49999726) Haiku 5.5 was "9x cheaper than Haiku 4.5 and 2 letter grades better" on it. austegard [reports](https://bsky.app/profile/muninn.austegard.com/post/3mxjcvcnwqu26) 11,208 of 11,209 tests passing across 15 rebuilt Python libraries, one agent per library; cost isn't stated, and the same author concedes SWE-bench Verified exposure in training is likely. Two production users, independently, report Haiku 4.5 still winning: [d1l](https://news.ycombinator.com/item?id=49997391) ("Results so far are trash. Prompt leakage even. And it's slower.") and [HyperL0gi](https://news.ycombinator.com/item?id=49999167) ("Both evals and Human pairwise tests for our use case are giving Haiku 4.5 first place in pretty much all tests."). Replies to d1l suggest re-tuning prompts. [jjcm](https://news.ycombinator.com/item?id=49996898) tried image-to-HTML UI replication: "I was curious if this smaller model was good enough for complex UI. It was not." The most useful negative is from GENDA's [Zenn write-up](https://zenn.dev/genda_jp/articles/haiku-5-5-subagent-roles). For a read-only code-explore subagent, answer quality matched Sonnet, but Haiku made more tool calls, used more tokens (under 2x Sonnet) and was not faster. It did cost roughly a tenth. They kept Sonnet for speed on a subscription, did not test an implementer role, and call their sample small. Anthropic's Terminal-Bench 4.0 numbers are 39.2% for Haiku 5.5 vs 70.6% for Sonnet 5.5, and Anthropic says Sonnet 5.5 and Opus 5.5 [remain better choices for complex agentic coding tasks](https://www.anthropic.com/claude-haiku-5-5). Those are vendor figures; the Plotly, austegard, GENDA and Farmadupe numbers above are third-party. Per the [system card](https://www.anthropic.com/claude-haiku-5-5-system-card), Haiku 5.5 and Sonnet 5.5 were both run in Claude Code `--bare` at max effort, so that pair is a like-for-like comparison. Other rows are not: GPT-6 Luna's 16.4% comes from a public leaderboard using a different harness (Codex CLI). Separately, an HN commenter quoted Artificial Analysis noting its [provisional Haiku 5.5 cost figures excluded the step-up](https://news.ycombinator.com/item?id=50005796), so early cost-per-task charts understate long-context cost. ## Keep Haiku 5.5 requests under 100k and out of the main coding loop The price case and the quality case are separate. On price, Haiku 5.5 stays cheaper than Sonnet 5.5 even over the cliff, so cost alone does not rule out a Haiku main loop. The Terminal-Bench gap between the two (a like-for-like run) and the jjcm and d1l reports do. One rule for Haiku sessions: compact before the prompt reaches about 90k, which leaves margin for tokenizer growth, then count the requests over 100k in your logs to confirm. The 90k figure is our choice and untested. The only measured setting is wmedia's `autoCompactWindow` of 130000, one run per configuration: with default compaction, 36 of 48 requests went over 100K and the run cost $0.508; with 130000, 0 of 48 did and it cost $0.145 (-71%). We cannot explain why 130000 produced zero requests over 100K, so do not copy it without counting. Setting the window on a Haiku subagent took that subagent from $0.372 to $0.076 (-79%), but that is the compaction setting at work, not evidence that moving work to Haiku saves that much. At 100000 the main session hit a compaction loop, and one turn that reads everything cost 3x more with the window ($0.438 vs $0.149). Compaction is the awkward row in the table. It summarises a context that is already large, so its input is often the big one. Our calculation, assuming the input is uncached (a different model cannot reuse the main model's cache) and a 5k-token summary: a 90k input on Haiku 5.5 costs 90,000 x $0.10 + 5,000 x $0.50 = $0.0115. A 130k input costs 130,000 x $0.50 + 5,000 x $2.50 = $0.0775, because the whole request is repriced. The same 130k input on Sonnet 5.5 is $0.31. So Haiku still wins on price, but compaction only gets the cheap tier if it runs before the prompt passes 100k.

Job

Model

Condition

Evidence (* = Anthropic's own numbers)

Compaction, summarisation

Haiku 5.5

Run it before the prompt passes 100k

Anthropic's positioning*

Read-only explore subagent

Haiku 5.5

Small brief, accept more tool calls

GENDA: equal quality, about 1/10 cost, not faster

Scoped worker under an orchestrator

Haiku 5.5

Stays under 100k

goosejuice

Implementer, main coding loop

Sonnet 5.5 or Opus 5.5

Any length

Terminal-Bench 70.6% vs 39.2%*

Classification batch

Haiku 5.5 or GPT-6 Luna

Count tokens on your own data first

Farmadupe, one job: Haiku used about 1.5x Luna's input tokens

We covered the lead-plus-subagents pattern in [dynamic workflows in Claude Code](https://laxima.tech/blog/a-harness-for-every-task-dynamic-workflows-in-claude-code). How you route to Haiku is the part we have not verified. [sdd.sh](https://sdd.sh/2026/10/claude-haiku-5-5-subagent-model-pricing-effort-levels/) and one HN commenter report that Claude Code 2.1.293 resolves the `haiku` alias to Haiku 5.5, while another HN commenter says [a subagent always inherits the parent model](https://news.ycombinator.com/item?id=50004154) unless told otherwise. We tested neither. Route whole tasks, not turns. Moving a conversation between models discards its prompt cache; Nadir's advice is to [route whole tasks or sessions, not individual turns](https://getnadir.com/blog/claude-haiku-5-5-pricing-100k-cliff-tokenizer-effort/). Two edges to handle. Per the migration guide, Haiku 5.5 has no Priority Tier and no server-side fallback when safety classifiers decline, so handle `stop_reason: "refusal"`. And per Claude Code's docs, the `/usage` "Prompt cache (main)" line (v2.1.251+) covers the main conversation only, not subagents, so log subagent spend separately. ## Our numbers come from one 68-call session The method: sum the usage blocks per model from `~/.claude/projects` jsonl files, de-duplicate by message id and request id, and price each bucket at the rate card. Here is a minimal version that prices each bucket per model and counts requests over 100k prompt tokens. This is an illustrative version of our method, written for this post, and we did not record its output; the tables above come from the two scripts we logged, `usage.py` and `table.py`. ```python import glob import json import os from collections import defaultdict # $ per 1M tokens, 5-minute cache writes. Add your own models. RATES = { "claude-sonnet-5-5": {"read": 0.10, "write": 2.50, "input": 2.00, "output": 10.00}, } seen = set() tok = defaultdict(lambda: defaultdict(int)) over, calls = 0, 0 for path in glob.glob(os.path.expanduser("~/.claude/projects/**/*.jsonl"), recursive=True): with open(path) as fh: for line in fh: try: e = json.loads(line) except ValueError: continue m = e.get("message") or {} u = m.get("usage") if e.get("type") != "assistant" or not u: continue key = (m.get("id"), e.get("requestId")) if key in seen: continue seen.add(key) read = u.get("cache_read_input_tokens", 0) write = u.get("cache_creation_input_tokens", 0) fresh = u.get("input_tokens", 0) t = tok[m.get("model", "unknown")] t["read"] += read t["write"] += write t["input"] += fresh t["output"] += u.get("output_tokens", 0) calls += 1 over += (read + write + fresh) > 100_000 print(f"{over} of {calls} requests over 100k prompt tokens") for model, t in tok.items(): rate = RATES.get(model) if not rate: print(model, dict(t), "(no rate set)") continue dollars = {k: t[k] * rate[k] / 1e6 for k in rate} total = sum(dollars.values()) print(model, f"${total:.2f}") for k in rate: print(f" {k:6} {t[k]:>12,} tokens ${dollars[k]:.2f} {dollars[k] / total:6.1%}") ``` Limits. The directory held 11 jsonl files from one sandbox session, all Sonnet 5.5, so every Haiku 5.5 figure above is arithmetic on assumed turn shapes. We assumed the 5-minute write price and did not examine the 5m/1h split; the 1-hour row above shows the range. API dollar shares also do not predict subscription limits: [a GitHub issue](https://github.com/anthropics/claude-code/issues/59872) reports "cache\_read tokens counted at full rate despite cache hits on Max 20x", the quota formula is unpublished, and the report is unconfirmed. What would change our mind: a multi-week transcript run showing the over-100k share of a real Haiku subagent fleet, a first invoice that contradicts whole-request repricing, or data on Haiku-vs-Sonnet token counts for the same text, which the docs do not give. Run the sum on your own history before quoting any share. The count of requests over 100k tells you which Haiku tier you would pay. The [context window fit tool](https://laxima.tech/tools/context-window-fit) shows where a given prompt sits against the step. ### How much does Claude Haiku 5.5 cost per million tokens? Claude Haiku 5.5 costs $0.10 per million input tokens, $0.50 output, $0.01 for cache reads and $0.125 for 5-minute cache writes, while the prompt stays at or under 100k tokens. Above 100k every one of those prices is 5x higher: $0.50 input, $2.50 output, $0.05 cache reads. ### Does the Haiku 5.5 100k price step apply only to tokens past 100k? No. Per Anthropic's pricing docs, the step applies to the whole request, and the 100k count includes cache reads and cache writes. A request with a 102k-token prompt pays the higher rate on all 102k tokens. In LAXIMA's arithmetic, going from 96k to 102k of context makes one turn about 5.2x more expensive. ### Is Claude Haiku 5.5 really 75% cheaper than Haiku 4.5? Only for short requests. Haiku 5.5's sticker prices are 90% lower than Haiku 4.5 up to 100k tokens and 50% lower above it, but its tokenizer produces about 30% more tokens for the same text. Above 100k, LAXIMA's calculation puts it at about 35% cheaper, and agent sessions cross 100k often. ### How much does the Sonnet 5.5 cache-read price cut save? It depends on your token mix. Halving Sonnet 5.5 cache reads from $0.20 to $0.10 per million saved 11-16% on LAXIMA's write-heavy Claude Code session and 31-35% on two published read-heavy mixes. Anthropic says around 20% on most agentic tasks, but does not publish the mix behind that figure. ### Should I use Claude Haiku 5.5 as the main model in Claude Code? Not for the main coding loop. Price doesn't rule it out, since Haiku 5.5 stays cheaper than Sonnet 5.5 even over 100k. Quality does: Anthropic reports 39.2% on Terminal-Bench 4.0 for Haiku 5.5 against 70.6% for Sonnet 5.5. Use Haiku for compaction, read-only explore subagents and scoped workers kept under 100k. ### How do I keep Haiku 5.5 requests under the 100k threshold? Compact the context before the prompt reaches about 90k tokens, which leaves room for tokenizer growth, then count the requests over 100k in your logs. In one published run, raising autoCompactWindow to 130000 took a Haiku session from 36 of 48 requests over 100k to none, and cut its cost by 71%.