What Is Haiku 5.5? Claude's Cheapest Model, and the 100K Line That Changes Its Price

Haiku 5.5 in One Sentence

Haiku 5.5 is a small model built for work that is high in volume, sensitive to latency, and narrow in scope: classification, routing, extraction, summarisation, context compaction, and acting as a subagent underneath a larger model. Anthropic describes it as "the cheapest, fastest, and most capable small model we've ever released."

The boundary matters more than the description. Haiku 5.5 is not a cheap Sonnet. Anthropic's own launch page states that Sonnet 5.5 and Opus 5.5 remain the better choices for complex agentic coding, and positions Haiku 5.5 for "more narrowly scoped tasks that might otherwise have been cost-prohibitive." The benchmark section below shows exactly how wide that gap is, and it is wide.

Why Anthropic Rebuilt the Small Tier

Start with the number that explains the whole release. On Terminal-Bench 4.0, Claude Haiku 4.5 scored 0.0%.

Not a low score. Zero. The previous small model could not complete this category of multi-step command-line task at all. That left a hole in the middle of how people actually build agents. A large share of calls in an agent loop are errands — search this, summarise that, classify the other thing. Running those on Sonnet is paying frontier prices for clerical work. But Haiku 4.5 was weak enough that handing it anything with steps in it meant handing it a failure.

Haiku 5.5 closes that hole from two directions. The model itself is stronger, and for the first time in the Haiku line it has adaptive thinking with an effort parameter — the same control surface as the larger Claude models. Instead of one fixed capability level, the same model slides along a cost-versus-intelligence curve, with medium as the default.

One sentence version: Anthropic did not make the small tier a bit better, it made the small tier adjustable, and that changes which jobs you can safely delegate to it.

What Haiku 5.5 Actually Changes

The context window is the headline spec change: a small model with a million-token window, up from 200K. Max output is 128K, and on the Message Batches API there is a beta header (output-300k-2026-03-24) that raises it to 300K.

On tools, Haiku 5.5 supports computer use through the computer_toolset_20260801 toolset and adds browser use via browser_toolset_20260801 on the Claude API and Google Cloud — the latter was not available on Haiku 4.5 at all.

Two costs attach to the upgrade. Haiku 5.5 does not support Priority Tier, so if you hold capacity commitments on Haiku 4.5 you need to plan those separately. And the sampling parameters you are used to are effectively locked — temperature, top_p, and top_k now reject almost every value you might want to set. That has enough consequences to deserve its own section further down.

Haiku 5.5 Pricing, and the 100K Threshold

Here is the full official rate card, per million tokens:

First, when a prompt crosses 100,000 tokens, the higher rate applies to the whole request — input, output, and cache alike — not just to the tokens above the line. A 95K prompt with 2K of output costs about $0.0105. Push the same job to 105K and it costs about $0.0575. The work grew by roughly 10%; the bill grew by about 450%. As far as I can tell from the current documentation, Haiku 5.5 is the only Claude model with tiered long-context pricing of this kind.

Second — and this is the part almost nobody writes down — the threshold is measured in Haiku 5.5's own tokens, and Haiku 5.5 uses a different tokenizer. It shares the tokenizer used by Claude 4.7 and later, which Anthropic's migration guide says produces "approximately 30% more tokens" for the same text. Run the arithmetic: a prompt that measured 80,000 tokens on Haiku 4.5 lands around 104,000 tokens on Haiku 5.5. It was comfortably inside the cheap tier. It is now in the expensive one, and nothing about your prompt changed.

Third, Batch API requests get 50% off input and output, and there is no Priority Tier.

Now the two numbers that conflicted in the coverage. The 90% figure is the per-token cut for prompts up to 100K: $0.10 against $1.00 input, $0.50 against $5.00 output. Above 100K the same comparison is a 50% cut. The 75% figure comes from Anthropic's own footnote and means something different — it is the blended cost to run the model, weighted by real traffic (around 90% of Haiku 4.5 requests fell under 100K) and already adjusted for the extra tokens the new tokenizer consumes. One is a sticker price, the other is an estimate of your actual bill. Both are Anthropic's.

My judgment, flagged as judgment: for the work this model is designed for — classification, routing, extraction, short summaries — you will never touch 100K, and the cheap tier is simply the price. The threshold bites a specific design pattern: agents that stuff an entire repository, document set, or long conversation history into a single prompt. If that is your architecture, the million-token window is a trap dressed as a feature, and you should price your largest realistic prompt before migrating anything.

