Claude Haiku 5.5: Pricing, the 100K Pricing Cliff, Benchmarks and API Guide (2026)

Anthropic shipped Claude Haiku 5.5 on October 7, 2026. It replaces Haiku 4.5 as the model to use for classification, extraction, routing and subagent work. Two headline numbers get attention: a 90% price cut for prompts up to 100K tokens, and a vendor-reported Terminal-Bench 4.0 score of 39.2%, up from 0.0% for Haiku 4.5.

The fine print matters more than either number. Haiku 5.5 is the only current Claude model priced by prompt length, so a request that crosses 100,000 input tokens costs about five times as much per token. It also brings the same breaking API changes as the rest of the 5.5 generation, so swapping only the model ID can produce 400 errors in production.

This guide covers the full price table and the 100K cliff, with worked examples. It also explains how Anthropic's "about 75% cheaper" claim fits with the 90% headline, then covers the specs, benchmarks (vendor-reported and independently measured, labelled separately), breaking changes, a head-to-head with GPT-6 Luna, and a migration checklist. For the bigger models, see our Claude Sonnet 5.5 guide and Claude Opus 5.5 guide.

Claude Haiku 5.5 at a glance

Anthropic describes it as built "for high-volume, latency-sensitive tasks such as classification, extraction, and routing". In the models overview it is the only current model with "Fastest" comparative latency.

Haiku 5.5 pricing and the 100K-token cliff

Here is the price table from Anthropic's pricing docs, as of October 2026. All prices are USD per million tokens (MTok).

Before writing this up we checked the table against the pricing page, the Haiku 5.5 model page and the announcement. All three agree. The pricing page also states the threshold rules plainly:

• The threshold covers all input. "A request's prompt length counts all of its input tokens, including cache reads and cache writes." A 95K cached prefix plus a 6K new message is a 101K prompt.
• The higher rate applies to the whole request. A request over 100K pays the higher prices on every token, output included, "even when part of its prompt is a cache hit."
• Each request is priced separately. Earlier requests in the same conversation keep the price they were billed at.
• The modifiers stack. Batch is 50% off both tiers. US-only inference (inference_geo: "us") applies a 1.1x multiplier, which the docs say "also applies to the higher prices for prompts over 100,000 tokens." Bedrock and Google-managed Google Cloud set their own regional pricing.

Every other current Claude model gives the full 1M context at a flat rate. Haiku 5.5 is the exception, so budgeting habits from Sonnet 5.5 or Opus 5.5 don't carry over.

Worked example 1: a 50K-token prompt

Take a document-extraction call with a 50,000-token prompt and a 2,000-token response, with no caching.

• Haiku 5.5 input: 50,000 × $0.10 / 1M = $0.0050
• Haiku 5.5 output: 2,000 × $0.50 / 1M = $0.0010
• Haiku 5.5 total: $0.0060 per request, or $6,000 per million requests
• Same token counts on Haiku 4.5: 50,000 × $1 / 1M + 2,000 × $5 / 1M = $0.05 + $0.01 = $0.060 per request, or $60,000 per million requests

That is the 90% cut. The 50K prompt stays under the threshold, so Haiku 5.5 bills it at the low tier.

Worked example 2: a 150K-token prompt

Now take a 150,000-token prompt (a long contract or a large chunk of a repo) and the same 2,000-token response.

• Haiku 5.5 input: 150,000 × $0.50 / 1M = $0.075
• Haiku 5.5 output: 2,000 × $2.50 / 1M = $0.005
• Haiku 5.5 total: $0.080 per request
• Haiku 4.5: 150,000 × $1 / 1M + 2,000 × $5 / 1M = $0.15 + $0.01 = $0.160 per request

Haiku 5.5 is still cheaper here, but only by 50%, not 90%.

The cliff itself: 99K vs 101K

• 99,000 input + 2,000 output: $0.0099 + $0.0010 = $0.0109
• 101,000 input + 2,000 output: 101,000 × $0.50 / 1M + 2,000 × $2.50 / 1M = $0.0505 + $0.0050 = $0.0555

Adding 2,000 input tokens makes the request about 5.1 times as expensive. Caching doesn't remove the cliff. Take a 150K request made of a 140K cached prefix, 10K of new input and 2K of output: 140,000 × $0.05 / 1M + 10,000 × $0.50 / 1M + 2,000 × $2.50 / 1M = $0.007 + $0.005 + $0.005 = $0.017. Trim the same workflow to a 90K cached prefix plus 9K new input, and it costs 90,000 × $0.01 / 1M + 9,000 × $0.10 / 1M + 2,000 × $0.50 / 1M = $0.0009 + $0.0009 + $0.0010 = $0.0028. For more on cache economics, see how prompt caching reduces AI cost.

