# Claude Haiku 5.5 migration: what changes from Haiku 4.5

URL: https://infro.io/blog/claude-haiku-5-5-migration
Author: INFRO Editorial (https://infro.io/blog/editorial)
Publisher: INFRO
Published: 2026-10-27
Last modified: 2026-10-27
Last reviewed: 2026-10-27 (next review due 2026-11-26)
Topic: Evaluation and models
Format: Guide

> Claude Haiku 5.5 (`claude-haiku-5-5`, released 7 October 2026) has a 1M-token context window and 128K output tokens, and is priced by prompt length: $0.10 input and $0.50 output per million tokens for prompts up to 100,000 tokens, $0.50 and $2.50 above. Moving from Haiku 4.5 means removing `temperature`, `top_p` and `top_k`, replacing assistant prefill with structured outputs or a user turn, switching `budget_tokens` to adaptive thinking with `effort`, reading content blocks by type, and recounting tokens, because the same text is about 30 percent more tokens. Haiku 4.5 is still active, with a retirement date of not sooner than 15 October 2026, so plan the move now.

Key takeaways:
- Claude Haiku 5.5 has a 1M-token window and 128K output tokens, up from 200K and 64K on Haiku 4.5, and `claude-haiku-5-5` is a fixed id with no dated snapshot.
- Prices change at 100,000 prompt tokens: $0.10 in and $0.50 out per million below the line, $0.50 and $2.50 above it, and the whole request pays the higher price.
- `temperature`, `top_p`, `top_k`, manual `budget_tokens` and a final assistant turn (prefill) all return 400 on Haiku 5.5.
- The same text is about 30 percent more tokens, thinking is on by default and counts toward `max_tokens`, so recount prompts and revisit every token limit.
- Haiku 4.5 is still active; its retirement date reads not sooner than 15 October 2026, and Anthropic promises at least 60 days' notice.
- Priority Tier does not support Haiku 5.5, so a Haiku 4.5 capacity commitment does not carry over.

Claude Haiku 5.5 is not a drop-in rename of Haiku 4.5. Anthropic released it on 7 October 2026 as `claude-haiku-5-5`, with a 1M-token context window, 128K output tokens and adaptive thinking on by default[1]. The same release makes five request shapes fail with a 400: `temperature`, `top_p`, `top_k`, manual extended thinking with `budget_tokens`, and an assistant message prefill[1]. Prices also change shape: Haiku 5.5 charges one rate for prompts up to 100,000 tokens and a higher one above[2].

This guide covers what changes from Haiku 4.5, what the two price bands do to a bill, how to replace prefill, when Sonnet 5.5 is the better choice, and an evaluation plan for the move.

## What changes from Haiku 4.5

|  | Claude Haiku 4.5 | Claude Haiku 5.5 |
| --- | --- | --- |
| Claude API id | `claude-haiku-4-5-20251001` or `claude-haiku-4-5` | `claude-haiku-5-5` (fixed, no alias) |
| Context window | 200K tokens | 1M tokens |
| Max output | 64K tokens | 128K tokens |
| Thinking | Extended thinking with `budget_tokens` | Adaptive, on by default, steered by `effort` (default `medium`) |
| Sampling parameters | Accepted | 400 error |
| Assistant prefill | Accepted with thinking off | 400 error, even with thinking off |
| Tokenizer | Earlier | Same text is about 30 percent more tokens |
| Minimum cacheable prompt | 4,096 tokens | 512 tokens |
| Input / output per million | $1 / $5 | $0.10 / $0.50 up to 100K prompt tokens; $0.50 / $2.50 above |
| Priority Tier | Supported | Not supported |

Table: Haiku 4.5 against Haiku 5.5, from Anthropic's migration guide, models overview, pricing and service tier pages, read 2026-10-27.

The figures come from Anthropic's own pages[3][4][5][2]. Three rows deserve more than a glance.

**Thinking is on unless you turn it down.** A response can now start with `thinking` blocks even when the request never mentions thinking, and by default those blocks carry an empty `thinking` field and only a `signature`[4]. Code that reads `content[0].text` as the answer breaks. Thinking tokens count toward `max_tokens`, so a small limit tuned for Haiku 4.5 can stop with `stop_reason: "max_tokens"` after a thinking block and before any text[4]. Thinking blocks from earlier assistant turns also stay in context and count as input tokens, where Haiku 4.5 kept only the latest turn's[3].

**Token counts move.** Haiku 5.5 uses the tokenizer introduced with Claude 4.7, and Anthropic says the same input text produces approximately 30 percent more tokens than on Haiku 4.5, depending on the content[4]. Large images cost more too: Haiku 5.5 uses the high-resolution image tier, and Anthropic's example is a 2,000 by 1,500 pixel image costing about 2.5 times as many visual tokens[4]. Every `max_tokens` value, context-trimming rule and cost estimate measured on Haiku 4.5 needs recounting with `model` set to `claude-haiku-5-5`.

**Refusals are a stop reason you must handle.** Haiku 5.5 runs safety classifiers that can decline a request with `stop_reason: "refusal"`, and Anthropic notes that server-side fallback is not available for it[3].

## The two-band price, worked through

Haiku 5.5 is the one current Claude model with long-context pricing. Anthropic's pricing page says a request whose prompt is over 100,000 tokens pays the higher prices, that the prompt length counts all input tokens including cache reads and cache writes, and that each request is priced on its own: a request over the threshold pays the higher prices even when part of the prompt is a cache hit[2].

| Prompt length | Input | 5-minute cache write | Cache read | Output | Batch input / output |
| --- | --- | --- | --- | --- | --- |
| Up to 100,000 tokens | $0.10 | $0.125 | $0.01 | $0.50 | $0.05 / $0.25 |
| Over 100,000 tokens | $0.50 | $0.625 | $0.05 | $2.50 | $0.25 / $1.25 |

Table: Claude Haiku 5.5 list prices per million tokens, from Anthropic's pricing page, read 2026-10-27.

US-only inference (`inference_geo: "us"`) applies a 1.1x multiplier to all of these, including the higher band[2].

> **Example: Illustrative: a classifier, and a request that crosses the line**
> At list rates. A ticket classifier sends a 2,000-token prompt and gets 50 visible output tokens on Haiku 4.5: $0.002 input plus $0.00025 output, $0.00225 per request, or $2,250 per million requests.
> 
> On Haiku 5.5 the same prompt counts about 2,600 tokens. If low effort adds 300 thinking tokens, output is 350 tokens: $0.00026 input plus $0.000175 output, $0.000435 per request, or $435 per million requests.
> 
> Now a document-review request. On Haiku 4.5 it counted 92,000 tokens. On Haiku 5.5 the same text is roughly 120,000 tokens, over the line, so with 1,000 output tokens it costs $0.06 plus $0.0025, $0.0625. Trimmed to 99,000 tokens it would cost $0.0099 plus $0.0005, $0.0104: about six times less for 18 percent fewer tokens.

The token counts are hypothetical; the shape is not. Two things follow. First, the tokenizer change alone can push prompts that sat under 100,000 tokens on Haiku 4.5 over the line on Haiku 5.5. Second, long-context workloads such as whole-document review or agent loops that accumulate history should be measured for the share of requests above 100,000 tokens, because those requests set the bill. Context editing and thinking-block clearing, which Anthropic links from the migration guide, are the levers for keeping a conversation under the line[4].

## Replacing prefill

A prefill is a final assistant turn that the model continues. Teams used it to force JSON by starting the answer with `{`, to skip a preamble, or to resume a cut-off answer. Haiku 5.5 rejects it with a 400 even when thinking is off[4]. Anthropic's guide names a replacement for each use[4]:

| What the prefill did | Replacement on Haiku 5.5 |
| --- | --- |
| Forced an output format | Structured outputs, or a tool with enum fields for classification |
| Removed a preamble | Ask for a direct answer in the system prompt |
| Continued an interrupted answer | Quote the earlier text in a user message and ask the model to continue |
| Added a context reminder | Put it in the user turn |

Table: Prefill replacements from Anthropic's Haiku 5.5 migration guide, read 2026-10-27.

For format control, structured outputs are generally available on the Claude API and the major cloud platforms, use `output_config.format` with `type: "json_schema"`, and list `claude-haiku-5-5` as supported[6]:

```json
{
  "model": "claude-haiku-5-5",
  "max_tokens": 1024,
  "output_config": {
    "effort": "low",
    "format": {
      "type": "json_schema",
      "schema": {
        "type": "object",
        "properties": {
          "category": { "type": "string", "enum": ["billing", "bug", "account", "other"] },
          "urgent": { "type": "boolean" }
        },
        "required": ["category", "urgent"],
        "additionalProperties": false
      }
    }
  },
  "messages": [{ "role": "user", "content": "Classify this ticket: ..." }]
}
```

Know the limits before you rely on it. The structured outputs guide lists unsupported schema features, including numeric and string-length constraints and recursive schemas, which return a 400; the first use of a schema adds latency while its grammar compiles, and compiled grammars are cached for 24 hours from last use[6]. Changing `output_config.format` also invalidates the prompt cache for that conversation[6]. Validate the parsed result in your own code anyway: a valid shape is not a correct answer.

## Migration steps

Anthropic's checklist for a Haiku 4.5 caller is ten items[4]. In the order that avoids surprises:

1. Change the model id per platform: `claude-haiku-5-5` on the Claude API, Claude Platform on AWS, Google-managed Vertex and Microsoft Foundry; `anthropic.claude-haiku-5-5` on Amazon Bedrock.
2. Remove `temperature`, `top_p` and `top_k`. API version 2026-10-21 removes them for every model anyway[7].
3. Replace `thinking: {"type": "enabled", "budget_tokens": N}` with adaptive thinking and set `output_config.effort`. Where Haiku 4.5 ran without thinking to save tokens, choose a lower effort.
4. Select response content blocks by `type`, never by position, and pass thinking blocks back unmodified with tool results.
5. End every `messages` array with a user turn, replacing prefill as in the table above.
6. Recount prompts on Haiku 5.5, then raise `max_tokens` where thinking now shares the budget.
7. Handle `stop_reason: "refusal"`.
8. If you use computer use, move from `computer_20250124` to the `computer_toolset_20260801` toolset (Bedrock: `computer_20251124`).
9. Keep conversations append-only if you send thinking blocks back: changing `system`, `tools` or earlier turns now invalidates them with a 400.
10. Replay stored conversations through the account that produced them; Haiku 5.5 thinking blocks work only in that account or one linked to it.

If your organization has a Priority Tier commitment on Haiku 4.5, plan capacity separately: Priority Tier is not supported on Haiku 5.5[4].

## Haiku 5.5 or Sonnet 5.5

Anthropic describes Haiku 5.5 as built for high-volume, latency-sensitive work such as classification, routing, extraction and subagent tasks, with the fastest comparative latency in the current lineup; Sonnet 5.5 is "the best combination of speed and intelligence" at $2 input and $10 output per million tokens, and its default effort is `high` where Haiku's is `medium`[5]. All four current models share a 1M-token window and 128K output[5].

Haiku 5.5 loses when the task needs judgement it cannot supply: a long multi-step agent turn, ambiguous instructions, code that has to compile. A cheap call that fails and is retried, escalated or corrected by a person is not cheap. Sonnet 5.5 loses on high-volume, well-specified work where Haiku already succeeds: its list rates are 20 times Haiku's lower band and four times Haiku's higher band, so even long prompts above 100,000 tokens usually cost less on Haiku if Haiku gets the task right. The defensible way to decide is cost per successful task on your own traffic, not either model's list price.

For leaders, the question to put to the team is short: which workloads have been qualified on Haiku 5.5, what share of their requests cross 100,000 prompt tokens, and what the failure rate is against the current model.

## An evaluation plan

1. **Sample real traffic.** Take a few hundred recorded requests per workload, including the longest ones, with the exact parameters your code sends after the changes above.
2. **Run both models.** Haiku 4.5 as the baseline, Haiku 5.5 at two effort levels, and Sonnet 5.5 where the task is borderline.
3. **Score outcomes, not style.** Task success against a rubric or labelled answers, refusals, truncation (`stop_reason: "max_tokens"`), schema failures, and latency to the first useful token.
4. **Compute cost per successful task** with the measured input, output and thinking tokens, priced at the right band per request.
5. **Shift in stages.** A small share first, watch error rates and the response's reported model, then widen. Keep Haiku 4.5 as the fallback only while it is still active.

## Moving Haiku traffic with INFRO

INFRO is a control plane that sits between your applications and the provider accounts you already hold. You connect your own Anthropic account, Anthropic bills you directly, and INFRO records each request that passes through it. Both `anthropic/claude-haiku-5.5` and `anthropic/claude-haiku-4.5` are in its model catalog.

**See what you are moving.** [Usage analytics](https://infro.io/docs/observability/analytics) group requests, tokens, latency and estimated provider cost by model, project and key, so you can list every caller of Haiku 4.5 that goes through INFRO and see its token profile before and after.

**Sampling parameters on the OpenAI-compatible endpoint.** On `/v1/chat/completions`, INFRO does not send `temperature`, `top_p` or `top_k` to Claude 4.7 and later models, Haiku 5.5 included, and lists what it dropped in the `X-INFRO-Params-Dropped` response header ([chat completions reference](https://infro.io/docs/api/chat-completions)). It does not rewrite prefill: a request ending in an assistant turn still reaches Anthropic and is refused.

**Shift without a deploy.** A [route](https://infro.io/docs/routes) lets an application name a route instead of a model id, so moving traffic from Haiku 4.5 to Haiku 5.5, or splitting it while you compare, is a configuration change. A [model allowlist](https://infro.io/docs/org/model-allowlists) can block Haiku 4.5 once the move is done, so a missed caller fails loudly.

One limit to state plainly: INFRO's cost estimate for Haiku 5.5 uses the up-to-100,000-token rates, so a request over the line is estimated low until the catalog carries the second band. Your Anthropic invoice is the figure that counts; compare the two, and treat long-context Haiku 5.5 traffic in INFRO's estimates as a floor.

## Questions

### When is Claude Haiku 4.5 retired?

Anthropic's deprecations page lists `claude-haiku-4-5-20251001` as Active with a tentative retirement date of not sooner than 15 October 2026. That is the earliest date, not a scheduled one. Anthropic says it gives at least 60 days' notice before retiring a publicly released model, so a retirement announced today could not take effect before late December 2026. Bedrock and Google-managed Vertex set their own dates.

### How much does Claude Haiku 5.5 cost?

For prompts up to 100,000 tokens: $0.10 per million input tokens, $0.50 per million output tokens and $0.01 per million cache reads. For prompts over 100,000 tokens: $0.50 input, $2.50 output and $0.05 cache reads. The prompt length includes cache reads and writes, and a request over the line pays the higher prices on all its tokens. Batch processing is half those rates.

### Why does Claude Haiku 5.5 return a 400 for temperature?

Haiku 5.5 rejects `temperature`, `top_p` and `top_k`. Anthropic's guidance is to omit them and guide behaviour with the prompt. API version 2026-10-21 removes these parameters for every model, so code that still sends them should drop them now.

### What replaces assistant prefill on Claude Haiku 5.5?

End `messages` with a user turn. Use structured outputs (`output_config.format` with a JSON schema) or a tool with enum fields where the prefill forced a format, a system-prompt instruction where it removed a preamble, and a user message that quotes the earlier text where it continued an interrupted answer.

### Should I use Haiku 5.5 or Sonnet 5.5?

Anthropic positions Haiku 5.5 for high-volume, latency-sensitive work such as classification, extraction, routing and subagent tasks, and Sonnet 5.5 as the balance of speed and intelligence at $2 input and $10 output per million tokens. Run both on a sample of your own traffic and compare cost per successful task; choose Sonnet where Haiku's failure rate costs more than the price gap.

## Sources

1. Claude Platform API release notes — Anthropic. https://platform.claude.com/docs/en/release-notes/api (accessed 2026-10-27)
2. Pricing — Anthropic. https://platform.claude.com/docs/en/about-claude/pricing (accessed 2026-10-27)
3. What's new in Claude Haiku 5.5 — Anthropic. https://platform.claude.com/docs/en/models/haiku-5-5/whats-new-haiku-5-5 (accessed 2026-10-27)
4. Claude Haiku 5.5 migration guide — Anthropic. https://platform.claude.com/docs/en/models/haiku-5-5/migration-guide (accessed 2026-10-27)
5. Models overview — Anthropic. https://platform.claude.com/docs/en/models/overview (accessed 2026-10-27)
6. Structured outputs — Anthropic. https://platform.claude.com/docs/en/build-with-claude/structured-outputs (accessed 2026-10-27)
7. Model deprecations — Anthropic. https://platform.claude.com/docs/en/about-claude/model-deprecations (accessed 2026-10-27)