Through GPT Proto, Claude Haiku 5.5 is listed at $0.09 input and $0.45 output per million tokens, with cache reads at $0.009 — 10% below Anthropic's up-to-100K rates, on the same key and shared balance as the rest of the catalogue. One caveat I want to be straight about: that page does not publish a tiered rate for prompts over 100K. I am not going to claim the platform's over-100K behaviour either way. If your prompts run long, confirm that rate before you size a budget around it.

If you are migrating an existing workload, four checks are enough to know whether the threshold will hit you. Take your largest realistic prompt — not your average one — and recount it with model: "claude-haiku-5-5" rather than reusing your Haiku 4.5 numbers. If the old count was above roughly 77,000 tokens, assume the new count clears 100K and price it at the higher tier. Then add your thinking tokens to the output side of the estimate, because they are billed as output and the effort setting controls how many of them there are. Finally, look at whether the prompt grows with conversation history or retrieved context; if it does, the real question is not today's token count but which turn of the conversation crosses the line.

How It Benchmarks

I want to start with the independent number, because the vendor numbers come with a caveat you need to hold in mind while reading them.

Artificial Analysis, which runs its own test scaffolding rather than reprinting vendor claims, places Haiku 5.5 at 43 on its Intelligence Index. A year ago the Haiku line scored 17. That is a 26-point move inside one generation, and it puts the model ahead of GLM-5.3 Flash at 42, Gemini 3.8 Flash at 41, and GPT-6 Luna at 38, roughly level with Kimi K3 at 44. It also puts it 13 points behind Claude Sonnet 5.5 running at max effort, which lands at 56. A small model closed most of the gap to last year's frontier. It did not close the gap to this year's.

The disagreement worth noticing is on Terminal-Bench 4.0. Anthropic reports 39.2%. Artificial Analysis, running the same benchmark through its own scaffolding, got 33%. Neither party is lying. Agentic benchmarks are scaffold-sensitive — the scaffold decides how many turns the model gets, how tool errors are surfaced, how retries are handled — and a six-point spread between two careful implementations is normal. It is also the clearest argument against reading any single agentic score as a specification.

Here is Anthropic's own table. Every figure in it is vendor-reported, measured at max effort, and has not been independently reproduced:

Anthropic has not published SWE-bench Verified, GPQA Diamond, AIME, or tau-bench results for this model. If you see those numbers attributed to Anthropic, they did not come from Anthropic.

Now the part that matters more than any of those rows, and that I have seen almost nobody write about. Artificial Analysis also measured how many tokens the model burns to reach those scores, and at max effort Haiku 5.5 spends roughly 162,000 output tokens per task. GPT-6 Luna at max spends about 50,000. That is three times the output volume — and it is more than Opus 5.5 at max consumes. A price per token that is ten times lower does not survive a token count that is three times higher. It only survives if your tasks are short.

The same data undercuts the instinct to turn effort up. Going from xhigh to max buys two index points and costs roughly 1.8× the tokens. At high effort the model scores 38 — the same as Luna at max — using around 55,000 tokens against Luna's 50,000. My judgment, and it is a judgment rather than a benchmark: start production traffic at low or medium, measure, and raise effort only for the specific task types that demonstrably fail at the lower setting. Treating max as a default is how a cheap model produces an expensive invoice.

One more result cuts against the usual story about small models. On AA-Omniscience, Haiku 5.5 answers correctly 36% of the time, behind Gemini 3.8 Flash at 55% and Luna at 44%. Its hallucination rate, though, is 40%, against 55% for Gemini 3.8 Flash and 77% for Luna. It knows less and admits it more often. For a routing or extraction layer feeding downstream systems, a model that says "I don't know" is frequently worth more than one that guesses with confidence.

Finally, a caveat on one low score you may see quoted. Haiku 5.5 scores 35% on AutomationBench-AA while competitors sit between 53% and 60%. Artificial Analysis attributes this to over-refusal in the pre-release build it tested, notes that Anthropic is addressing it, and says it will re-run the benchmark. Treat that 35% as provisional and expect it to move up.

Haiku 5.5 vs Sonnet 5.5 vs Opus 5.5

All three models in the Claude 5.5 generation now carry a one-million-token context window and adaptive thinking, so context length is no longer how you choose between them. Price and agentic depth are.

The hardest line here is the coding gap: 39.2% against 70.6% on Terminal-Bench. That is not a matter of degree. Multi-step shell work, large refactors, debugging across a codebase — those belong to Claude Sonnet 5.5, and Anthropic says so on its own launch page rather than leaving you to discover it. Haiku 5.5 handles narrow, well-scoped edits. It does not handle open-ended engineering.

