Claude Sonnet 5.5 Developer Guide: Pricing and API Changes

Last updated: October 8, 2026 - Sonnet 5.5 cache reads fell from $0.20 to $0.10 per million tokens on October 7, so the pricing table, worked example, Copilot rates, decision guide, and FAQ are re-verified against the Claude API pricing page and GitHub's Copilot models and pricing table (which now lists the same $0.10 cached input, and the same rates for GPT-6.1 Sol), and Haiku 4.5 is replaced by Haiku 5.5. Launch benchmarks, API changes, and community discussion were checked on September 29, 2026.

Claude Sonnet 5.5 (claude-sonnet-5-5) costs $2 per million input tokens, $10 per million output tokens, and $0.10 per million cache reads, after Anthropic halved the cache-read rate on October 7, 2026. That makes it exactly half the price of Claude Opus 5.5 on every line of the bill. Pick it over Opus 5.5 for well-scoped everyday coding and agent work, over Sonnet 5 always (same input and output price, cheaper cache reads, far higher vendor-reported scores), and over Haiku 5.5 whenever the task is multi-step agentic coding rather than high-volume classification or summaries.

Sonnet 5.5 is Anthropic's mid-tier model, released September 28, 2026, the second model in the Claude 5.5 family and the replacement for Claude Sonnet 5. It was generally available in GitHub Copilot and live on Vercel's AI Gateway the same day, 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: Half of Opus 5.5 on Every Line#

First-party API prices per 1M tokens, re-verified on the Claude API pricing page on October 8, 2026:

The cache-read row is the one that changed. At launch, Sonnet 5.5 and Opus 5.5 both charged $0.20 per million cached tokens, which narrowed the real gap on long agent loops where cache reads dominate the bill. On October 7, alongside the Haiku 5.5 launch, Anthropic cut Sonnet 5.5 cache reads by 50% to $0.10 and said that lowers Sonnet 5.5's cost on most agentic tasks by "around 20%". The pricing page now prices cache hits on both 5.5 models at 0.05x base input, so Sonnet 5.5 is exactly half of Opus 5.5 on every per-token line. Anthropic's separate "up to 30% less per task" launch claim is measured against Sonnet 5 and comes from needing fewer tokens, not a lower rate. Cost per task is still the number that settles it, 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.009, 10K fresh input = $0.020, 4K output = $0.040. Total $0.069.
• Opus 5.5: 90K cache reads = $0.018, 10K fresh input = $0.040, 4K output = $0.080. Total $0.138.

That is 50% cheaper, and it stays 50% whether the turn is mostly cached or mostly fresh. At the launch cache rate the same Sonnet 5.5 turn cost $0.078, so the October 7 cut takes about 12% off this particular turn; turns with a bigger cached share save more. GitHub Copilot bills list rates through AI credits, where 1 credit = $0.01, and its per-token table now lists Claude Sonnet 5.5 at $2.00 input, $0.10 cached input, $2.50 cache write, and $10.00 output, so the turn above costs about 6.9 credits in Copilot. In the same table, GPT-6.1 Sol's default tier (prompts up to 272K) lists identical rates: $2.00 input, $0.10 cached input, $2.50 cache write, and $10.00 output, so on price alone the two tie in the model picker and the choice comes down to which one finishes your tasks in fewer tokens. The older GPT-6 Sol default tier still lists $0.20 cached input, so against that one Sonnet 5.5 is cheaper on cache-heavy agent work.

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 at launch is the mechanism several point to; that parity ended with the October 7 cache-read cut.
• 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 Haiku 5.5#

Prices, limits, and effort defaults are from the models overview and pricing page; Terminal-Bench figures are vendor-reported in the Sonnet 5.5 and Haiku 5.5 announcements.

• Start with Sonnet 5.5 for well-scoped everyday work: feature work, bug fixes, document and spreadsheet generation, and higher-volume agent loops. It scores higher than Opus 5.5 on Terminal-Bench 4.0 in Anthropic's launch numbers, at half Opus 5.5's price. Treat that lead as directional: readers of the system cards note that more of Opus 5.5's trials were answered by a fallback model (see the community section).
• Move up to Opus 5.5 for open-ended, long-horizon work that needs sustained judgment, and for review, or when your evals at Sonnet 5.5 high still fall short. Anthropic says the two can perform comparably at a similar cost at higher effort, so compare cost per completed task.
• Route down to Haiku 5.5 for summaries, compaction, classification, routing, and subagent steps, and keep prompts under 100K tokens to stay on the low tier. The Haiku 5.5 guide covers the price cliff and the migration from Haiku 4.5.

Search Demand Check#

Google Trends was accessible on September 29, 2026. For a United States, past-90-days comparison of Claude Sonnet 5.5, GitHub Copilot, Claude Code, AI coding agent, and Claude Sonnet, the durable demand is still around the category queries, not only the launch string.

On September 28 and September 29, Claude Sonnet 5.5 rose from 2 to 3 while Claude Code stayed near 30. That says this page should keep answering the durable comparison questions: Claude in Copilot, GitHub Copilot model choice, Claude Code vs Copilot, and AI coding model pricing. It should not be only a launch recap.

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?#

Yes, by half on every per-token line since October 7, 2026: $2/$10 versus $4/$20 for input and output, and $0.10 versus $0.20 per million cache reads. Before the cache-read cut the two charged the same $0.20, which made cache-heavy agent loops much closer in cost. At higher effort settings Anthropic says the two can perform comparably at a similar cost per task, so compare cost per completed task, not per token.

Should I use Sonnet 5.5 or Haiku 5.5?#

Use Haiku 5.5 ($0.10/$0.50 per million tokens for prompts up to 100K) for high-volume, narrowly scoped steps such as summaries, classification, and subagent work. Keep Sonnet 5.5 for multi-step agentic coding: Anthropic's own Terminal-Bench 4.0 numbers put it at 70.6% against Haiku 5.5's 39.2%.

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
• Claude Haiku 5.5 Developer Guide - the new small model, its 100K price cliff, and the Haiku 4.5 migration