Claude Sonnet 5.5 Developer Guide: Pricing, Benchmarks, and the Five API Changes

Last updated: September 28, 2026 - prices, benchmarks, and API changes re-verified against Anthropic's announcement, platform docs, and the GitHub and Vercel changelogs on this date.

Claude Sonnet 5.5 (claude-sonnet-5-5) is Anthropic's new mid-tier model, released September 28, 2026 at $2 per million input tokens and $10 per million output tokens. Pick it over Opus 5.5 for well-scoped everyday coding and agent work where half the token price matters, over Sonnet 5 always (same price, far higher vendor-reported scores), and over Haiku 4.5 ($1 / $5, 200K context) when quality matters more than cost. It is the second model in the Claude 5.5 family and the replacement for Claude Sonnet 5. It is generally available in GitHub Copilot and live on Vercel's AI Gateway the same day. Those are Sonnet 5's prices, with a 1M-token context window, 128K max output, and vendor benchmarks that land next to Claude Opus 5.5.

The three numbers to remember: Anthropic reports Terminal-Bench 4.0 at 70.6% against Sonnet 5's 10.3%, CursorBench 4.0 at 55.5% against 34.1%, and output generated 30%+ faster than Sonnet 5. If you run Sonnet 5 in production, the code migration is small but not zero: five changes now return HTTP 400, and the replacement for the most common one has a new name.

Official Sources#

Benchmarks: Anthropic's Launch Numbers#

Vendor-reported, from the announcement. Sonnet 5.5 runs with safeguards on; where a request is declined, server-side fallback answers with Sonnet 5.

Two caveats Anthropic states itself. At max effort, Sonnet 5.5 scores lower on FrontierCode than at xhigh (46.2% versus 52.1%), because it more often triggers a multi-subagent code-review skill that overshot the task scope in two examined cases. And the knowledge-work scores were run by Artificial Analysis on a pre-release deployment that had a structured-output bug, which Anthropic says understates the result. The launch numbers are still the best first read available; they are not independent evaluations.

Pricing: Sonnet 5 Sticker, Opus 5.5 Benchmark Neighbors#

First-party API prices per 1M tokens, verified on the Sonnet 5.5 model overview and the Claude API pricing pages on September 28, 2026:

The cache-read row is the one to look at twice. Sonnet 5.5 and Opus 5.5 charge the same $0.20 per million cached tokens, and cache reads dominate long agent loops. Anthropic's "up to 30% less per task" claim is measured against Sonnet 5, not Opus, and comes from needing fewer tokens rather than a lower rate. Cost per task is the only number that settles it, which is the same arithmetic we ran for parallel Claude agent fleets.

Worked example, using list prices. An agent turn sends 100K input tokens, 90K of them cache reads, and returns 4K output:

• Sonnet 5.5: 90K cache reads = $0.018, 10K fresh input = $0.020, 4K output = $0.040. Total $0.078.
• Opus 5.5: same cache reads = $0.018, 10K fresh input = $0.040, 4K output = $0.080. Total $0.138.

That is about 43% cheaper on input/output-heavy turns, and roughly 10% cheaper on a fully cached turn where only the cache-read line applies. GitHub Copilot bills the same list rates through AI credits, where 1 credit = $0.01, so that turn costs about 7.8 credits on Sonnet 5.5 in Copilot. The per-token table in Copilot's docs lists Claude Sonnet 5.5 at $2.00 input, $0.20 cached input, $2.50 cache write, and $10.00 output - identical to GPT-6 Sol's Copilot rates, which makes the model picker a straight benchmark-versus-benchmark decision at equal price.

Run It Today: Copilot, AI Gateway, Anthropic API, OpenCode#

GitHub Copilot is the fastest path. Sonnet 5.5 is available to Copilot Pro, Pro+, Max, Business, and Enterprise users, in the model picker across VS Code, Visual Studio, Copilot CLI, the Copilot coding agent, the Copilot app, github.com, GitHub Mobile, JetBrains IDEs, Xcode, and Eclipse. Rollout is gradual. Business and Enterprise administrators control access through the model policy in Copilot settings; under default enablement, new models are on unless an admin has turned off the global default. GitHub's changelog says its early testing found the model matching Sonnet 5 on coding tasks while using significantly fewer steps, tokens, and tool calls. If you are weighing the jump to a terminal agent instead, our Copilot to Claude Code migration guide covers that route.

On Vercel's AI Gateway the model is anthropic/claude-sonnet-5.5, with Zero Data Retention supported. The changelog's setup command is:

