# Claude Sonnet 5.5 vs Sonnet 5: Cost by Effort and What Breaks

> Sonnet 5.5 keeps Sonnet 5's $2/$10 token prices. On Artificial Analysis tests it costs less per task from low to xhigh effort and about 51% more at max.

- URL: https://blog.laozhang.ai/en/posts/claude-sonnet-5-5
- Published: 2026-10-06
- Updated: 2026-10-06
- Author: LaoZhang AI Team (https://blog.laozhang.ai/en/about)
- Topic: Claude Code
- Tags: Claude Sonnet 5.5, Claude Sonnet 5, Claude API, Claude Code, API Migration

---
Claude Sonnet 5.5 (`claude-sonnet-5-5`) is the Sonnet model Anthropic released on September 28, 2026, as the successor to Sonnet 5. It bills exactly what Sonnet 5 does: $2 per million input tokens and $10 per million output tokens, with the same cache and batch rates. It also uses the same tokenizer, so the same text counts the same tokens. What moves your bill is how many tokens it spends to finish a task, and that depends on the effort level you run.

On the Artificial Analysis (AA) Intelligence Index, as of October 5, 2026, Sonnet 5.5 costs less per task than Sonnet 5 at `low`, `medium`, `high`, and `xhigh` effort and scores higher at every level. At `max`, it costs about 51% more. That's how Anthropic's "costs up to 30% less for most work" and AA's "~50% higher than Sonnet 5's Cost per Task" can both be true: AA's headline compares the two models at max.

Switching takes more than a model ID change. Five changes can return 400 errors on code that works on Sonnet 5, including `thinking: {"type": "disabled"}` and forced `tool_choice`. Sonnet 5 stays available as a legacy model until at least June 30, 2027, so you have time to fix them first. If you're still on Sonnet 4.5, your clock is shorter: it retires from the Claude API on November 30, 2026.

## Sonnet 5.5 vs Sonnet 5 specs: same price and tokenizer, newer cutoff

Sonnet 5.5 is still a Sonnet-class model: same price tier, same context window, same output limit. The differences that matter in practice are the knowledge cutoff, how you turn thinking off, and the defaults in Claude Code and the Claude apps.

| | Claude Sonnet 5 | Claude Sonnet 5.5 |
|---|---|---|
| Claude API model ID | `claude-sonnet-5` | `claude-sonnet-5-5` (no date suffix) |
| Amazon Bedrock model ID | `anthropic.claude-sonnet-5` | `anthropic.claude-sonnet-5-5` |
| Released | June 30, 2026 | September 28, 2026 |
| Status on the Claude API | Legacy, retirement not sooner than June 30, 2027 | Active, retirement not sooner than September 28, 2027 |
| Input / output per million tokens | $2 / $10 | $2 / $10 |
| Cache read / 5-minute write / 1-hour write | $0.20 / $2.50 / $4 | $0.20 / $2.50 / $4 |
| Tokenizer | Sonnet 5 tokenizer | Same as Sonnet 5 |
| Context window / max output | 1M / 128K tokens | 1M / 128K tokens |
| Knowledge cutoff | January 2026 | June 2026 |
| Default effort on the Claude API | `high` | `high` |
| Default effort in Claude Code | `high` | `medium` (also `medium` in the Claude apps) |
| Thinking off | `thinking: {"type": "disabled"}` | `thinking: {"type": "between_tools"}`, at `low` to `high` only |
| Minimum cacheable prompt | 1,024 tokens | 512 tokens |
| Forced tool use (`any`, `tool`) | Supported | Returns a 400 error |

Prices and lifecycle dates come from the [Claude API pricing page](https://platform.claude.com/docs/en/about-claude/pricing) and [Anthropic's model deprecations page](https://platform.claude.com/docs/en/about-claude/model-deprecations); the rest is from [What's new in Claude Sonnet 5.5](https://platform.claude.com/docs/en/models/sonnet-5-5/whats-new-sonnet-5-5) in the Claude Platform docs. Batch processing is 50% off for both models. For why Sonnet 5 ended up at $2/$10 after a planned increase, see [Claude Sonnet 5 Price Increase Canceled: Current Rates and Billing Math](https://blog.laozhang.ai/en/posts/claude-sonnet-5-pricing).

Sonnet 5.5 is available on the Claude API, Amazon Bedrock, Claude Platform on AWS, Google Cloud, and Microsoft Foundry. Cloud providers set their own lifecycle dates, so check your provider's model list if you aren't on the Claude API.

## Is Sonnet 5.5 cheaper than Sonnet 5? Per task, yes, except at max

Per token, no: the rates are identical. Per task, Sonnet 5.5 costs less at every effort level except `max`, because below `max` it usually finishes with fewer output tokens. The table below uses AA's Intelligence Index v4.3.2, a mix of 10 evaluations, as published on [Artificial Analysis's Claude Sonnet 5.5 model page](https://artificialanalysis.ai/models/claude-sonnet-5-5) as of October 5, 2026. Cost per task is what AA spent to run one index task. Scores are rounded to whole numbers.

| Effort | Sonnet 5: score / cost per task | Sonnet 5.5: score / cost per task | Cost change | Score change |
|---|---|---|---|---|
| `low` | 24 / $0.51 | 36 / $0.42 | −18% | +12 |
| `medium` | 28 / $1.00 | 41 / $0.59 | −41% | +13 |
| `high` | 32 / $1.79 | 47 / $1.12 | −37% | +15 |
| `xhigh` | 34 / $2.87 | 52 / $2.75 | −4% | +18 |
| `max` | 38 / $5.09 | 56 / $7.67 | +51% | +18 |

Cost change is (Sonnet 5.5 cost ÷ Sonnet 5 cost) − 1, calculated from AA's figures. For `max`, that's 7.67 ÷ 5.09 − 1 = +51%. For `high`, 1.12 ÷ 1.79 − 1 = −37%.

![Bar chart of cost per task for Sonnet 5 and Sonnet 5.5 at low, medium, high, xhigh and max effort, with Sonnet 5.5 cheaper at every level except max, where it costs 51% more](https://blog.laozhang.ai/posts/en/claude-sonnet-5-5/img/sonnet-5-5-cost-per-task-by-effort.webp)

The `max` row is where Sonnet 5.5's token appetite shows. AA measured about 197,400 output tokens per task at `max`, against 117,800 for Sonnet 5, roughly 68% more. At `high`, it was the other way around: 37,300 for Sonnet 5.5 against 44,300 for Sonnet 5. At `xhigh`, Sonnet 5.5 already writes more output (74,800 vs 65,400 tokens), and the two models cost about the same per task.

So the two headlines measure different things:

- **Anthropic's "up to 30% less per task"** comes from [Anthropic's Claude Sonnet 5.5 announcement](https://www.anthropic.com/claude-sonnet-5-5). It's a vendor maximum from Anthropic's own tests, stated "for most work." It doesn't promise savings at every setting.
- **AA's "~50% higher"** comes from [Artificial Analysis's Sonnet 5.5 launch analysis](https://artificialanalysis.ai/articles/claude-sonnet-5-5) on September 28, 2026, and compares both models at `max`, the one setting where Sonnet 5.5 spends far more tokens.

The bigger saving comes from dropping a level. On AA's index, Sonnet 5.5 at `low` (36, $0.42) outscored Sonnet 5 at `xhigh` (34, $2.87) at about one-seventh the cost. Sonnet 5.5 at `medium` (41, $0.59) outscored Sonnet 5 at `max` (38, $5.09) at about one-ninth the cost. Anthropic describes the same pattern on several of its own benchmarks: Sonnet 5.5 at Low or Medium effort beats Sonnet 5's best score "for about a tenth of the cost per task."

A real workload shows a similar direction. In [CodeRabbit's Sonnet 5.5 code-review test](https://www.coderabbit.ai/blog/sonnet-5-5-model-review), the Claude calls behind one review cost about 60% less on Sonnet 5.5 ($0.46–0.47 vs $1.16 at list prices) and finished in about half the wall-clock time. That run covered 13 hard known-bug cases, a sample CodeRabbit itself calls small.

Speed splits the same way as cost. AA's time per task drops at most levels, for example from 375 to 238 seconds at `high`, but rises at `max`, from 852 to 968 seconds. Anthropic reports that Sonnet 5.5 generates output 30%+ faster than Sonnet 5.

## How much better is Sonnet 5.5? 12 to 18 index points over Sonnet 5

On AA's index, Sonnet 5.5 scores 12 points higher than Sonnet 5 at `low` and 18 higher at `max`. At `max`, its score of 56 put it second on AA's index at launch, two points behind Opus 5.5 at `max`.

Anthropic's launch table shows larger jumps on agentic work. These are vendor-run evaluations, mostly at the highest effort:

| Benchmark (Anthropic's table) | Sonnet 5 | Sonnet 5.5 |
|---|---|---|
| Terminal-Bench 4.0 | 10.3% | 70.6% |
| CursorBench 4.0 | 34.1% | 55.5% |
| FrontierCode 1.1 (Main) | 42.4% | 52.1% at `xhigh` (46.2% at `max`) |
| OSWorld 2.1 (partial) | 57.0% | 80.1% |
| Humanity's Last Exam (with tools) | 54.9% | 64.5% |
| Chartography (no tools) | 15.6% | 61.6% |

Read the Terminal-Bench row with care. Sonnet 5's 10.3% baseline is unusually low: AA's own Terminal-Bench 4.0 runs measured 14.1% for Sonnet 5 and 63.6% for Sonnet 5.5, both at `max`. The gap is still large, just not 60 points.

CodeRabbit's review test adds a third-party view on bug finding. Sonnet 5.5 caught 6 of 13 known bugs against 4 for Sonnet 5, at nearly the same actionable precision (41.2% vs 40.0%). Four of its catches were bugs Sonnet 5 missed, and it missed two that Sonnet 5 caught, so it's a different set of misses as much as more catches.

It's still a Sonnet. Anthropic says Opus 5.5 "remains clearly stronger at complex, open-ended work requiring sustained judgment," and AA measured lower factual accuracy for Sonnet 5.5 than Opus 5.5 on AA-Omniscience (54% vs 66%). Opus 5.5 lists at $4/$20 per million tokens, twice Sonnet's rates.

## Which Sonnet 5.5 effort level replaces your Sonnet 5 setting

Don't copy your Sonnet 5 setting. Anthropic recalibrated the levels, so `high` on Sonnet 5.5 doesn't produce the same amount of thinking as `high` on Sonnet 5, and its migration guide tells you to re-run your effort sweep. [Anthropic's effort parameter docs](https://platform.claude.com/docs/en/build-with-claude/effort) give these starting points for Sonnet 5.5:

- **Most work:** start at `high`, the Claude API default.
- **Agentic coding and multistep tool use:** start at `medium` for well-specified tasks, and move to `high` for harder or longer ones.
- **Chat and other latency-sensitive work:** start at `medium` or `low`.
- **`xhigh` and `max`:** use them only where your evals show a quality gain.

AA's data gives you the other end of the sweep: the lowest Sonnet 5.5 level that already matched your old Sonnet 5 setting on its index.

| Your Sonnet 5 setting (AA score, cost per task) | Lowest Sonnet 5.5 level that scored as high on AA's index | Cost per task vs your old setting |
|---|---|---|
| `low` (24, $0.51) | `low` (36, $0.42) | −18% |
| `medium` (28, $1.00) | `low` (36, $0.42) | −58% |
| `high` (32, $1.79) | `low` (36, $0.42) | −77% |
| `xhigh` (34, $2.87) | `low` (36, $0.42) | −85% |
| `max` (38, $5.09) | `medium` (41, $0.59) | −88% |

Percentages use the same formula as above, for example 0.42 ÷ 1.79 − 1 = −77%.

The rule that follows: sweep between that floor and Anthropic's starting point for your workload, and keep the lowest level that passes your own evals. An index score averages 10 evaluations, and your workload may lean hard on one of them, so the floor tells you where to start testing, not where to stop.

Treat `max` as a separate decision. On AA's index, Sonnet 5.5 at `max` adds 9 points over `high` (56 vs 47) at about 6.8 times the cost per task ($7.67 vs $1.12). If your Sonnet 5 job ran at `max` because nothing lower was good enough, try `high` on Sonnet 5.5 before paying for `max`.

If you ran Sonnet 5 with thinking off, the choice narrows. `between_tools`, the Sonnet 5.5 replacement for `disabled`, works only at `low`, `medium`, and `high`. A thinking-off setup at `xhigh` or `max` has to pick one: drop to `high` and keep up-front thinking off, or stay at `xhigh` or `max` with adaptive thinking on.

## Five changes that return errors after switching to claude-sonnet-5-5

Anthropic lists five breaking changes for code already running on Sonnet 5. Check each row against your integration before you change the model ID:

| Change | Hits your code if it… | What Sonnet 5.5 returns | Fix |
|---|---|---|---|
| Thinking off | sends `thinking: {"type": "disabled"}` | 400 `invalid_request_error` that points to `between_tools` | Send `{"type": "between_tools"}` at `low` to `high`, or drop the field to use adaptive thinking at `xhigh` or `max` |
| Forced tool use | sets `tool_choice` to `any` or `tool`, including on the token-counting endpoint | 400: `tool_choice: type "tool" and "any" are not supported for this model.` | Keep `auto` and mark the tool `strict: true`, or move the schema to structured outputs; on Bedrock, `auto` alone |
| Thinking blocks tied to the conversation | edits the system prompt, tools, or an earlier message, then replays a Sonnet 5.5 thinking block | 400 on accounts created on or after August 31, 2026, 00:00 UTC (Claude API, Bedrock, Google Cloud) | Keep history append-only and change instructions with mid-conversation system messages |
| Computer use | declares `computer_20251124` on the Claude API or Google Cloud | 400: `'claude-sonnet-5-5' does not support tool types: computer_20251124.` | Switch to `computer_toolset_20260801`; Bedrock still accepts the old tool |
| Advisor tool (beta) | uses Opus 4.8, Opus 4.7, or Sonnet 5 as the advisor | 400 `invalid_request_error` | Use Opus 5.5, Opus 5, Sonnet 5.5 itself, or a Fable or Mythos advisor |

![Five Sonnet 5 request patterns that return a 400 error on Sonnet 5.5, each paired with its fix: between_tools for thinking off, auto with strict tools, append-only history, computer_toolset_20260801, and a supported advisor model](https://blog.laozhang.ai/posts/en/claude-sonnet-5-5/img/sonnet-5-5-breaking-changes-fixes.webp)

If you use Claude Code, the bundled Claude API skill can apply the model ID swap and the breaking parameter changes for you. Run `/claude-api migrate this project to claude-sonnet-5-5`; it asks you to confirm the scope before editing files and ends with a checklist of items to verify by hand. [Anthropic's Sonnet 5.5 migration guide](https://platform.claude.com/docs/en/models/sonnet-5-5/migration-guide) has before-and-after requests in every SDK language. The two you're most likely to need are below in Python.

### Thinking off: replace "disabled" with "between_tools"

On Sonnet 5.5, `disabled` fails with this message:

```text
To turn thinking off on this model, send "thinking": {"type": "between_tools"} instead of {"type": "disabled"}. The model does not think before responding. The short updates it writes between tool calls come back as thinking blocks.
```

A Sonnet 5 request that turned thinking off at `xhigh`:

```python
client.messages.create(
    model="claude-sonnet-5",
    max_tokens=16000,
    thinking={"type": "disabled"},
    output_config={"effort": "xhigh"},
    messages=[{"role": "user", "content": "..."}],
)
```

The Sonnet 5.5 version keeps thinking off, so effort has to come down to `high`:

```python
client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=16000,
    thinking={"type": "between_tools"},
    output_config={"effort": "high"},
    messages=[{"role": "user", "content": "..."}],
)
```

To stay at `xhigh` or `max` instead, remove the `thinking` field (or send `{"type": "adaptive"}`) and accept up-front thinking. `between_tools` takes no other field: sending `display`, `budget_tokens`, or `block_binding` with it returns a 400 error. With it, you also can't change effort mid-conversation. Without tools, the response is text only, the same as `disabled` on Sonnet 5.

### Forced tool use: tool_choice "any" and "tool" are rejected

Sonnet 5 code that forced a tool call:

```python
client.messages.create(
    model="claude-sonnet-5",
    max_tokens=1024,
    tools=tools,
    tool_choice={"type": "tool", "name": "get_weather"},
    messages=[{"role": "user", "content": "What's the weather in Paris?"}],
)
```

On Sonnet 5.5, let the model choose and make the tool strict so its input matches the schema:

```python
client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=1024,
    # strict tool use: every call matches the tool's input_schema
    tools=[{**tool, "strict": True} for tool in tools],
    tool_choice={"type": "auto"},
    messages=[
        {
            "role": "user",
            "content": "What's the weather in Paris? Use the get_weather tool.",
        }
    ],
)
```

With `auto`, the model can answer without calling the tool, so the prompt has to say when the tool applies. Strict tool use needs `additionalProperties: false` on every object and allows at most 20 strict tools per request. On Amazon Bedrock, structured outputs (which include strict tool use) aren't available for Sonnet 5.5, so send `auto` without `strict` and validate the tool input in your own code.

### Thinking blocks, computer use, and advisor pairings

Thinking blocks now record which model and which conversation produced them. Moving a conversation from Sonnet 5 onto Sonnet 5.5 keeps its reasoning, because Sonnet 5.5 reads Sonnet 5's blocks. Moving from Sonnet 5.5 up to Opus 5.5 keeps it too, on the Claude API and Google Cloud. Any other move away from Sonnet 5.5 drops the blocks: the request still succeeds, and dropped blocks aren't billed. Sonnet 5.5 thinking blocks also work only in the account that produced them or a linked account.

The edit check is the one that throws errors. If anything before a Sonnet 5.5 thinking block changes (the `system` prompt, the `tools`, or an earlier message) and you replay the block, newer accounts get a 400. To drop the affected blocks instead of failing, send the `thinking-binding-controls-2026-08-01` beta header and set `thinking.block_binding.prefix_mismatch_behavior` to `"drop_block"`; this works only with adaptive thinking.

For computer use on the Claude API or Google Cloud, drop the beta header, replace the tools entry with `{"type": "computer_toolset_20260801"}`, and update your agent loop for member `tool_use` blocks, batched actions, and `toolset_name` on results. If you also send `fine-grained-tool-streaming-2025-05-14`, remove it; next to a toolset entry it returns a 400.

For the advisor tool, every advisor Sonnet 5.5 accepts returns its advice encrypted as an `advisor_redacted_result` block. If your code reads the advice text, that part stops working even after you pick a supported advisor.

## Changes with no error: quiet tool loops, new refusals, cheaper caching

Some differences change the response without failing a request. They're easy to miss in testing because nothing returns a 4xx.

**Text between tool calls moves into thinking blocks.** On Sonnet 5, everything the model wrote between tool calls came back as `text`. On Sonnet 5.5, notes longer than a sentence or two come back as progress-update `thinking` blocks, which are empty at the default `display: "omitted"`. An app that streams those notes to users goes quiet between tool calls. With adaptive thinking, set `thinking.display` to `"updates"` (with the `thinking-display-updates-2026-08-18` beta header) for the updates alone, or to `"summarized"` for updates mixed with reasoning. Render each non-empty `thinking` block before the `tool_use` block that follows it. With `between_tools`, the text comes back without any `display` setting.

**More requests can end in a refusal.** Sonnet 5.5 is the first Sonnet with cyber safeguards and reasoning-extraction classifiers. A declined request returns HTTP 200 with `stop_reason: "refusal"` and a `stop_details` category: `cyber`, `bio`, `frontier_llm`, `reasoning_extraction`, or `general_harms`. Benign work can trigger `general_harms`. Server-side fallback (`fallbacks: "default"`, beta, Claude API only) retries `cyber` and `frontier_llm` declines on Sonnet 5; it doesn't retry the other three. Refusals count against your rate limits either way, and whether one is billed depends on its category. If your code only checks for errors, add a check for this stop reason.

**Smaller prompts can be cached.** The minimum cacheable prompt drops to 512 tokens from 1,024, so prompts in between now get cache-read pricing.

**New controls you can use.** Sonnet 5.5 supports per-message effort (beta), mid-conversation system messages, and mid-conversation tool changes (beta), none of which Sonnet 5 offers. Mid-conversation system messages are also the clean way to change instructions without tripping the thinking-block edit check.

## Using Sonnet 5.5 in Claude Code: version, alias, effort, and /status

Claude Code needs version 2.1.284 or later for Sonnet 5.5. Here's the switch, in order:

1. Run `claude update`. On older versions, requests for Sonnet 5.5 fail.
2. Switch with `/model claude-sonnet-5-5` (or `/model sonnet` on the Anthropic API). Press `Enter` in the picker to save it as your default, or `s` for this session only. To start a session on it, use `claude --model claude-sonnet-5-5` or set `ANTHROPIC_MODEL`.
3. Run `/status` to confirm which model is running.
4. Set effort on purpose. Sonnet 5.5 starts at `medium` in Claude Code, where Sonnet 5 started at `high`. A top-level `effortLevel` you saved in user settings for older models doesn't carry over; pick a level with `/effort` (for example `/effort high`), `--effort`, or `CLAUDE_CODE_EFFORT_LEVEL`.

Switch at the start of a session when you can. Changing models mid-session invalidates the prompt cache, so the next request re-reads the whole conversation at uncached rates.

The `sonnet` alias doesn't mean Sonnet 5.5 everywhere. Per [Claude Code model configuration docs](https://code.claude.com/docs/en/model-config), it resolves by provider:

| Provider | `sonnet` resolves to |
|---|---|
| Anthropic API | Sonnet 5.5 |
| Claude Platform on AWS | Sonnet 4.6 |
| Amazon Bedrock, Google Cloud's Agent Platform | Sonnet 4.5 |
| Microsoft Foundry | Sonnet 4.5 |

On those providers, select Sonnet 5.5 by its full model ID, or pin it with `ANTHROPIC_DEFAULT_SONNET_MODEL`. The pin has one side effect on cyber fallback. When a Sonnet 5.5 request is flagged for cybersecurity, Claude Code re-runs it on Sonnet 5 and the session stays on Sonnet 5 until you run `/model` again. On Bedrock, Google Cloud, and Foundry, that re-run goes to the model set in `ANTHROPIC_DEFAULT_SONNET_MODEL`, or to a Sonnet 5 entry in your provider's model list if that variable isn't set. A pin that names Sonnet 5.5 itself leaves the refusal standing. Fallback on those providers also needs an Opus target: `ANTHROPIC_DEFAULT_OPUS_MODEL` or an Opus 4.8 entry. Biology-flagged requests on Sonnet 5.5 end in a refusal on every provider, because there's no biology fallback model.

In the Claude apps, Sonnet 5.5 also runs at Medium effort by default, while the Claude Platform API defaults to High.

## Should you stay on Sonnet 5 for now? When waiting makes sense

You can. Sonnet 5 is a legacy model, not a deprecated one: there's no deprecation notice, it's still available, and its retirement is not sooner than June 30, 2027. Anthropic suggests you consider moving to Sonnet 5.5 but sets no deadline.

Waiting makes sense when:

- **Your code forces tool calls** and you haven't moved to `auto` with strict tools or structured outputs, especially on Bedrock, where structured outputs aren't available for Sonnet 5.5.
- **Your production job runs at `max`** and cost per task is the number you're held to. On AA's index, Sonnet 5.5 at `max` costs about 51% more per task. Testing Sonnet 5.5 at `high` is the alternative to staying.
- **Your app edits conversation history**, such as rewriting the system prompt each turn or trimming old messages, and your account was created on or after August 31, 2026.
- **Your UI streams the model's notes between tool calls** and you haven't added `display` handling yet.
- **Your advisor-tool code reads the advice text**, which Sonnet 5.5 always encrypts.
- **Your work is security research** that regularly trips cyber classifiers. Flagged requests fall back to Sonnet 5 anyway.

For chat, well-scoped coding, documents, and most agent work, none of these apply, and the data favors switching and testing one effort level lower.

## Still on Sonnet 4.5? The November 30, 2026 retirement

On September 30, 2026, Anthropic deprecated `claude-sonnet-4-5-20250929`. It retires from the Claude API on November 30, 2026, and the recommended replacement is `claude-sonnet-5-5`. Sonnet 4.6 isn't affected; its retirement is not sooner than February 17, 2027. Amazon Bedrock, Google Cloud, and Microsoft Foundry set their own dates.

Moving from Sonnet 4.5 means every Sonnet 5 change above plus a longer list. The items most likely to break or change your bill:

- **Thinking now runs by default.** Sonnet 4.5 ran without it. Read content blocks by `type` instead of `content[0].text`, pass thinking blocks back unchanged in tool loops, and revisit `max_tokens`, which covers thinking plus text.
- **Non-default `temperature`, `top_p`, and `top_k` return 400 errors.** Remove them.
- **Assistant prefill returns a 400:** `This model does not support assistant message prefill. The conversation must end with a user message.`
- **The same text costs about 30% more tokens** than on Sonnet 4.5's tokenizer, and images now go up to 2,576 pixels, so a 2000×1500 image uses about 2.5 times as many tokens. Re-baseline cost before you compare bills.
- **Set `output_config.effort` explicitly**, move `output_format` to `output_config.format`, remove `interleaved-thinking-2025-05-14` and any context-window beta header, and replace `fine-grained-tool-streaming-2025-05-14` with `eager_input_streaming`.

The migration guide's "Migration checklist by starting model" lists every item for Sonnet 4.5.

## Claude Sonnet 5.5 FAQ

### Is Claude Sonnet 5.5 free in the Claude app?

As of September 29, 2026, Claude's plan comparison on claude.com lists Sonnet as available on the Free plan and Opus as paid-only, without naming versions. Sonnet 5.5 is the current Sonnet, so that's most likely the model Free users get, but the table doesn't say so directly. In the apps, Sonnet 5.5 runs at Medium effort by default. Through the API, it bills $2/$10 per million tokens.

### Is Sonnet 5.5 as good as Opus 5.5?

Not for the hardest work. At `max`, AA puts Sonnet 5.5 two index points behind Opus 5.5, but Anthropic says Opus 5.5 remains clearly stronger at open-ended work that needs sustained judgment, and Sonnet 5.5 trails on factual accuracy. Sonnet 5.5 costs half as much per token ($2/$10 vs $4/$20).

### Is Claude Sonnet 5 deprecated?

No. Anthropic lists Sonnet 5 as legacy and still available, with retirement not sooner than June 30, 2027. The model being retired soon is Sonnet 4.5, on November 30, 2026.

### Does Sonnet 5.5 use more tokens than Sonnet 5 for the same text?

Not for input. The tokenizer is the same, so the same text produces the same token count. Output is different: it depends on effort. On AA's index, Sonnet 5.5 wrote fewer output tokens per task than Sonnet 5 at `low`, `medium`, and `high`, and more at `xhigh` and `max`.

### How does Sonnet 5.5 compare with GPT-6 Astra?

Sonnet 5.5 costs about one-fifth as much per token, but on AA's index it beats GPT-6 Astra only at `max`, where each task costs more. The per-effort breakdown is in [Claude Sonnet 5.5 vs GPT-6 Astra: When the Cheaper Model Wins](https://blog.laozhang.ai/en/posts/claude-sonnet-5-5-vs-gpt-6-astra).

## Sources

External pages this guide links to, in the order they appear. Last updated 2026-10-06.

- [Claude API pricing page](https://platform.claude.com/docs/en/about-claude/pricing) (platform.claude.com)
- [Anthropic's model deprecations page](https://platform.claude.com/docs/en/about-claude/model-deprecations) (platform.claude.com)
- [What's new in Claude Sonnet 5.5](https://platform.claude.com/docs/en/models/sonnet-5-5/whats-new-sonnet-5-5) (platform.claude.com)
- [Artificial Analysis's Claude Sonnet 5.5 model page](https://artificialanalysis.ai/models/claude-sonnet-5-5) (artificialanalysis.ai)
- [Anthropic's Claude Sonnet 5.5 announcement](https://www.anthropic.com/claude-sonnet-5-5) (anthropic.com)
- [Artificial Analysis's Sonnet 5.5 launch analysis](https://artificialanalysis.ai/articles/claude-sonnet-5-5) (artificialanalysis.ai)
- [CodeRabbit's Sonnet 5.5 code-review test](https://www.coderabbit.ai/blog/sonnet-5-5-model-review) (coderabbit.ai)
- [Anthropic's effort parameter docs](https://platform.claude.com/docs/en/build-with-claude/effort) (platform.claude.com)
- [Anthropic's Sonnet 5.5 migration guide](https://platform.claude.com/docs/en/models/sonnet-5-5/migration-guide) (platform.claude.com)
- [Claude Code model configuration docs](https://code.claude.com/docs/en/model-config) (code.claude.com)