So the split is roughly this. High-frequency, narrow tasks with a clear definition of done — classification, routing, extraction, summarisation, context compaction, subagent calls — go to Haiku 5.5, and the twenty-fold price difference makes that an easy decision. Complex agentic coding and multi-step tool use go to Sonnet 5.5. Long-horizon autonomous agents and the hardest reasoning go to Claude Opus 5.5. Because all three sit behind one key and one balance on GPT Proto, routing between them is a string change in your request rather than a second vendor contract.

One connected change shipped in the same announcement and is easy to miss: Anthropic cut Sonnet 5.5's cache read price in half, from $0.20 to $0.10 per million tokens, which it says makes Sonnet roughly 20% cheaper on most agentic workloads. That is a change on Anthropic's side. Wherever you buy access, read the provider's currently published cache rate rather than assuming the cut has already propagated.

How Haiku 5.5 Compares to GPT-6 Luna and GPT-6.1 Sol

People search for "Haiku 5.5 vs GPT-6.1 Sol," and I would rather correct the question than answer it badly. These are not peers. Sol sits in OpenAI's agentic and coding tier; Haiku 5.5 sits in the small, high-volume tier. Comparing them tells you which tier you need, not which model is better.

The actual peer is GPT-6 Luna, and the comparison is genuinely close. Both list at $0.10 input and $0.50 output per million tokens at Anthropic's and OpenAI's own rates — identical sticker prices. Both apply a long-context surcharge, but the shape differs sharply: Luna's threshold sits at 272K with a 2× input and 1.5× output multiplier, while Haiku 5.5's sits at 100K with a 5× multiplier on the entire request. On intelligence, Haiku 5.5 leads 43 to 38.

And then the token counts invert the conclusion. Haiku 5.5 at max effort spends about three times the output tokens Luna does for the same task. Equal price per token, triple the tokens — the cheaper invoice belongs to Luna on long reasoning tasks, and to Haiku 5.5 on short ones where the effort setting stays low and the model answers without a long internal monologue.

That gives you something better than a verdict: a method. Take your actual prompt and your actual expected output length. Count the prompt in Haiku 5.5's tokenizer, not your old one, and check which side of 100K it lands on. Multiply your realistic output length — including thinking tokens, which are billed as output — by the applicable rate. Do the same for whichever alternative you are weighing. Whichever number is smaller wins for your workload, and no benchmark table can answer that for you.

Calling Haiku 5.5 from the API

The examples below are written against the documentation rather than from a test run, so smoke-test them against your own key before shipping. Haiku 5.5 is listed at claude-haiku-5-5 and reachable through GPT Proto's Claude Messages surface at https://gptproto.com/v1/messages, which takes a bearer token:

curl https://gptproto.com/v1/messages \
  -H "Authorization: Bearer $GPTPROTO_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-haiku-5-5",
    "max_tokens": 2048,
    "thinking": { "type": "adaptive" },
    "output_config": { "effort": "low" },
    "messages": [
      { "role": "user", "content": "Classify this ticket as billing, bug, or feature request. Reply with one word.\n\nTicket: Charged twice for the October invoice." }
    ]
  }'

Three things in that request are specific to this generation. thinking takes adaptive rather than enabled with a token budget. output_config.effort carries the cost dial. And there is no temperature, top_p, or top_k — their absence is deliberate, and the next section explains why sending them breaks the call.

The Python example uses Anthropic's own SDK (pip install anthropic). Note the base_url here has no /v1 on the end — the Anthropic SDK appends /v1/messages itself, so passing the bare host is correct and resolves to the same endpoint as the cURL call above. If you are used to the OpenAI SDK, which does want /v1 in base_url, that difference will catch you once.

The detail that bites people is response parsing. A response can open with a thinking block, so indexing content[0] will hand you reasoning instead of an answer. Filter by type:

import os, anthropic

client = anthropic.Anthropic(
    api_key=os.environ["GPTPROTO_API_KEY"],
    base_url="https://gptproto.com",
)

resp = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=2048,
    thinking={"type": "adaptive"},
    output_config={"effort": "low"},
    messages=[{
        "role": "user",
        "content": "Extract the invoice number and total as JSON.\n\n"
                   "Invoice INV-20418, amount due $412.70, net 30.",
    }],
)

if resp.stop_reason == "refusal":
    raise RuntimeError("Model declined; there is no server-side fallback.")
if resp.stop_reason == "max_tokens":
    raise RuntimeError("Budget exhausted — thinking tokens count against max_tokens.")