npx vercel ai-gateway setup

That detects installed coding agents, provisions a gateway key, and writes their config; run /model afterwards to pick Sonnet 5.5. The AI SDK call is model: 'anthropic/claude-sonnet-5.5'.

Direct on the Claude API, the model id is claude-sonnet-5-5 (no date suffix) and the current SDK examples set effort in output_config. This request is copied verbatim from the official migration guide; we did not run it, because no Anthropic API key was available in the environment used to write this post:

curl https://api.anthropic.com/v1/messages \
  -H "x-api-key: $ANTHROPIC_API_KEY" \
  -H "anthropic-version: 2023-06-01" \
  -H "content-type: application/json" \
  -d '{
    "model": "claude-sonnet-5-5",
    "max_tokens": 4096,
    "messages": [{"role": "user", "content": "Fix the failing test and verify the change."}],
    "output_config": {"effort": "medium"}
  }'

We could not confirm Sonnet 5.5 in OpenCode: opencode models on a local install on September 28 returned no Sonnet 5.5 entry, so there is no opencode run --model line to give you today. Check your own catalog, or use the API or Copilot.

Python and TypeScript SDK#

The migration guide's Messages examples, with the verified model id and effort set through output_config. Doc-verified, not executed: no Anthropic API key was available where this post was written.

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Analyze the trade-offs between microservices and monolithic architectures",
        }
    ],
    output_config={"effort": "medium"},
)

print(f"Stop reason: {response.stop_reason}")
for block in response.content:
    if block.type == "text":
        print(block.text)

import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic();

const response = await client.messages.create({
  model: "claude-sonnet-5-5",
  max_tokens: 4096,
  messages: [
    {
      role: "user",
      content: "Analyze the trade-offs between microservices and monolithic architectures",
    },
  ],
  output_config: { effort: "medium" },
});

const textBlock = response.content.find(
  (block): block is Anthropic.TextBlock => block.type === "text",
);
console.log(textBlock?.text);

Read blocks by type, as both loops do: with adaptive thinking on by default, a response can begin with a thinking block, so content[0].text breaks. To turn up-front thinking off, send thinking: {"type": "between_tools"} at high effort or below. Anthropic notes that SDK versions without between_tools fail type checking on that value; update the SDK or pass raw JSON. In Claude Code, the migration guide says /claude-api migrate this project to claude-sonnet-5-5 automates the model swap and breaking-parameter edits.

Claude Code#

Per the Claude Code model configuration docs, the sonnet alias now resolves to Sonnet 5.5 on the Anthropic API (on Amazon Bedrock, Google Cloud, and Microsoft Foundry it still resolves to an older Sonnet, so pin the full id there). The documented ways to select it:

claude --model sonnet
claude --model claude-sonnet-5-5
claude --effort medium

/model sonnet
/effort high

Claude Code's default effort on Sonnet 5.5 and Opus 5.5 is medium, while the raw API default is high. Sonnet 5.5 has a native 1M window, so no [1m] suffix is needed. To pin the model and effort per project, the docs show these settings.json keys:

{
  "model": "sonnet",
  "modelSettings": {
    "sonnet": { "effort": "medium" }
  },
  "env": {
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-5-5"
  }
}

The env alternative is ANTHROPIC_MODEL=sonnet, and claude --fallback-model sonnet,haiku sets fallbacks.

Three prompt changes worth making#

Anthropic says existing Sonnet 5 prompts should work unchanged, and its Sonnet 5.5 prompting guide lists targeted fixes. These are our paraphrases of three of them.

1. It stops to ask at low and medium effort. Anthropic reports that on long agentic coding tasks the model sometimes pauses to confirm a plan or asks whether to continue.

• Before: "Migrate the auth module to the new session API." The agent finishes the first file, then asks whether to keep going.
• After: the same request, plus a system prompt line telling it to keep working until everything asked is done and to stop only when blocked or before a risky step. Anthropic warns sessions then run longer and cost more.

2. It adds unrequested tests and docs. The guide says the model tends to add tests and small supporting files that fit your repo, more at higher effort.

• Before: "Fix the off-by-one in pagination." The diff includes a new test file and a README edit.
• After: add a system prompt rule to report the finished change and mention optional extras at the end instead of making them.

3. JSON answers to multi-step questions come back wrong. With structured outputs, the model can skip thinking on tasks that need working out, especially at low and medium.

• Before: "Total these invoice lines and return JSON," at medium effort with between_tools, and the totals are off.
• After: use adaptive thinking (omit the field), end the system prompt with "Think the problem through before you answer.", or move to xhigh. Treat any stop_reason of max_tokens as a failure and retry.