Why "about 75% cheaper" and "90% cheaper" are both true

Anthropic's announcement says Haiku 5.5 "now costs around 75% less to run" than Haiku 4.5 on average. The footnote explains that this is a blend: 90% lower for requests up to 100K tokens and 50% lower above that. Anthropic adds that about 90% of Haiku 4.5 requests were in the first group. It also says the 75% figure accounts for the new tokenizer, which uses slightly more tokens per task.

A rough way to see how the numbers connect (our arithmetic, not Anthropic's method): if about 90% of requests save 90% and the rest save 50%, the saving by request count is 0.9 × 90% + 0.1 × 50% = 86%. Long requests cost more each, so they carry more weight in total spend than in request count. Add the new tokenizer, which the migration guide says produces about 30% more tokens for the same text, and the average lands near Anthropic's ~75%.

For budgeting: re-measure token counts on claude-haiku-5-5 instead of reusing Haiku 4.5 numbers, and track what share of your traffic goes over 100K.

What's new compared with Haiku 4.5

1M context and 128K output

Haiku 5.5 has the same 1M-token context window and 128K synchronous output limit as Sonnet 5.5, Opus 5.5 and Fable 5.1. The large window is real, but given the pricing above, prompts past 100K should be a deliberate choice.

The effort parameter, a first for Haiku

Anthropic calls Haiku 5.5 the first Haiku-class model with adjustable effort. The announcement charts show five levels: low, medium, high, xhigh and max. In the API you set it with output_config.effort, and the default is medium. Effort replaces manual thinking budgets. Adaptive thinking is on by default, and lower effort means less thinking, or none at all on simple requests.

Effort has a large effect on cost and latency. These are Artificial Analysis's independent measurements of the Haiku 5.5 variants, taken from its models leaderboard on October 26, 2026. Speed and time-to-first-chunk are live medians that shift from day to day, so treat them as approximate.

For classification and routing, start at low and only raise it if your evals show a quality gap. Artificial Analysis lists Haiku 5.5 (Max) last of 69 models for output tokens used to run its index (440M tokens). At high effort the model writes a lot, so the low per-token price doesn't translate directly into a low per-task price.

New tokenizer and higher-resolution images

Haiku 5.5 uses the tokenizer introduced with Claude Opus 4.7, which produces about 30% more tokens for the same text. Images also cost more. Haiku 5.5 uses the high-resolution image tier, and Anthropic's example says a 2,000 × 1,500 image costs about 2.5 times as many visual tokens as on Haiku 4.5. Thinking blocks from earlier turns also stay in context as input tokens, where Haiku 4.5 kept only the latest turn's. So multi-turn conversations grow faster than the tokenizer change alone would suggest.

Computer use and browser use

On the Claude API and Claude Models on Google Cloud (Google managed), computer use moves to the computer_toolset_20260801 toolset. On those same two platforms, Haiku 5.5 also supports the browser use tool (browser_toolset_20260801), which Haiku 4.5 does not. On Amazon Bedrock, use computer_20251124 with the computer-use-2025-11-24 beta header. For other platforms, check the Compatibility section of the computer use tool docs. Anthropic's announcement describes SDK support for computer use and browser use as beta.

Default Haiku in Claude Code

The Claude Code changelog for v2.1.293 says: "Added Claude Haiku 5.5 (claude-haiku-5-5), now the default Haiku model on the Anthropic API." If your team uses the haiku alias in Claude Code subagents or hooks on the Anthropic API, it now resolves to 5.5. You can pin a different model with ANTHROPIC_DEFAULT_HAIKU_MODEL.

Breaking changes from Haiku 4.5

Anthropic's release notes say directly: "Code written for Claude Haiku 4.5 can break on Claude Haiku 5.5." These are the changes that return errors or change behavior:

Two quieter changes. Haiku 5.5 thinking blocks only work in the account that produced them, or a linked account. A multi-tenant service that replays stored conversations through a different account will have those blocks dropped without an error. Haiku 5.5 also runs safety classifiers that can return stop_reason: "refusal", and the migration guide says there is no server-side fallback, so your code has to handle it.

A minimal Haiku 5.5 request in Python

This uses the request shape from Anthropic's migration guide: adaptive thinking, effort set through output_config, and the answer read by block type.

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY

response = client.messages.create(
    model="claude-haiku-5-5",
    max_tokens=4096,  # leave room: thinking tokens count toward max_tokens
    thinking={"type": "adaptive", "display": "summarized"},
    output_config={"effort": "low"},
    messages=[
        {"role": "user", "content": "Classify this support ticket as billing, bug or feature request: ..."}
    ],
)

# Don't assume content[0] is the answer; it may be a thinking block.
answer = "".join(block.text for block in response.content if block.type == "text")
print(answer)
print(response.stop_reason, response.usage.input_tokens, response.usage.output_tokens)

To keep requests under the cliff, count tokens before sending and route long prompts elsewhere or trim them:

count = client.messages.count_tokens(
    model="claude-haiku-5-5",
    messages=messages,
)

if count.input_tokens > 100_000:
    # Over the threshold every token is billed at $0.50 / $2.50 per MTok.
    # Trim, summarize, or send this request to a model with flat long-context pricing.
    ...

Pass the same system and tools to count_tokens that you'll send with the request, because they count toward the prompt too. If you are also upgrading SDKs, read our API version 2026-10-21 and SDK migration guide. The October 21 SDK and CLI releases send that API version by default and include their own breaking changes.

Haiku 5.5 benchmarks

Vendor-reported (Anthropic)

All figures below come from Anthropic's announcement. Some benchmarks were designed by Artificial Analysis (GDPval-AA, AA-Briefcase), but these particular numbers are Anthropic's.

Independently measured (Artificial Analysis)

• Artificial Analysis Intelligence Index: Claude Haiku 5.5 (Max) scores 43, ranked #4 of 173 models on its model page. GPT-6 Luna (Max) scores 38.
• Terminal-Bench 4.0, AA-measured: about 33% for Haiku 5.5 (Max) (32.8% in AA's published data) and about 12.6% for GPT-6 Luna (Max). Compare that with Terminal-Bench 4.0 (Anthropic-reported) 39.2%. Same benchmark version; neither source explains the gap, which likely reflects differences in harness, settings and runs. Run your own agent loop before relying on either number.
• Measured output speed: Artificial Analysis reports a median of 234 tokens/s for Haiku 5.5 (Max) on Anthropic's API, compared with 129 tokens/s for GPT-6 Luna (Max), as of October 26, 2026. These are live medians and change over time.

Anthropic's announcement calls Haiku 5.5 its "fastest model to date" at standard speed, and adds that the Opus models in Fast Mode are faster. Customer-reported figures come from specific workloads and are worth re-testing on yours. Asana reported over a 30% reduction in latency for task completions, compared with the model it uses today. Box said that in early testing Haiku 5.5 "scored 11 points higher than Haiku 4.5 at about half the latency."

Haiku 5.5 vs GPT-6 Luna

GPT-6 Luna (gpt-6-luna) is the obvious alternative. Its short-context list price is identical: $0.10 input, $0.01 cached input and $0.50 output per MTok, according to OpenAI's pricing page, as of October 2026. The difference is where the long-context surcharge starts and how large it is.

Cost at 10K, 120K and 300K prompts

Each example assumes a 1,000-token response and no caching. The two models use different tokenizers, so the same text won't produce exactly the same token count. Treat these as per-token list-price comparisons.

• 10K prompt: Haiku 5.5 = 10,000 × $0.10 / 1M + 1,000 × $0.50 / 1M = $0.0010 + $0.0005 = $0.0015. GPT-6 Luna = the same calculation, $0.0015. A tie.
• 120K prompt: Haiku 5.5 is past its cliff: 120,000 × $0.50 / 1M + 1,000 × $2.50 / 1M = $0.060 + $0.0025 = $0.0625. Luna is still in its short tier: 120,000 × $0.10 / 1M + 1,000 × $0.50 / 1M = $0.012 + $0.0005 = $0.0125. Haiku costs 5x as much.
• 300K prompt: Haiku 5.5 = 300,000 × $0.50 / 1M + 1,000 × $2.50 / 1M = $0.150 + $0.0025 = $0.1525. Luna (long tier) = 300,000 × $0.20 / 1M + 1,000 × $0.75 / 1M = $0.060 + $0.00075 = $0.06075. Haiku costs about 2.5x as much. This assumes Luna's long-context rate covers the whole request. OpenAI's pricing page defines short context as ≤272K input tokens and long context as >272K, but doesn't say how a request that crosses the line is billed.

Per-task cost depends on how many tokens a model generates as well as its price. On Artificial Analysis's index runs, Haiku 5.5 (Max) cost $0.21 per task and GPT-6 Luna (Max) cost $0.07. Haiku 5.5 at high effort scored 38, the same as Luna at max, for $0.08 per task. So a fair comparison sets Haiku's effort one or two levels below Luna's.

Verdict by workload

• Short-prompt classification, extraction and routing (under ~100K): both models cost the same per token. Haiku 5.5 scores higher on Anthropic-reported and AA-measured agentic benchmarks and produces output faster on AA's measurements. Haiku 5.5 at low or medium effort is the default to beat.
• Computer use and terminal-heavy agents: Haiku 5.5. It leads on OSWorld 2.1 offline (Anthropic-reported) and on Terminal-Bench 4.0 under both Anthropic's and AA's measurements.
• Long-document work between 100K and 272K tokens: GPT-6 Luna, by about 5x on list price. You could also restructure the pipeline with chunking or retrieval to keep Haiku prompts under 100K.
• Very long prompts (272K+): Luna is still about 2.5x cheaper per token. If quality matters more than cost, test Sonnet 5.5, which has flat pricing across its full 1M context.
• Latency-critical first-token use cases: AA's time-to-first-chunk numbers depend heavily on effort level, and Luna also offers a non-reasoning variant. Benchmark both models at the effort level you would actually deploy.

For a full profile of OpenAI's model, see our GPT-6 Luna guide. For a wider comparison of budget models, see the cheapest fast LLM APIs compared.

Haiku 5.5 migration checklist

1. Swap the model ID: claude-haiku-5-5, or anthropic.claude-haiku-5-5 on Bedrock.
2. Remove temperature, top_p and top_k.
3. Replace budget_tokens thinking with adaptive thinking plus output_config.effort. Start low for classification work.
4. Replace assistant prefill with structured outputs, enum tools or system-prompt instructions.
5. Read content blocks by type. Set thinking.display: "summarized" if you log reasoning.
6. Raise max_tokens where you had tuned it tightly, since thinking tokens count toward it.
7. Recount tokens on Haiku 5.5, which produces about 30% more for text and more for large images. Then recompute cost forecasts with both price tiers.
8. Add a token-count guard or routing rule for prompts near 100K, and count cache reads and writes toward the threshold.
9. Move computer use to computer_toolset_20260801 on the Claude API and Google Cloud (Google managed), or to computer_20251124 with the computer-use-2025-11-24 beta header on Bedrock.
10. Keep conversations append-only, replay them through the account that produced them, and handle stop_reason: "refusal".
11. If you have a Priority Tier commitment on Haiku 4.5, plan capacity separately.

If you are migrating several Claude models at once, our Claude Sonnet 4.5 retirement and migration guide covers the Sonnet side, and the 2026-10-21 API version guide covers SDK changes. Anthropic's migration guide also says Claude Code's bundled Claude API skill can apply these changes with /claude-api migrate this project to claude-haiku-5-5, then produce a checklist to verify manually.

FAQ

How much does Claude Haiku 5.5 cost?

As of October 2026, prompts up to 100,000 tokens cost $0.10 per million input tokens and $0.50 per million output tokens, and cache reads cost $0.01. Prompts over 100,000 tokens cost $0.50 input and $2.50 output, and cache reads cost $0.05. The Batch API halves both tiers.

Do cached tokens count toward the 100K threshold?

Yes. Anthropic's pricing docs say a request's prompt length counts all of its input tokens, including cache reads and cache writes. A request over the threshold pays the higher rate on every token, including the cached portion.

Is Haiku 5.5 really 90% cheaper than Haiku 4.5?

Per token, under 100K, yes: $0.10 vs $1.00 input. Across real traffic, Anthropic estimates about 75% savings on average. That figure blends the 90% (≤100K) and 50% (>100K) cuts and accounts for the new tokenizer using more tokens for the same text.

What is the Claude Haiku 5.5 API model ID?

claude-haiku-5-5 on the Claude API, Claude Platform on AWS, Google Cloud and Microsoft Foundry, and anthropic.claude-haiku-5-5 on Amazon Bedrock. It is a fixed ID with no date suffix.

Can I still use temperature with Haiku 5.5?

No. temperature, top_p and top_k return a 400 error on Haiku 5.5. Anthropic says to omit them and use prompting to guide the model's behavior. For format control, it recommends structured outputs, and effort controls how much the model thinks.

Is Haiku 5.5 better than GPT-6 Luna?

On published benchmarks, mostly yes. It scores 43 vs 38 on the Artificial Analysis Intelligence Index, and it leads on Terminal-Bench 4.0 and OSWorld 2.1 offline in Anthropic's numbers. On price, the two tie under 100K tokens, and Luna is cheaper for prompts between 100K and 272K tokens and beyond.

Sources

• Anthropic: Introducing Claude Haiku 5.5
• Claude Docs: Pricing (model, batch, long-context and data residency pricing)
• Claude Docs: Claude Haiku 5.5 overview
• Claude Docs: Claude Haiku 5.5 migration guide
• Claude Docs: Models overview
• Claude Docs: Release notes (October 7, 2026)
• Claude Code CHANGELOG (v2.1.293)
• Artificial Analysis: Models leaderboard
• Artificial Analysis: Claude Haiku 5.5
• Artificial Analysis: Terminal-Bench 4.0 evaluation
• OpenAI: API pricing (GPT-6 Luna)

If your team runs high-volume agent or classification pipelines and needs someone to tune model routing, effort levels and long-context costs, Codersera can help you hire vetted remote AI developers.