Anthropic's Haiku 5.5 is genuinely cheap per token. Per completed workflow it is a different calculation: a 30% token-count shift, a 5x price step at 100k, and adaptive thinking billed as output.
Last Updated: October 13, 2026
Claude Haiku 5.5 is priced at $0.10/$0.50 per million input/output tokens for prompts under 100,000 tokens, and $0.50/$2.50 above that — a 5x step, not a taper. Three things break naive cost comparisons: the newer tokenizer counts the same text as roughly 30% more tokens, adaptive thinking is on by default and bills as output, and cache reads count toward the 100k threshold. Price per completed workflow, including the human exception queue, before you demote any step.
What Anthropic actually shipped on 7 October
Haiku 5.5 is a small model aimed squarely at the work that dominates agent pipelines by volume: classification, routing, extraction and subagent calls. Anthropic's model overview lists a 1M-token context window, 128k max output tokens (300k on the Batch API behind a beta header), a June 2026 knowledge cutoff, release on 7 October 2026 and a retirement date no sooner than 7 October 2027.
The pricing is tiered by prompt length. Anthropic's announcement puts input at $0.10/MTok and output at $0.50/MTok for prompts up to 100,000 tokens, rising to $0.50 and $2.50 above it, against Haiku 4.5's flat $1/$5. Cache reads drop to $0.01/MTok under the threshold, from $0.10 on Haiku 4.5. Anthropic's own framing of the headline saving is careful: 90% lower under 100k, 50% lower over it, and around 75% less to run on average once you account for the fact that the newer tokenizer consumes more tokens per task.
Benchmarks moved a long way for a Haiku-class model. On Anthropic's published results, Haiku 5.5 scores 1620 on GDPval-AA v2.1 against 735 for Haiku 4.5 and 1437 for GPT-6 Luna, and 72.4% on the OSWorld 2.1 offline subset against 15.7%. It also scores 39.2% on Terminal-Bench 4.0 where Sonnet 5.5 scores 70.6% — which is the number that should govern your routing decisions more than the GDPval jump does.
The tokenizer change quietly invalidates your existing cost model
Anthropic flagged this explicitly rather than burying it, and almost every roundup this week skipped it anyway. Haiku 5.5 uses the same newer tokenizer as Claude 4.7 and later models, so the same input text produces approximately 30% more tokens than on Claude Haiku 4.5, with the exact increase depending on content. The migration guide is blunt about the consequence: recount your prompts with model set to claude-haiku-5-5 rather than reusing counts measured on Haiku 4.5.
If your finance model was built from a token-usage export taken last quarter, every per-item figure in it is now understated by roughly a third on the input side. That matters less when the unit price falls 90% — but it matters a great deal for anything you sized in tokens rather than dollars: max_tokens ceilings, chunk sizes, context budgets, the threshold at which your router escalates to a bigger model, and the 100k price boundary itself.
Two secondary effects compound it. Images cost more: Haiku 5.5 uses the high-resolution image tier, and an image of 2,000 by 1,500 pixels costs about 2.5 times as many visual tokens as on Haiku 4.5. If your extraction pipeline feeds scanned invoices or screenshots, that is a direct multiplier on your highest-volume step. And in conversations, Haiku 5.5 keeps thinking blocks from all earlier assistant turns in context, where Haiku 4.5 kept only the latest turn's — so multi-turn agent loops carry more input tokens than the tokenizer change alone explains, unless you enable thinking block clearing.
Then there is adaptive thinking, which is on by default at medium effort. Thinking tokens bill as output, at the output rate, and count toward max_tokens. A classification step that previously returned a 40-token JSON object on Haiku 4.5 with thinking off can now return 40 tokens of answer behind several hundred tokens of reasoning. Anthropic's prompting guide notes that in its testing, telling the model in the prompt to answer directly did not stop it from thinking — you lower effort, or set thinking: {"type": "disabled"}, which works at low, medium and high only.
The 100k cliff is a pipeline design constraint, not a pricing footnote
Every other current Claude model prices the full 1M window at a flat rate. Haiku 5.5 does not. The pricing documentation spells out the mechanics that bite in production: a request's prompt length counts all of its input tokens, including cache reads and cache writes, and each request is priced on its own — a request over the threshold pays the higher prices even when part of its prompt is a cache hit.
Read that twice if you run a long-lived agent with a large cached system prompt. A 90k-token cached preamble plus a 15k-token document is a 105k-token prompt. The whole thing prices at the upper tier, and the cache read you were counting on at $0.01/MTok bills at $0.05/MTok.
| Request shape | Input tokens | Output tokens | Cost per call | Cost per 10,000 calls |
|---|---|---|---|---|
| Just under the threshold | 99,000 | 2,000 | $0.0109 | $109 |
| Just over the threshold | 101,000 | 2,000 | $0.0555 | $555 |
| Retrieval instead of stuffing | 8,000 | 2,000 | $0.0018 | $18 |
| Full 1M window stuffed | 1,000,000 | 2,000 | $0.5050 | $5,050 |
Arithmetic from the published Haiku 5.5 rates, uncached and excluding batch discounts. A 2% increase in prompt size across the boundary produces a 5x increase in cost. That is not a gradient your autoscaler will smooth out; it is a step function sitting in the middle of your highest-volume path.
Treating a 1M window on a cheap model as a replacement for retrieval
The reasoning looks sound: tokens are now a tenth of the price, retrieval infrastructure costs engineering time, so stuff the whole knowledge base into context and delete the vector store. On Haiku 5.5 specifically, that trade runs backwards. Crossing 100k puts you on 5x rates for the entire request, so the large-context path costs more per call than the same workload did on Haiku 4.5's flat $1/$5 for prompts in the 100k–200k range once you add the ~30% tokenizer inflation. You also lose the cheap cache read, and you inherit the recall degradation that long contexts bring on any model.
Cheap classifiers get expensive in the exception queue
Here is the number that decides most demotion questions, and it has nothing to do with token price. In a real finance or support chain, the model is rarely the expensive component. The human who handles an exception is.
Take an invoice extraction pipeline at 10,000 documents a month. Classify the document type at roughly 1,200 input tokens and a few hundred output tokens including thinking; extract line items at roughly 3,000 input and 1,300 output. At Haiku 5.5's sub-threshold rates that is about $2.50 and $9.50 respectively, so roughly $12 of model spend for the month. The same extraction step on Sonnet 5.5 at $2/$10 would run about $190. Demoting saves you around $180 a month.
Now suppose the smaller model's exception rate on ambiguous documents rises from 4% to 7%. That is 300 additional items in a human review queue. At even a conservative $1.50 of fully loaded handling time per exception, the demotion has added $450 of cost to save $180. These figures are illustrative — substitute your own volumes and handling cost — but the shape holds across every chain we have priced: model spend is usually one to two orders of magnitude below exception-handling spend, so a three-point accuracy regression wipes out a 90% price cut.
The corollary is that per-token comparisons between Haiku 5.5 and, say, Google's Gemini 3.7 Flash — listed on Google Cloud's Agent Platform pricing page at introductory rates of $0.75/$3.75 per 1M tokens input/output through 31 December 2026 — are close to meaningless on their own. A 7.5x input price difference is $70 a month on the pipeline above. Which model produces fewer exceptions on your document distribution is worth hundreds. Run both against a labelled set and compare exception rates, not price sheets. We keep current rate and capability comparisons on our model coverage page for exactly this reason: the price is the easy half.
It's accurate enough that we'd trust it there, and fast and cheap enough that we can run it a lot.
— Alex Wang, Applied AI, Rogo, Anthropic launch page
Note the ordering in that sentence. Accuracy qualifies the step first; price determines how often you run it second. That is the right sequence.
The demotion test: which steps can drop to Haiku 5.5
Do not migrate a pipeline. Migrate one step, measure, then move to the next. The test below is what we run before changing a model inside a live n8n or custom orchestration layer, and it is deliberately boring.
Step-level demotion test
Pick the number the business already cares about — invoices posted without touch, tickets resolved without escalation, orders routed correctly. Not step accuracy. End-to-end completion rate, measured on at least 500 real items with known outcomes.
Count every prompt in the chain with model: claude-haiku-5-5. Flag any step whose prompt now lands between 80k and 120k tokens — those are the ones that will cross the cliff on a bad day.
Start with the highest-volume, narrowest-scope step: document type classification, intent routing, field extraction against a fixed schema, or summarisation for a downstream prompt. Leave everything else on the incumbent model.
Compare two or three effort levels on your eval set before you touch the prompt text. Anthropic's guidance is that existing Haiku 4.5 prompts should perform well unchanged, and that low raises the chance the model skips a search, stops early or skips a check.
A different model produces a different confidence distribution. The threshold that sent 4% of items to review will not send 4% after the swap. Recalibrate it against the labelled set, or your exception volume moves for reasons no one will be able to explain three weeks later.
Whatever step makes the irreversible decision — approves the payment, issues the refund, closes the ticket — stays on Sonnet 5.5 or Opus 5.5. The savings live in the fan-out, not in the final call.
Steps that reliably survive demotion: fixed-schema extraction, deduplication, language detection, intent classification with fewer than about twenty classes, compaction of long tool output before it reaches a larger model, and read-only database queries. Steps that usually do not: multi-document reconciliation, anything requiring a policy judgement, long agentic coding loops, and any step whose output is written to a system of record without a second check. We walk through this sequencing in more depth on our AI implementation work.
The migration checklist nobody reads until something 400s
Haiku 5.5 is not a drop-in model ID swap from Haiku 4.5. The official migration guide lists several changes that return hard errors, and these are the ones that surface as 400s in a production queue rather than as degraded output:
| Change | What breaks | What to do |
|---|---|---|
| Manual thinking budgets | thinking: {"type": "enabled", "budget_tokens": N} returns 400 | Switch to {"type": "adaptive"} and set output_config.effort |
| Sampling parameters | temperature, top_p, top_k can return an error | Remove them from every request body |
| Assistant prefill | Ending messages with an assistant turn returns an error | End with a user turn; move format hints into the prompt or a tool schema |
| Response parsing | Responses can begin with thinking blocks | Select content blocks by type, never by index |
| Refusals | stop_reason: "refusal" with no server-side fallback | Handle it explicitly in the client and route to a fallback path |
| Structured outputs on Bedrock | Not available for Haiku 5.5 on Amazon Bedrock | Describe the format in the prompt or use a non-strict tool, then validate in code |
| Priority Tier | Not supported on Haiku 5.5 | Plan capacity separately if you hold a Haiku 4.5 commitment |
Two more that catch orchestration layers specifically. First, changing system, tools or earlier messages mid-conversation while sending thinking blocks back can return a 400 — keep conversations append-only. Any workflow node that rewrites the system prompt between turns, which is a common pattern in visual builders, needs rework. Second, changing the top-level effort value between requests invalidates the prompt cache for that conversation's messages. A router that dials effort up for hard items and down for easy ones will silently destroy your cache hit rate and your cost model with it; there is a per-message effort change in beta that preserves the cache.
If you store and replay conversations — common in audit-heavy workflows — note that thinking blocks work only in the account that produced them, or in an account linked to it.
Where this does not pay off yet
The honest version: if your pipeline is already stable on Haiku 4.5 and your monthly model spend is under a few hundred dollars, the migration is engineering time you will not recover. Seven breaking changes, a token re-baseline, a confidence-gate recalibration and a fresh eval run is a week of careful work. The payback on $200 a month of model spend is not there.
It also does not pay off if the step you want to demote is the one making the decision. Terminal-Bench 4.0 at 39.2% versus Sonnet 5.5's 70.6% is the clearest signal Anthropic published, and their own framing is that Sonnet and Opus remain the better choices for complex agentic coding while Haiku 5.5 suits narrowly scoped work that was previously cost-prohibitive.
And the broader constraint is not model price at all. A Teradata-commissioned survey of 1,000 senior technology and data leaders found 69% of C-suite executives say their organisation is already operating with agentic AI against 57% of VPs, that 40% of respondents say more than 40% of AI pilots pause before production because infrastructure is not ready for autonomy, and that 78% report difficulty creating a connected data foundation. None of those failures are priced in tokens. A cheaper model does not fix a pipeline that cannot reliably reach the right record at the moment of the decision. If that is where you are, fix the data path first — the model bill will still be the smallest line item when you get there. Examples of how we sequence that work are on our case studies page, and if you want a second opinion on a specific chain before you swap anything, start here.
Frequently Asked Questions
How much does Claude Haiku 5.5 actually cost?
$0.10 per million input tokens and $0.50 per million output tokens for prompts up to 100,000 tokens, and $0.50/$2.50 above that threshold. Cache reads are $0.01/MTok under the threshold and $0.05 above it, with a 50% Batch API discount available. Because the prompt-length tier applies to the whole request, a single oversized call pays the higher rate on every token in it.
Why do my token counts go up after migrating to Haiku 5.5?
Haiku 5.5 uses the newer tokenizer shared with Claude 4.7 and later models, so identical text counts as roughly 30% more tokens than on Haiku 4.5. Large images also cost more because Haiku 5.5 uses the high-resolution image tier. Re-run token counting with the Haiku 5.5 model ID before reusing any cost estimate or max_tokens ceiling from your previous baseline.
Should I use the 1M context window instead of retrieval?
Rarely, on this model. Crossing 100,000 prompt tokens moves the entire request to 5x rates on both input and output, and cache reads count toward that threshold. A retrieval-backed 8,000-token prompt costs a fraction of a stuffed 1M-token prompt. If a step genuinely needs a very large context, route it to Sonnet 5.5 or Opus 5.5, which price the full window at standard rates.
Is Haiku 5.5 or Gemini 3.7 Flash cheaper for subagent work?
On list price, Haiku 5.5 is substantially cheaper under 100k tokens: $0.10/$0.50 against Gemini 3.7 Flash's introductory $0.75/$3.75 per million tokens, which Google lists as running through 31 December 2026. But on realistic subagent volumes that difference is often tens of dollars a month, while a one-point difference in exception rate is worth hundreds. Benchmark exception rates on your own labelled data before choosing.
What breaks if I just change the model ID?
Several things return errors rather than degrading quietly: manual thinking budgets, temperature/top_p/top_k, assistant-message prefill, and the older computer-use tool version. Responses can also start with a thinking block, so code that reads the first content block as the answer will break. Structured outputs are unavailable on Amazon Bedrock, and Priority Tier is not supported on Haiku 5.5.
Does adaptive thinking increase my bill?
Yes. Thinking is on by default at medium effort, thinking tokens bill at the output rate, and they count toward max_tokens — so a tight limit can truncate before any visible text. For high-volume classification where you previously ran with thinking off, lower the effort level or disable thinking explicitly. Prompt instructions telling the model to answer directly did not stop it thinking in Anthropic's testing.
Which pipeline steps should stay on a larger model?
Keep the adjudication step — the one that approves, refunds, posts or closes — on Sonnet 5.5 or Opus 5.5, along with multi-document reconciliation, policy judgements and long agentic coding loops. Demote the fan-out: fixed-schema extraction, intent classification, deduplication, compaction of tool output, and read-only queries. That split captures most of the cost reduction without moving the end-to-end completion rate.
Research digest
AI Research Briefing
Honest insights on AI agents, Small Language Models, and local RAG. No hype. Only when we have something worth sending.
- No hype, just measurable outcomes
- Read by 2,400+ engineers
- Unsubscribe anytime





