Haiku 5.5 costs about 75% less than Haiku 4.5 on average. Worked examples show what that means for a 20-turn agent run, a classification job, and the 100K-token tier.
Claude Haiku 5.5 pricing looks simple on the rate card and gets interesting the moment you model a real workload. Anthropic published the model on October 7, 2026 at $0.10 per million input tokens and $0.50 per million output tokens for requests up to 100,000 tokens, with a steeper tier above that line and very cheap cache reads at both levels. This article runs the numbers through three workloads, shows where the 100,000-token threshold changes the math, and tests whether the cheaper model is also the cheaper way to finish a task.
Prices come from Anthropic’s launch page and may change after October 10, 2026. Benchmark figures are Anthropic’s own. The arithmetic is mine, and every assumption is stated so you can swap in your own.
The published rate card
| Per million tokens | Haiku 5.5, up to 100K prompt | Haiku 5.5, over 100K prompt | Haiku 4.5 | Sonnet 5.5 |
|---|---|---|---|---|
| Input | $0.10 | $0.50 | $1.00 | $2.00 |
| Output | $0.50 | $2.50 | $5.00 | $10.00 |
| Cache reads | $0.01 | $0.05 | $0.10 | $0.10 (cut from $0.20) |
| Cache writes | $0.125 | $0.625 | $1.25 | $2.50 |
The model ID is claude-haiku-5-5, and it is available on the Claude Platform, Amazon Web Services, Google Cloud and Microsoft Azure. The page does not state a context window or a maximum output length. A news roundup on October 8 reported a one-million-token window, which I could not find on Anthropic’s page, so treat that figure as unconfirmed.
What “about 75 percent cheaper” means
Anthropic says Haiku 5.5 costs about 75 percent less to run than Haiku 4.5 on average. The page breaks that into two parts: a 90 percent discount for requests up to 100,000 tokens and a 50 percent discount for longer ones. It adds that about 90 percent of Haiku 4.5 requests fell under the threshold, and that the estimate accounts for a new tokenizer that uses slightly more tokens per task.
Weighting by request count alone gives 0.9 times 90 plus 0.1 times 50, or 86 percent. The published figure is lower. The page does not show its method, so what follows is my inference: long requests probably carry a larger share of total spend, which drags the blended discount toward 50 percent, and the tokenizer change takes a further bite. At least one headline cites a 90 percent cut, which matches the under-100,000 discount and not the blended average.
The 100,000-token cliff
Because the higher tier is described as applying to requests, a prompt that crosses the line probably reprices in full and not just the tokens above it. The page’s wording points that way, but confirm it in the documentation before building around it. Under that reading, an uncached call with 1,000 output tokens costs $0.0105 at a 100,000-token prompt and $0.0525 at 100,001, a fivefold jump for one extra token.
A 120,000-token prompt with the same output costs $0.0625 on Haiku 5.5, against $0.125 on Haiku 4.5. The discount is still 50 percent, and the practical lesson is to compact or summarize before the prompt reaches the line, which fits the summarization and compaction work Anthropic lists as the model’s target.
A worked agent run
Assume an agent that takes 20 turns. It carries a 40,000-token prefix of instructions and tool definitions, writes that prefix to the cache on the first turn and reads it on the other nineteen. Each turn adds 2,000 tokens of fresh input and produces 500 tokens of output. The model ignores conversation growth and cache expiry, so real runs will differ.
| Model | Cost per run, cached | Cost per run, no cache | Per 1,000 cached runs |
|---|---|---|---|
| Haiku 5.5 | $0.0216 | $0.0890 | $21.60 |
| Haiku 4.5 | $0.2160 | $0.8900 | $216.00 |
| Sonnet 5.5 | $0.3560 | $1.7800 | $356.00 |
Two patterns stand out. Caching removes about three quarters of the bill on Haiku models and about four fifths on Sonnet 5.5, so a long, stable prefix is worth engineering for. And Haiku 5.5 comes in at one tenth of Haiku 4.5’s cost on this workload, because every token in the run sits under the 100,000 line. At the old $0.20 cache-read price Sonnet 5.5 would have cost $0.432 per run, so the halved price trims about 18 percent here, in the neighborhood of the 20 percent Anthropic estimates for most agentic work.
A high-volume classification job
Now take the opposite shape: no cache, 1,500 tokens in and 50 tokens out per request. A million requests cost $175 on Haiku 5.5, $1,750 on Haiku 4.5 and $3,500 on Sonnet 5.5. At this scale the output price barely matters and the input price is nearly everything, which is why classification, extraction and routing are the places where a small model’s rate card pays off fastest.
Where Sonnet 5.5 still wins
Price per token is only half of cost per finished task. Anthropic’s own benchmark table shows where the larger model keeps a clear lead:
| Benchmark (Anthropic-reported) | Haiku 5.5 | Haiku 4.5 | GPT-6 Luna | Sonnet 5.5 |
|---|---|---|---|---|
| GDPval-AA v2.1 | 1620 | 735 | 1437 | 1840 |
| AA-Briefcase v1.1 | 1578 | 614 | 1336 | 1824 |
| OSWorld 2.1, offline subset | 72.4% | 15.7% | 48.9% | 83.9% |
| Humanity’s Last Exam, no tools | 45.9% | 10.2% | not reported | 56.9% |
| Humanity’s Last Exam, with tools | 57.4% | 18.7% | not reported | 64.5% |
| Terminal-Bench 4.0 | 39.2% | 0.0% | 16.4% | 70.6% |
| FrontierCode 1.1 (Main) | 46.4% | not reported | 42.4% | 52.1% |
| Chartography, no tools | 46.4% | 6.4% | 29.1% | 61.6% |
The FrontierCode figure for Sonnet 5.5 was run at Xhigh effort. The widest gap is Terminal-Bench 4.0, where Sonnet 5.5 scores 70.6 percent to Haiku 5.5’s 39.2 percent, and Anthropic itself recommends Sonnet 5.5 and Opus 5.5 for complex agentic coding.
Here is one way to fold success rates into price, strictly as an illustration. Use the worked agent run above as the cost per attempt, treat the Terminal-Bench pass rates as stand-ins for your own success rates, and assume attempts are independent and checkable so that a failed one can simply be retried. Haiku 5.5 then costs about $0.055 per success ($0.0216 divided by 0.392), and Sonnet 5.5 about $0.50 ($0.356 divided by 0.706). Real tasks are not benchmark tasks, and retries are only free when something can verify the result, but the exercise shows why a cheap model with a modest pass rate can still win on cost per finished task.
The routing pattern Anthropic is pushing
The launch page positions Haiku 5.5 as a subagent as well as a standalone model. Anthropic cites Cognition, whose Devin Fusion scored 66.2 on FrontierCode with Haiku 5.5 as the sidekick model. It also lists customer-reported results: Asana saw about 30 percent lower task-completion latency, HubSpot reported 92.8 percent on its CRM suite averaged over three runs, and Box reported a score 11 points above Haiku 4.5 at about half the latency. These are customer figures chosen for a launch page. They are useful as hints about where to test and not as proof it will hold for you.
Other details worth knowing
Haiku 5.5 is the first Haiku-class model with an adjustable effort setting, with levels from Low through Max, and Anthropic calls it the fastest of its models at standard speed. Cybersecurity safeguards are stricter than Haiku 4.5’s but looser than Sonnet 5.5’s, and the biology safeguards match those of the larger models. Subscribers get API credits as well: Max 5x plans include $100 a month, Max 20x plans $200, and Team plans up to $500 pooled.
A monthly budget, with and without escalation
Scale the worked run to 50,000 agent runs a month. Everything on Haiku 5.5 comes to $1,080, everything on Haiku 4.5 to $10,800, and everything on Sonnet 5.5 to $17,800. Those are the two ends of the range, and neither is how most teams will actually run it.
A tiered setup is more realistic. Suppose every run starts on Haiku 5.5 and one in five fails a check and is rerun on Sonnet 5.5. The Haiku attempts cost $1,080 across all 50,000 runs, and the 10,000 Sonnet reruns add $3,560, for a total of $4,640. That is about 74 percent below the all-Sonnet bill, and the assumptions that matter are the escalation rate and the cost of the check that triggers it.
A rule of thumb for choosing per step
The deciding question is whether a cheap test can verify the output. Code with a test suite, extraction with a schema, and classification against known labels can all be checked automatically, so starting small and escalating on failure is safe. Work with no automatic check, such as a summary a customer will read directly, puts the cost of a wrong answer on a person, and there the larger model’s higher pass rate may be worth its price. Measure on your own tasks before settling the split, because benchmark gaps shrink and grow depending on the work.
What I could not verify
The context window and maximum output length are not on the page I read. The size of the tokenizer effect is not given. Anthropic’s 75 percent average depends on its own request mix, and yours may differ. And I assumed that the over-100,000 tier reprices an entire request, which fits the page’s language but should be checked against the pricing documentation.
Frequently asked questions
Is Haiku 5.5 really 75 percent cheaper than Haiku 4.5? That is Anthropic’s average estimate. For requests under 100,000 tokens the discount is 90 percent, and for longer requests it is 50 percent.
Does prompt caching still matter? Yes. In the worked run above, caching cut the bill by roughly three quarters on Haiku 5.5.
When should I pick Sonnet 5.5 instead? When the task is hard enough that the benchmark gap shows up in your own tests, particularly terminal-style agentic coding, where Anthropic’s own numbers show the widest spread.
Sources