The Five Breaking Changes (and What Replaces Them)#

All from the migration guide, all 400 errors if you move code unchanged from Sonnet 5:

1. thinking: {"type": "disabled"} is rejected. The replacement is thinking: {"type": "between_tools"}, which turns off up-front thinking while still returning progress updates between tool calls. It works at low, medium, and high effort; at xhigh or max it returns a 400, and display, budget_tokens, or block_binding sent alongside it also fail.
2. Forced tool use is gone. tool_choice of any or tool returns a 400. Send tool_choice: {"type": "auto"} and mark the tool strict: true so its input matches the schema. A request can hold at most 20 strict tools, and every object needs additionalProperties: false. On Amazon Bedrock, structured outputs are unavailable for this model, so validate tool input in your own code.
3. Thinking blocks are model- and account-bound. Sonnet 5.5 cannot read blocks from Opus 5, Opus 5.5, Fable, or Mythos models, and each block is signed over the conversation before it. For accounts created on or after August 31, 2026, replaying a block after an edit to earlier history returns a 400: keep histories append-only.
4. Computer use changes toolset. On the Claude API and Google Cloud, computer_20251124 is rejected; use computer_toolset_20260801, and drop the fine-grained-tool-streaming-2025-05-14 beta header.
5. The advisor tool accepts fewer advisors. An Opus 4.8, Opus 4.7, Opus 4.6, Sonnet 5, or Sonnet 4.6 advisor returns a 400; pair the executor with Opus 5, Opus 5.5, Sonnet 5.5, Fable 5, Fable 5.1, Mythos 5, or Mythos 5.1.

Three quieter changes matter too. Non-default temperature, top_p, or top_k values now return a 400. Notes between tool calls arrive as thinking blocks, so a UI that streams that text goes silent until it sets a display value. And the minimum cacheable prompt drops to 512 tokens from 1,024, which extends caching to shorter prompts. On effort, the API default is high and the Claude apps and Claude Code default to medium; Anthropic recommends re-running your effort sweep rather than carrying over Sonnet 5 levels, starting at medium for well-specified agentic coding and high for harder, longer runs. The Sonnet 5 developer guide is the baseline for what changed in the 5 line.

What people are actually saying#

• The HN thread is bullish on the numbers. The top comment on the main discussion (336 points and 210 comments at our re-read on September 28) posts Anthropic's table and concludes Sonnet 5.5 "stacks up nearly 1:1 with Opus 5.5", and another commenter flags the Terminal-Bench jump: "Big jump on Agentic coding from 10.3% -> 70.6%". A separate system card thread is a three-comment summary of the day: "Sonnet 5.5 max is performing better than opus 5.5", a benchmaxxing joke, and "Haiku 5.5 when?".
• The sharpest disagreement is about effort levels above medium. Several commenters argue there is little reason to run Sonnet 5.5 hard: one says that on the cost-performance charts "in almost all configurations, it looks worse than Opus", and another asks why you would use Sonnet at xhigh when Opus 5.5 at high scores better for less. A third says they cannot find where the 30% saving comes from, since most of their charts show similar cost to Sonnet 5. The cache-read parity with Opus 5.5 is the mechanism several point to.
• The benchmark caveat came from commenters reading the system cards. One notes that 10% of Opus 5.5's Terminal-Bench trials were answered by a fallback model after safeguards intervened, against 1.5% for Sonnet 5.5, and argues that gap alone could explain Sonnet 5.5's lead. Others push back that the user experience with safeguards on is what matters, and a third observes that the fallback rate differing between models is itself a fairness problem for the benchmark.
• Practitioner reports are mixed, with real numbers. Simon Willison writes on the thread that at max effort the model burned 128,000 thinking tokens over 15 minutes and ran out before delivering the final SVG, the same failure he saw from Opus 5.5. A developer who runs an adversarial esolang benchmark reports Sonnet 5.5 performs worse than Sonnet 5 because it stops to ask whether to continue instead of finishing. A PacMan bakeoff entry places it second only to Opus 5.5, and a commenter trying it for a few minutes calls it noticeably faster than Opus.
• Safeguards are the loudest complaint, and Anthropic documents the trade. A Max subscriber in the Cyber Verification Program reports being flagged for authorized security work on both Opus 5.5 and Sonnet 5.5, and others chime in with flags on parser fuzzing, old C code, and an ESP32 project. The docs back the friction: Sonnet 5.5 adds cyber, bio, frontier_llm, and reasoning_extraction refusal categories, and server-side fallback retries only cyber and frontier-LLM declines, on Sonnet 5. The flip side is that this is the first Sonnet model with those safeguards at all, and the first Sonnet to beat Pokemon Red from screenshots alone.
• Reddit split the same way. The r/ClaudeAI launch thread and a top-of-day r/ClaudeCode thread framed the release as Opus-class coding at half the price, while the cost analysis on HN is the counterweight.

