Claude Haiku 5.5 costs a tenth of Haiku 4.5. One more token of prompt can make a request cost 5 times as much.
What Haiku 5.5 is, the price step at 100,000 tokens, the old requests that now fail, and my run of the same 12 tickets on both models.
On 7 October 2026 Anthropic released Claude Haiku 5.5, its new small, fast model. For prompts up to 100,000 tokens it costs a tenth of Haiku 4.5 per token. Above that line, the price table gives five times those rates.
I read Anthropic’s pages, sent the same 12 support tickets to Haiku 4.5 and Haiku 5.5, and worked out where the price jumps and which old code stops working. Both models got all 12 tickets right. Haiku 5.5 counted the same requests as 1.42 times as many tokens and still cost 86% less per ticket.
Below: what the model is, the price and the step, what changed from Haiku 4.5, Anthropic’s benchmark numbers, my run, the cost arithmetic, and the checks I would do before switching.
What Anthropic released
Haiku is the smallest and cheapest line of Claude models. Anthropic’s models come in several sizes, including Fable, Opus and Sonnet above Haiku. Haiku 5.5 is the successor to Haiku 4.5.
It came out on Anthropic’s API (the web service your code calls), Amazon Web Services, Google Cloud and Microsoft Azure (as Microsoft Foundry). In the API it is called claude-haiku-5-5. Anthropic's migration guide says this is a fixed name with no date added and no second, shorter name, so the name you test with is the name you run. The overview page says it will not be retired (switched off) before 7 October 2027.
Anthropic aims it at work that is done many times a day and must be quick:
- sorting messages into categories (classification)
- deciding which system handles a request (routing)
- pulling fields out of documents (extraction)
- summaries
- subagent work, where a bigger model hands small jobs to a cheaper one
The announcement says it pairs with Opus 5.5 and Sonnet 5.5 as a subagent on coding work, and that it is Anthropic’s fastest model to date at standard speed. Its footnote adds that Opus models in Fast Mode are quicker.
Introducing Claude Haiku 5.5: the cheapest, fastest, and most capable small model we’ve ever released.
That is Anthropic’s own line from the launch post.
Anthropic announced two related changes at the same time. A cache is a store of prompt text the API has already read; reading from it again is a cache read, and it costs much less than new input. Cache reads on Sonnet 5.5 were halved to $0.10 per million tokens, which Anthropic says makes Sonnet 5.5 about 20% cheaper on most agent work. And Anthropic says that this week it will start giving Claude Max and Team subscribers a monthly API credit: $100 a month on Max 5x, $200 on Max 20x and up to $500 for a Team, usable on any model. If you have one of those plans, that is enough to test Haiku 5.5 on your own prompts.
The price, and the step at 100,000 tokens
A token is a small piece of text, often part of a word. Input tokens are what you send (the prompt). Output tokens are what the model writes back. You pay for both.
This is the part that matters most: one extra token of prompt can make a request cost five times as much.
The context window is the most text a model can take in one request. Anthropic’s pricing page says the other Claude models from 4.6 onward charge one rate however full that window gets. Haiku 5.5 does not. It is priced by the length of the prompt, and a prompt of over 100,000 tokens pays higher prices.
Anthropic’s prices, read on 8 October 2026, per million tokens:
- Input, prompt up to 100,000 tokens: $0.10
- Output, prompt up to 100,000 tokens: $0.50
- Cache read (hit), up to 100,000 tokens: $0.01
- Input, prompt over 100,000 tokens: $0.50
- Output, prompt over 100,000 tokens: $2.50
- Batch API (answers within hours, not seconds): 50% off input and output
- Haiku 4.5, for comparison: $1 in, $5 out
As I read Anthropic’s price table, the higher rates apply to the whole request, not only to the tokens above 100,000. The table lists both the input and the output price “for prompts over 100,000 tokens”. Anthropic’s pages do not say whether cached tokens count toward the 100,000. My arithmetic assumes they do, so check this on a real bill.
In my arithmetic, a request with a 100,000-token prompt and a 1,000-token answer costs $0.0105. Add one token to the prompt and it costs $0.0525, five times as much.
Anthropic says prompts up to 100,000 tokens were about 90% of the requests sent to Haiku 4.5. It also says that on average Haiku 5.5 costs around 75% less to run, after allowing for the new tokenizer, which I explain next.
What else changed from Haiku 4.5
A bigger window. Haiku 5.5 can read 1 million tokens in one request, up from 200,000, and write up to 128,000 tokens of answer, up from 64,000. Anthropic’s overview puts 1 million tokens at roughly 555,000 words. It reads text and images and writes text, and its reliable knowledge runs to June 2026.
Thinking is on by default. Thinking means the model writes hidden working notes before its answer, and you pay for those tokens as output. Haiku 4.5 only thought when you switched it on and gave it a budget of tokens. Haiku 5.5 uses adaptive thinking: it decides for itself whether and how long to think, and you steer it with a setting called effort (low, medium, high and so on). Medium is the default. At lower effort the model thinks less and can skip thinking on simple requests. Anthropic says this is its first Haiku-class model with an adjustable effort setting.
More tokens for the same text. A tokenizer is the program that cuts text into tokens. Haiku 5.5 uses the newer tokenizer that Claude models from 4.7 onward use. Anthropic says the same input becomes about 30% more tokens than on Haiku 4.5, depending on the content. So a cost estimate made on Haiku 4.5 is no longer right, and neither is a max_tokens limit (the most tokens you allow the model to write in one reply). Count again with the new model.
New tools and new limits. Haiku 5.5 can use Anthropic’s browser use tool, which lets it work inside web pages, on the Claude API and Google Cloud. It runs safety classifiers, small checking models that can block a request. The reply then carries stop_reason “refusal” (the field that tells your code why the model stopped), with no automatic fallback to another model, so your code has to handle that answer. Priority Tier, Anthropic’s paid option for guaranteed capacity, is not supported on Haiku 5.5.
More request settings now fail. These return HTTP 400, which means the API rejects the request as badly formed:
- a temperature other than 1 (temperature is a setting for how random answers are)
- any top_k
- a top_p set to anything except 0.99 (top_p and top_k are older randomness settings; 0.99 is top_p’s default, so the simplest fix is to leave it out)
- temperature and top_p sent together
- an assistant prefill, which means writing the first words of the model’s answer for it
- a thinking budget (budget_tokens)
- the old computer_20250124 computer use tool, on the Claude API and Google Cloud
For JSON answers, Anthropic points to structured outputs, an API option that makes the answer follow a JSON shape you give.
One more rule matters for agents. An agent is a model that works through a task in many steps, calling tools along the way. The API sends its reply as a list of pieces called content blocks. A thinking block is the piece that holds the model’s hidden notes. An agent sends the whole conversation back on every step, thinking blocks included.
On Haiku 5.5 that only works if you never edit what came before. Change the system prompt, the tools or an earlier message and then send a thinking block back, and the request fails with a 400 error. So only ever add new messages at the end. This is called keeping the conversation append-only.
If your Anthropic account was created before 31 August 2026, you only get this error when your request sets the field that controls the check (thinking.block_binding.prefix_mismatch_behavior).
Get Roni Das’s stories in your inbox
Join Medium for free to get updates from this writer.
Separately, a thinking block only works in the account that produced it or one linked to it. Send it from any other account and the API throws it away without an error. The model then answers without its earlier notes, which can quietly make answers worse.
How good is it? Anthropic’s numbers, not mine
A benchmark is a fixed set of test tasks with a score, so models can be compared. Every number below is from Anthropic’s 7 October 2026 announcement, run by Anthropic with its own setup. I did not re-run any of them. GPT-6 Luna is the OpenAI model Anthropic chose to compare with.
- GDPval-AA v2.1, real-world professional work (a rating, higher is better): Haiku 5.5 1620, Haiku 4.5 735, GPT-6 Luna 1437, Sonnet 5.5 1840
- OSWorld 2.1, offline subset, using a computer: Haiku 5.5 72.4%, Haiku 4.5 15.7%, GPT-6 Luna 48.9%, Sonnet 5.5 83.9%
- Humanity’s Last Exam, no tools, very hard questions: Haiku 5.5 45.9%, Haiku 4.5 10.2%, GPT-6 Luna not given, Sonnet 5.5 56.9%
- Terminal-Bench 4.0, coding tasks in a command line: Haiku 5.5 39.2%, Haiku 4.5 0.0%, GPT-6 Luna 16.4%, Sonnet 5.5 70.6%
- Chartography, no tools, reading charts: Haiku 5.5 46.4%, Haiku 4.5 6.4%, GPT-6 Luna 29.1%, Sonnet 5.5 61.6%
The pattern in Anthropic’s own table: a very large jump over Haiku 4.5 everywhere, ahead of GPT-6 Luna on every row where both are given, and still clearly behind Sonnet 5.5.
Anthropic says so itself. Sonnet 5.5 and Opus 5.5 remain the better choice for complex agentic coding, meaning long coding jobs the model works through on its own over many steps. Haiku 5.5 is best for narrowly scoped tasks such as compaction (shrinking a long conversation into a summary), summarisation and subagent work.
Customers quoted in the announcement report the same direction on their own tests. AlphaSense ran 400 queries of its document Q&A feature and scored Haiku 5.5 at 0.84 against 0.76 for Haiku 4.5. HubSpot reported 92.8% on its tests of customer-records (CRM) tasks, averaged over three runs. These are their tests, reported by Anthropic. Use them to decide what to test yourself.
My run: the same 12 tickets on Haiku 4.5 and Haiku 5.5
I wanted real numbers, not only a price table, so I ran one real job on both models on 8 October 2026, from India, on a MacBook with an Apple M4 chip and 24 GB of memory.
First I tried the Messages API, the plain HTTP interface most apps call. The Anthropic key this project has answered HTTP 400, “Your credit balance is too low”. The account had no API credit, so no request reached either model that way and nothing was billed.
Then I used the Claude Code command line tool (CLI), version 2.1.34, in print mode. Print mode sends one prompt and prints the answer as JSON, including the token counts the API reported. I turned off all its tools and replaced its system prompt (the standing instructions sent before every message) with my own.
The counts show the CLI adds text of its own to every request. My instruction and a ticket are about 40 tokens, but each request to Haiku 4.5 counted 149 to 159 input tokens. So roughly 110 tokens a request on Haiku 4.5, and more on Haiku 5.5’s tokenizer, are text I did not write. Every token and dollar figure below includes them. A direct API call would be cheaper on both models.
The job was a ticket router: read one customer message and reply with one word, billing, bug, account or shipping. I wrote 12 tickets with known right answers, three per label, and sent each one to both models, one request per ticket.
SYSTEM = "You route customer support tickets. Reply with exactly one word from this list: billing, bug, account, shipping."
TICKETS = [("I was charged twice for my annual plan this month.", "billing"),
("The export button does nothing when I click it in Firefox.", "bug"),
("How do I change the email address on my login?", "account"),
("My parcel says delivered but nothing arrived.", "shipping"),
...] # 12 in all, three per label$ python3 router_cli.py
claude-haiku-4-5: 12/12 right | input 1833 tokens, output 48 | API time median 0.68 s (min 0.62, max 3.56) | list-price cost $0.002073, $173 per million tickets
claude-haiku-5-5: 12/12 right | input 2606 tokens, output 48 | API time median 0.91 s (min 0.79, max 1.09) | list-price cost $0.000285, $24 per million tickets
same 12 prompts: 2606 input tokens on Haiku 5.5 against 1833 on Haiku 4.5 = 1.42xWhat came back:
- Both models routed all 12 tickets correctly.
- More tokens. Haiku 5.5 counted the same 12 requests as 2,606 input tokens against 1,833 on Haiku 4.5, about 217 and 153 a request, 1.42 times as many. That is more than Anthropic’s “approximately 30%”. Part of the reason: roughly 110 of every 153 tokens on Haiku 4.5 are the CLI’s own text, not my tickets, and that text may split into tokens differently from ordinary prose. Anthropic says the exact increase depends on the content.
- Still much cheaper. At a tenth of the price per token, all 12 cost $0.000285 against $0.002073. That is $24 per million tickets against $173, or 86% less, including the CLI’s overhead.
- No hidden thinking billed. Each answer was 4 output tokens on Haiku 4.5 and 3 to 5 on Haiku 5.5, 48 in all on each. I did not set the effort, and I cannot tell from the CLI’s output whether the model skipped thinking by itself or the CLI’s own settings turned it off.
- Not faster in my run. The median (middle) time at the API was 0.91 seconds for Haiku 5.5 against 0.68 for Haiku 4.5, through the CLI, from India, the day after launch. My first attempt stopped partway, so five of the Haiku 4.5 answers come from that attempt, a few minutes earlier. Network speed can change in minutes, so the timing comparison is rough. This was not a speed test, but it is a reason to measure response time yourself.
One more thing the run showed: CLI version 2.1.34 does not know the new model yet. It reported a 200,000-token window and a cost of $0.008538 for the Haiku 5.5 run, about 30 times the list-price figure, because it priced the tokens at a rate that is not Haiku 5.5’s. If you track spend with a tool, update it, or compute the cost from token counts yourself, as I did.
Twelve tickets is a smoke test (a quick check that something works at all), not an eval (a scored test on many real examples). It shows the switch works and roughly what it costs, not that Haiku 5.5 is better at your task.
I also wrote a small offline checker for the request shapes in Anthropic’s migration guide. It sends no request. Here is what it found in three typical Haiku 4.5 requests:
$ python3 migrate_check.py
a classifier tuned for Haiku 4.5:
- temperature other than 1: remove it
- max_tokens 5: thinking counts toward it, leave room (warning)
JSON forced with a prefill:
- assistant prefill: end messages with a user turn
- max_tokens 512: thinking counts toward it, leave room (warning)
extended thinking with a budget:
- thinking with budget_tokens: use {"type": "adaptive"} and output_config.effort
the migrated request: OKThe max_tokens warning at 1024 is my own rule of thumb, not Anthropic’s.
What it costs: the step, the tokenizer, thinking and caching
Four things decide the real bill.
The step. Stay under 100,000 tokens of prompt and Haiku 5.5 is about 87% cheaper than Haiku 4.5 for the same text and the same length of answer, by my arithmetic. Go over and it is still about 35% cheaper, but each request costs five times what it did just under the line.
The tokenizer. The same text is about 30% more tokens, which eats part of the price cut. That is already counted in both numbers. My router run came out at 86% less rather than 87% because its token ratio was 1.42, not 1.3, with the CLI’s own text included.
Thinking. Those numbers assume no hidden thinking. At the default medium effort Haiku 5.5 may think and bill extra output tokens, which narrows the gap.
Caching. If many requests start with the same text, for example the same long instructions, the API can keep that opening part stored. Reading it again is a cache hit, and it costs a tenth of normal input.
Here is the arithmetic, one request with 1,000 tokens of answer, no caching:
$ python3 cost.py
one request, 1,000 tokens out, by prompt length (Haiku 5.5 tokens)
prompt Haiku 5.5 Haiku 4.5 5.5 vs 4.5
2,000 $ 0.00070 $ 0.00538 87% less
20,000 $ 0.00250 $ 0.01923 87% less
99,000 $ 0.01040 $ 0.08000 87% less
100,000 $ 0.01050 $ 0.08077 87% less
101,000 $ 0.05300 $ 0.08154 35% less
150,000 $ 0.07750 $ 0.11923 35% less
500,000 $ 0.25250 too long
1,000,000 $ 0.50250 too longthe step at 100,000: one more token of prompt
100,000 -> $0.01050 100,001 -> $0.05250 5.0xa document Q&A service: 100,000 requests a month, 20,000 tokens in, 500 out
Haiku 5.5 $ 225 a month with 18,000 cached $ 63
Haiku 4.5 $ 1,731 a month with 18,000 cached $ 485
Haiku 4.5 is counted on the same text as the Haiku 5.5 tokens divided by 1.3, from Anthropic’s “about 30% more tokens”. Its window is 200,000 of its own tokens, about 260,000 Haiku 5.5 tokens. Your own text may differ, so count it with Anthropic’s token counting endpoint (an API address that counts tokens without running the model) before you rely on these numbers.
So for a document question-and-answer service with 100,000 requests a month, each with a 20,000-token prompt and a 500-token answer, I get $225 a month on Haiku 5.5 against $1,731 on Haiku 4.5. If 18,000 of the 20,000 prompt tokens are cache hits, it is $63 against $485.
What the step means in practice: if your prompts sit just over 100,000 tokens, trimming them under the line makes each request cost about a fifth as much (about 80% less). Retrieval systems, which paste found documents into the prompt, can cap how much they paste. Long agent conversations can be compacted, but if you send thinking blocks back, start a new conversation from the summary rather than editing the old one, because Haiku 5.5 rejects a thinking block after earlier turns change.
Sonnet 5.5 has no step, but at $2 in and $10 out per million it costs four times Haiku’s upper rates. So the step never makes Sonnet the cheaper choice. Move long prompts to Sonnet only if Haiku’s answers are not good enough.
GPT-6 Luna, the OpenAI model in Anthropic’s comparison, lists the same per-token price for short prompts on OpenAI’s pricing page: $0.10 in, $0.01 cached and $0.50 out per million. The two companies use different tokenizers, so the same text is a different number of tokens on each. Only a run on your own prompts tells you which is cheaper for you.
Should you move to Haiku 5.5?
For most Haiku 4.5 workloads the price alone says yes. These are the checks I would do first, in order.
- Fix the requests that now fail. Remove temperature, top_p and top_k. Replace any assistant prefill with structured outputs or a user-turn instruction. Replace a thinking budget with adaptive thinking and an effort level. Move computer use to the new toolset. Read the answer by block type, not by position, because the first block may be a thinking block. If you send thinking blocks back, keep conversations append-only and replay them through the account that produced them. Handle stop_reason “refusal”.
- Count your tokens again. Use Anthropic’s token counting endpoint with the model set to
claude-haiku-5-5.Raise any small max_tokens, because thinking tokens count toward it and a tiny limit can stop the reply before any text. - Find your prompts near 100,000 tokens. Log the prompt length of every request. If some sit just above 100,000, trimming them under the line is the cheapest change you can make. If many are far above, price them against Sonnet 5.5 too.
- Choose the effort level. Medium is the default, and the model may think on any request. For classification and routing, try low effort, check the answers, and measure the output tokens, which is where thinking is billed.
- Run your own eval before you move traffic. Take 30 to 50 real examples with known right answers and score both models. Anthropic’s benchmarks and customer quotes say Haiku 5.5 is much stronger than 4.5; your prompts decide whether that holds for you. Keep Haiku 4.5 as the fallback until it does.
What I could and could not check
The facts about the model come from Anthropic’s announcement, its Haiku 5.5 overview, its “What’s new” page, its migration guide and its pricing page, all read on 8 October 2026. GPT-6 Luna’s price comes from OpenAI’s pricing page the same day.
I ran 12 tickets on each model through the Claude Code CLI and reported what came back, including the CLI’s own added text in the token counts. I could not use the Messages API directly, because this project’s API key had no credit. So I did not test effort levels, thinking display, the 1 million token window, the price step on a real bill, or the new error messages against the live API. The 400 errors here are from Anthropic’s documentation; my checker covers the request settings in it, not the append-only rule.
Every benchmark here is Anthropic’s, and every customer result is the customer’s, as quoted by Anthropic.
The original article has the full scripts, the raw output and links to every source: https://www.systemdesign.academy/explained/claude-haiku-5-5
Where to go from here
Price is the easy part. What takes work is knowing which requests a cheaper model can take, proving it on your own examples, and knowing where your tokens go.
I write two courses on systemdesign.academy. AI Engineering teaches how to build AI systems that hold up in production: RAG, AI agents, evals and model serving, with real labs, including lessons on model routing and cascades and on token cost engineering. It is $49, paid once: https://www.systemdesign.academy/ai-engineering
The System Design Masterclass covers the other half of the job, from caching and databases to distributed systems, with interview designs like Uber, Netflix, Stripe and WhatsApp. It is also $49, paid once: https://www.systemdesign.academy/system-design-course