text = "".join(b.text for b in resp.content if b.type == "text")
print(text)

Both failure branches are real conditions rather than defensive padding. refusal has no server-side retry behind it, so your code is the only thing standing between a declined request and a silent empty string downstream. And because thinking tokens are billed and counted inside max_tokens, a budget that was generous on Haiku 4.5 can now terminate the response after the reasoning and before any text block — you get an HTTP 200 with nothing usable in it. If you are migrating a service that set max_tokens tightly, raise it before you change the model ID.

Migrating from Haiku 4.5

Swapping the model string is not enough. Anthropic's migration guide lists a set of changes that return a hard 400 rather than degrading quietly, and the sampling parameters are where most teams will hit the wall first. temperature must be 1 or omitted. top_p accepts exactly one value, 0.99 — sending top_p: 1 fails. Any top_k fails. Sending temperature and top_p together fails even if both values are individually legal. The official recommendation is to delete all three and move that control into your prompt.

After that, in rough order of how likely you are to trip on it: the old thinking: {"type": "enabled", "budget_tokens": N} form is rejected, replaced by adaptive plus output_config.effort. Assistant prefill is now prohibited, even with thinking disabled — which kills the familiar trick of prefilling { to force JSON output, so move that to structured outputs, and note that Bedrock does not support structured outputs and needs a tool with a JSON schema instead. Thinking blocks are bound to the account that created them, and replaying them across accounts is silently dropped: the request still returns 200, the reasoning just is not there. Conversations must be append-only, so editing system, tools, or any earlier message and then passing thinking blocks back returns 400. Computer use requires computer_toolset_20260801, the old computer_20250124 declaration fails, and the computer-use-2025-01-24 and fine-grained-tool-streaming-2025-05-14 headers have to come off; a new browser_toolset_20260801 is available alongside it. The thinking field returns an empty string with a signature by default — set "display": "summarized" if you want readable reasoning. And the tokenizer changed, so recount every prompt budget with model: "claude-haiku-5-5" instead of reusing numbers from 4.5.

There is one trap outside the API itself. From Claude Code 2.1.293, claude-haiku-5-5 is the default Haiku on the Anthropic API, and the Explore subagent switches to it with no configuration change on your part. But the bare haiku alias still resolves to 4.5 on Amazon Bedrock, Google Cloud, Microsoft Foundry, and Claude Platform on AWS. If you deploy across more than one of those, you can end up running two different models from what looks like one config. Pin it explicitly with ANTHROPIC_DEFAULT_HAIKU_MODEL rather than trusting the alias.

Who Should Use It, and Who Shouldn't

Use it for high-frequency classification, routing, and extraction; for short summaries and context compaction; as a subagent under Opus or Sonnet where the parent model delegates narrow lookups; and for latency-sensitive paths like support triage and browser operation, where the speed matters as much as the cost. Anthropic's launch page quotes Aaron Vinh, a staff software engineer at Asana, reporting over 30% lower task completion latency and up to 2.5× faster reasoning per agent turn on their AI Teammates eval suite. That is a vendor-published customer quote rather than an independent measurement, and it describes one company's internal benchmark — useful as a signal about latency, not as a number to plan against.

Avoid it for complex multi-step shell work, where the Terminal-Bench gap is decisive. Avoid it for tasks that lean on broad factual recall, given the 36% accuracy on AA-Omniscience; pair it with retrieval instead of asking it to know things. Avoid it if your pipeline depends on temperature for deterministic output, because that control no longer exists and you will need to rebuild that determinism in prompting or in post-processing. And avoid it if you need Priority Tier capacity commitments, which this model does not support.

Final Take

Haiku 5.5 changes what the small tier is for. Haiku 4.5 scored 0.0% on Terminal-Bench — not weak, but unable to participate — and the practical consequence was that teams ran Sonnet for work that did not deserve it. A 43 on the Intelligence Index at a tenth of the old input price makes delegation real. It is still a small model, and the coding and factual-recall numbers mark the boundary clearly.

The skill in using it well is not picking it. It is staying under the 100K line and keeping effort low. Those two habits are what separate a bill that reflects the sticker price from one that does not.

If you want to try it, Claude Haiku 5.5 is live on GPT Proto at $0.09 input and $0.45 output per million tokens, and Sonnet 5.5 and Opus 5.5 sit behind the same key and the same balance for the jobs Haiku should hand upward.

All prices, model identifiers, and benchmark figures verified October 9, 2026. Vendor benchmarks are labelled as such; independent figures are from Artificial Analysis.