Decision Guide: Sonnet 5.5 vs Opus 5.5 vs Sonnet 5 vs Haiku 4.5#

Haiku 4.5 figures come from the comparison table on the Sonnet 5.5 overview page. For the GPT-6 side of the price map, see our GPT-6 Sol vs Opus 5.5 vs Grok 4.7 pricing comparison.

Start with Sonnet 5.5 for well-scoped everyday work: feature work, bug fixes, document and spreadsheet generation, and higher-volume agent tasks where Opus is overkill. At medium and below it is the cheapest way into the 5.5 family, and it is the new default Sonnet.

Move up to Opus 5.5 when the work is open-ended, long-horizon, or needs sustained judgment, or when your evals at Sonnet 5.5 high still fall short. Run the comparison at equal effort budgets rather than equal effort names, and compare cost per completed task: at high effort the two models overlap in price, and the HN thread's cost charts are the argument for checking before assuming the cheaper sticker wins.

Choose Haiku 4.5 for high-volume, latency-first work where $1 / $5 and a 200K window are enough. Anthropic says Haiku 5.5 joins the family in the coming weeks.

Stay on Sonnet 5 only if you have pinned it deliberately and have not run an eval since; the benchmark gap is too large for it to be the default any more. Haiku 5.5 joins the family "in the coming weeks", per the announcement, which will reset the high-volume end of this table.

FAQ#

What is the Claude Sonnet 5.5 model id?#

claude-sonnet-5-5 on the Claude API, Google Cloud, Microsoft Foundry, and Claude Platform on AWS; anthropic.claude-sonnet-5-5 on Amazon Bedrock. There is no date suffix.

Can I turn off thinking on Sonnet 5.5?#

Up-front thinking turns off with thinking: {"type": "between_tools"}, at low, medium, or high effort. The old {"type": "disabled"} returns a 400, and between_tools itself returns a 400 at xhigh or max, where you must use adaptive thinking.

How do I use Sonnet 5.5 in Claude Code?#

Run claude --model sonnet or /model sonnet; on the Anthropic API the sonnet alias resolves to Sonnet 5.5 per the Claude Code docs. Use /effort or claude --effort to change reasoning depth. Claude Code defaults to medium effort on this model.

Which effort level should I start with?#

Anthropic recommends starting at medium for well-specified agentic coding and high for harder or longer tasks, and re-running your own sweep because levels are recalibrated from Sonnet 5. Reserve xhigh and max for work where you measured a gain.

Is Sonnet 5.5 cheaper than Opus 5.5?#

Per token, input and output are half price ($2/$10 versus $4/$20) but cache reads are the same $0.20 per million. On cache-heavy agent loops the real gap is much smaller than the sticker suggests, and at high effort Anthropic's own cost charts show the two models overlapping. Compare cost per task, not per token.

Is Sonnet 5.5 available in GitHub Copilot on my plan?#

It is available to Copilot Pro, Pro+, Max, Business, and Enterprise users and is rolling out gradually. Business and Enterprise admins manage it through the model policy in Copilot settings. Usage is billed at provider list pricing in GitHub AI credits, where 1 credit = $0.01.

Is Claude Sonnet 5.5 available in OpenCode?#

We found no Sonnet 5.5 entry in opencode models on a local install on September 28, 2026, so we cannot confirm it. Check your own catalog; otherwise use the Anthropic API directly, GitHub Copilot, or Vercel AI Gateway.

Sources#

Continue Reading#

• Claude Opus 5.5 Developer Guide - the bigger sibling's API changes, pricing, and effort levels
• Claude Sonnet 5 Developer Guide - what the 5 line changed in July, and the baseline for this migration
• Fable 5 Effort Levels Explained - how the effort dial trades quality against cost on the 5-series
• How to Migrate from GitHub Copilot to Claude Code - the terminal-agent route if the Copilot model picker is not enough
• What a Fleet of Claude Agents Actually Costs - the cache-heavy cost math behind the pricing section
• GPT-6 Sol vs Claude Opus 5.5 vs Grok 4.7 - how the other September launches price against this