Claude Sonnet 5: A Practical Guide

TL;DR

• The Claude Sonnet 5 generation has two models: Claude Sonnet 5 (claude-sonnet-5), released June 30, 2026 and now legacy, and Claude Sonnet 5.5 (claude-sonnet-5-5), released September 28, 2026 and Anthropic’s current Sonnet.
• Both cost $2 per million input tokens and $10 per million output tokens, with a 1M-token context window and 128K max output; Sonnet 5.5 halves cache reads to $0.10.
• Anthropic reports Sonnet 5.5 at 70.6% on Terminal-Bench 4.0 (Sonnet 5: 10.3%) and says it runs 30%+ faster and costs up to 30% less per task than Sonnet 5.
• Moving from Sonnet 5 to Sonnet 5.5 is not a pure model-ID swap: thinking: disabled and forced tool use now return 400 errors, and computer use needs the new toolset on the Claude API and Google Cloud.
• In Claude Code, sonnet resolves to Sonnet 5.5 only on the Anthropic API; Bedrock and Google Cloud users must pin it explicitly.

Claude Sonnet 5 is Anthropic’s mid-tier model generation, priced at $2 per million input tokens and $10 per million output tokens and built for coding, agents, and everyday knowledge work. The generation now has two releases: Claude Sonnet 5, launched June 30, 2026, and Claude Sonnet 5.5, launched September 28, 2026, which replaced it as the current Sonnet. This guide covers what each version is, what it costs, how to call it, when to pick it over Opus 5.5 or Haiku 5.5, how to use it in Claude Code, what breaks when migrating, and how to run it behind a gateway.

What Claude Sonnet 5 Is

Claude Sonnet 5 is the fifth-generation Sonnet model from Anthropic and the first in a two-model Sonnet 5 line. Sonnet 5 shipped on June 30, 2026, as “the most agentic Sonnet model yet”; Sonnet 5.5 followed on September 28, 2026, as the second model in the Claude 5.5 family. Both keep Sonnet’s role: near-flagship capability at a mid-tier price.

Anthropic’s Sonnet 5 launch post describes a model that can plan, use browsers and terminals, and run autonomously at a level that previously needed larger models. It also says its performance is close to that of Opus 4.8 at lower prices. At launch it became the default model for Free and Pro plans in the Claude apps.

Three months later, Anthropic introduced Sonnet 5.5 as the second model in the Claude 5.5 family and called it “a clear upgrade over Claude Sonnet 5” that “runs 30%+ faster, and costs up to 30% less for most work.” Anthropic’s developer docs now mark the older model as legacy: the Sonnet 5 model page says that “although Claude Sonnet 5 is still available, you should consider migrating to Claude Sonnet 5.5.”

Above Sonnet sit Claude Opus 5.5 ($4/$20) and Claude Fable 5.1 ($10/$50); below it, Claude Haiku 5.5, released October 7, 2026.

Claude Sonnet 5 Release Date and Timeline

Claude Sonnet 5 was released on June 30, 2026, at introductory pricing of $2/$10 per million tokens that Anthropic made permanent on August 10. Claude Sonnet 5.5 was released on September 28, 2026, six days after Opus 5.5, and its cache-read price was cut to $0.10 on October 7.

Figure 1: Four dates define the Sonnet 5 generation, and the price never moved off $2/$10.

The milestones in Figure 1 come from Anthropic’s posts and API release notes, which record that Anthropic lowered the price of prompt cache reads on Claude Sonnet 5.5 on October 7:

The pricing change is worth knowing because older articles still quote $3/$15 for Sonnet 5. The Sonnet 5 post’s changelog records that its introductory pricing of $2 per million input tokens and $10 per million output tokens is now permanent, and a footnote on Anthropic’s pricing page confirms that the planned $3/$15 increase “will not occur.” Teams still on Sonnet 4.5 have a firmer deadline: Anthropic announced its deprecation with retirement on the Claude API on November 30, 2026.

Claude Sonnet 5 Specs: Context Window, Output, and Thinking

Both Sonnet 5 models have a 1M-token context window billed at standard rates, 128K max output on the synchronous Messages API, 300K output on the Batch API with a beta header, text and image input, and adaptive thinking with high as the default API effort. Sonnet 5.5 adds per-message effort, a lower cache minimum, and a newer knowledge cutoff.

Four details change how code is written for these models:

• Sampling parameters are fixed. On Sonnet 5.5, setting temperature, top_p, or top_k to a non-default value returns a 400 error. The same rule applies to Sonnet 5.
• The tokenizer is newer. Sonnet 5 introduced a tokenizer that, per Anthropic’s footnote, means the same input can map to more tokens: about 1.0 to 1.35 times Sonnet 4.6’s count. Sonnet 5.5 uses the same tokenizer as Sonnet 5.
• Thinking counts toward max_tokens. The effort guide says that for agentic coding, set max_tokens to 128,000, the model’s maximum, and stream the response.

What Sonnet 5.5 Is Good For

Sonnet 5.5 is built for well-scoped, repeatable work: everyday coding, bug fixes, code review, agent tasks with a clear goal, computer use, and documents and slides. Anthropic’s benchmarks put it close to Opus 5.5 on most tests, but the company still recommends Opus for open-ended work that needs sustained judgment.

Anthropic frames the split directly. Its announcement says Sonnet 5.5 is strongest at well-scoped everyday tasks, fixing bugs, and creating polished documents, slides, and spreadsheets, while noting that Opus 5.5 remains clearly stronger at complex, open-ended work. AWS’s launch post for Bedrock lists alert response, SQL generation, UI testing, and fast coding agents in the IDE with a fixed spend cap as fits.

Anthropic’s published results, all from its own runs:

Independent numbers are lower but tell the same story. Vals’ Terminal-Bench 4.0 run, covered in this site’s ranking of the best AI models for coding, puts Sonnet 5.5 at 64.14% against Opus 5.5’s 65.15%, a statistical near-tie. The site’s broader list of top AI models ranks Sonnet 5.5 second overall on the Artificial Analysis Intelligence Index.

For computer use, OSWorld 2.1 puts Sonnet 5.5 within two points of Opus 5.5. On the Claude API and Google Cloud, it supports computer use only through the computer_toolset_20260801 toolset; Bedrock still accepts the older computer_20251124 tool. Long-horizon agents that must decide what to do next are where Opus 5.5 earns its higher price.

Sonnet 5.5 is also the first Sonnet to launch with cyber safeguards like those on Opus. Per the announcement, higher-risk cybersecurity tasks will visibly fall back to Sonnet 5, while routine bug finding and fixing are unaffected.

Claude Sonnet 5 Pricing and Cost Control

Claude Sonnet 5 pricing is $2 per million input tokens and $10 per million output tokens for both Sonnet 5 and Sonnet 5.5, with 50% off on the Batch API. Cache writes cost $2.50 (5-minute) or $4 (1-hour); cache reads cost $0.10 on Sonnet 5.5 and $0.20 on Sonnet 5. US-only inference adds 10%.

The current rates, per million tokens, come from Anthropic’s pricing page, where the Batch API carries a 50% discount on both input and output tokens:

Two modifiers sit on top. Requests pinned to the US with inference_geo: "us" carry a 1.1x pricing multiplier on Claude 4.6 and later models, and Haiku 5.5 moves to $0.50/$2.50 once a prompt passes 100,000 tokens.

As an illustration, take an agent call with 50,000 input tokens, of which 40,000 are a cached prefix, and 5,000 output tokens including thinking (assumed figures, cache-write cost ignored):

Output dominates, which is why the levers that matter most are the ones that reduce output tokens:

• Tune effort before switching models. Anthropic’s model selection guide says “tuning effort is often a better lever than switching models.” For agentic coding on Sonnet 5.5, it suggests starting at medium for well-specified tasks.
• Re-run the effort sweep. On Sonnet 5.5, effort levels are recalibrated, so a medium setting carried over from Sonnet 5 does not produce the same amount of thinking.
• Cache the prefix. Sonnet 5.5’s minimum cacheable prompt length is 512 tokens, half of Sonnet 5’s, and a hit costs 5% of base input.
• Batch what can wait. Evaluation runs, backfills, and nightly document jobs cost half on the Batch API.
• Route simple traffic down. Classification and extraction often pass quality checks on Haiku 5.5 at a twentieth of Sonnet’s per-token price.

This site’s explainer on what drives AI inference cost works through a full agent cost model on Sonnet 5.5, and a separate comparison covers AI gateways with prompt caching support.

Calling the Claude Sonnet 5 API

The Claude Sonnet 5 API uses Anthropic’s Messages endpoint with model ID claude-sonnet-5-5 (or claude-sonnet-5 for the legacy model). Effort is set with output_config.effort, thinking is adaptive by default, and the same model IDs work on Google Cloud, Microsoft Foundry, and Claude Platform on AWS.

A minimal Python request at medium effort:

import anthropic

client = anthropic.Anthropic()  # reads ANTHROPIC_API_KEY

response = client.messages.create(
    model="claude-sonnet-5-5",
    max_tokens=16000,
    output_config={"effort": "medium"},
    messages=[{"role": "user", "content": "Write a failing test for the date parser bug in utils/dates.py"}],
)

for block in response.content:
    if block.type == "text":
        print(block.text)

To run without up-front thinking, for example in a latency-sensitive tool loop, add thinking={"type": "between_tools"}. Anthropic’s What’s new page calls it the lowest thinking setting on this model; it works at low, medium, and high effort and returns a 400 error at xhigh or max.

Model IDs by platform:

On AWS, Sonnet 5.5 is available today on Amazon Bedrock through the Global CRIS inference profile. Google Cloud describes the model as built for coding, agents, and professional work at scale, and its model page lists a 1,000,000-token input limit, 128,000 output tokens, Provisioned Throughput support, and a global-endpoint quota of 2,500 queries per minute. Anthropic’s Sonnet 5.5 system card covers the safety evaluations.

Sonnet 5.5 vs Opus 5.5 vs Haiku 5.5

Pick Sonnet 5.5 for well-defined coding, agent, and document work where speed and cost matter; Opus 5.5 for long-running, open-ended work and planning; and Haiku 5.5 for high-volume classification, extraction, routing, and sub-agent calls. All three share a 1M context window and 128K output, so the decision is about judgment, latency, and price.

Figure 2: Most teams end up running all three, with the scope of the task deciding which one serves it.

Anthropic’s own default differs from what many teams pick. The models overview says to start with Claude Opus 5.5 for most workloads, and Claude Code defaults to Opus 5.5. Launch customers describe a pairing instead: Opus 5.5 plans, Sonnet 5.5 implements. Detail on the Opus side, including its own breaking changes, is in this site’s guide to Claude Opus 5.5.

Using Claude Sonnet 5.5 in Claude Code

In Claude Code, run /model sonnet or start with claude --model sonnet to use Sonnet 5.5 on the Anthropic API. It needs Claude Code v2.1.284 or later, defaults to medium effort, and cannot have thinking turned off. On Bedrock and Google Cloud, the sonnet alias still points to Sonnet 4.5 unless pinned.

Claude Code’s model configuration docs say the sonnet alias uses the latest Sonnet model for daily coding tasks, and note that Sonnet 5.5 requires Claude Code v2.1.284 or later. The settings that matter:

• Provider differences. The aliases resolve to the newest version on the Anthropic API and to an earlier version on some other providers. On Bedrock and Google Cloud’s Agent Platform, sonnet resolves to Sonnet 4.5; on Claude Platform on AWS, to Sonnet 4.6. Set ANTHROPIC_DEFAULT_SONNET_MODEL to the provider’s Sonnet 5.5 ID to fix it.
• Plan with Opus, execute with Sonnet. The opusplan alias is a special mode that uses opus during plan mode, then switches to sonnet for execution, which matches the pairing Anthropic recommends.
• Effort. Claude Code defaults Sonnet 5.5 to medium (the API defaults to high). /effort changes it per session.
• Safety fallback. On a Sonnet 5.5 session, cybersecurity-flagged requests re-run on Sonnet 5; biology-flagged requests end in a refusal. Outside the Anthropic API, the fallback needs a resolvable Sonnet 5 entry or a ANTHROPIC_DEFAULT_SONNET_MODEL pin.
• Access control. Administrators can restrict which models developers pick with availableModels in managed settings, for example ["sonnet", "haiku"].

For how Claude Code compares with OpenAI’s agent, see the Claude Code vs Codex comparison; for plan quotas, see the guide to Claude usage limits.

Teams that want per-developer spend tracking can read a walkthrough of a Claude Code gateway covering routing, governance, and cost control, and a comparison of Claude Code cost management tools.

Migrating From Sonnet 5 to Sonnet 5.5

Migrating from Sonnet 5 to Sonnet 5.5 starts with the model ID, then six checks: replace thinking: disabled with between_tools, replace forced tool use, keep conversations append-only, move computer use to the new toolset, update advisor pairings, and handle progress text that now arrives in thinking blocks. Prices are unchanged.

Anthropic’s model page states that five breaking changes affect code already running on Claude Sonnet 5, plus one change to response shape. The checklist:

1. Swap disabled for between_tools. A request with thinking: {"type": "disabled"} returns a 400 invalid_request_error. Use between_tools at high effort or below.
2. Replace forced tool use. tool_choice of type any or tool returns a 400 error. For schema-valid tool input, Anthropic recommends tool_choice: auto with strict tool use, or structured outputs.
3. Keep history append-only. The API checks whether the system prompt, tools, or earlier messages changed since a Sonnet 5.5 thinking block was produced; on accounts created on or after August 31, 2026, a replay after such an edit returns a 400 error. Anthropic’s advice is to keep the conversation append-only so the check never fails and use mid-conversation system messages for changes.
4. Move computer use to the toolset. On the Claude API and Google Cloud, replace computer_20251124 with computer_toolset_20260801.
5. Check advisor pairings. The advisor tool rejects Opus 4.8, Opus 4.7, Sonnet 5, and Haiku 5.5 as advisors to a Sonnet 5.5 executor.
6. Restore progress text. Notes between tool calls now come back as thinking blocks with empty text at the default display setting, so a UI that streamed them goes quiet. Set thinking.display, or use between_tools.

Two smaller changes affect multi-model and multi-account setups. Thinking blocks that Claude Sonnet 5.5 produces work only in the account that produced them, or a linked account; blocks from another account are dropped silently. Sonnet 5.5 also reads Sonnet 5’s thinking blocks, so conversations moved up from Sonnet 5 keep their reasoning.

From Sonnet 4.x, the Sonnet 5 changes also apply: no manual budget_tokens thinking, no sampling parameters, and a tokenizer that counts more tokens.

Running Sonnet 5.5 Through an AI Gateway

An AI gateway puts one endpoint in front of Sonnet 5.5 on several platforms, so teams can split traffic between the Claude API, Bedrock, and Google Cloud, fail over when one returns errors, and enforce budgets per team. Options include Anthropic’s Claude apps gateway, LiteLLM, Cloudflare AI Gateway, and Bifrost.

Claude Code’s documentation lists what a gateway provides: credentials kept server-side, usage attribution, budgets and rate limits, audit logging, and provider switching. It also warns that a gateway that does not forward new request fields breaks the corresponding features, which matters for a model with new parameters such as between_tools. The main approaches:

• Cloud-native routing. Bedrock’s global inference profile and Google Cloud’s global endpoint spread traffic within one cloud, under that cloud’s IAM and billing.
• Anthropic’s Claude apps gateway. For Claude Code specifically, Claude apps gateway is a self-hosted service that sits between your developers and Bedrock, Claude Platform on AWS, Google Cloud, or Foundry, with SSO sign-in and per-group model access.
• LiteLLM. The open-source proxy handles failover through model groups (fallbacks are how LiteLLM does automatic failover) and documents setting team budgets.
• Cloudflare AI Gateway. A managed option that lets teams gain visibility and control over your AI apps with analytics, caching, rate limiting, retries, and model fallback.

This site compared these and other options in its review of AI gateways for Anthropic, OpenAI, and Gemini and in Claude Code gateways.

Worked example: Sonnet 5.5 on Bifrost

Bifrost, an open-source AI gateway written in Go by Maxim AI, is used here because its documentation covers the three platform paths for Claude as separate providers and documents fallbacks and budgets per virtual key. It routes to 25+ providers and 10,000+ models through one OpenAI-compatible API, and its published benchmark reports 11 µs of added overhead per request at 5,000 RPS on an AWS t3.xlarge, listed on the t3.xlarge page as Total Overhead: 11 µs.

Figure 3: The application asks for Sonnet 5.5 once; the gateway decides which platform serves it, what it may spend, and where it goes when a platform fails.

The setup in Figure 3 has three parts:

1. Weighted platforms on a virtual key. A virtual key lists the anthropic and vertex providers with claude-sonnet-5-5 allowed on each. Each provider can be assigned a weight, and requests are distributed proportionally, which spreads load across two rate-limit pools.
2. Budgets at several levels. Budgets attach to the virtual key and to each provider config, with reset windows such as 1M. Each budget must have sufficient remaining balance for the request to proceed.
3. A fallback chain. The request names fallbacks; fallbacks provide automatic failover to a different provider when the primary fails, here to Sonnet 5.5 on Bedrock (through a provider alias that maps claude-sonnet-5-5 to the global inference profile) and then to Haiku 5.5.

The virtual key’s provider configuration:

{
  "provider_configs": [
    { "provider": "anthropic", "allowed_models": ["claude-sonnet-5-5"], "key_ids": ["*"], "weight": 0.6,
      "budgets": [{ "max_limit": 3000.00, "reset_duration": "1M" }] },
    { "provider": "vertex", "allowed_models": ["claude-sonnet-5-5"], "key_ids": ["*"], "weight": 0.4,
      "budgets": [{ "max_limit": 2000.00, "reset_duration": "1M" }] }
  ],
  "budgets": [{ "max_limit": 5000.00, "reset_duration": "1M" }]
}

And a request through the gateway’s OpenAI-compatible endpoint:

curl -X POST http://localhost:8080/v1/chat/completions \
  -H "x-bf-vk: vk-eng-sonnet" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-5-5",
    "messages": [{"role": "user", "content": "Review this diff for missing error handling."}],
    "fallbacks": ["bedrock/claude-sonnet-5-5", "anthropic/claude-haiku-5-5"]
  }'

Applications built on the Anthropic SDK keep their code and update the base_url to point to Bifrost, and Bifrost automatically manages Anthropic beta headers per provider.

For Claude Code, Claude Code uses the /anthropic path with a virtual key in ANTHROPIC_AUTH_TOKEN. Routing rules can go further and send requests by header or team, for example Opus 5.5 for one group and Sonnet 5.5 for the rest.

One Anthropic rule applies to any gateway that moves a conversation between platforms: because Sonnet 5.5 thinking blocks are bound to the account that produced them, a multi-turn conversation that fails over mid-session continues without earlier reasoning. Per-request failover, as in the example above, is the clean case.

Setup guides: Bifrost’s Anthropic provider guide, the walkthrough on integrating Claude Code with the Bifrost gateway, and the guide to routing Claude Code through AWS Bedrock.

Design background: enabling automatic fallback when a primary provider fails, a comparison of enterprise LLM gateways for cost control and failover, and the Claude Code resource page.

What the Sonnet 5 Generation Means for Teams

The Claude Sonnet 5 generation moved Sonnet from a cheaper fallback to a near-peer of Opus on coding and computer use. Sonnet 5 made $2/$10 the Sonnet price; Sonnet 5.5 kept that price, halved cache reads, and closed most of the benchmark gap with Opus 5.5.

For teams still on Sonnet 5, the upgrade is worth doing now: the price is the same, Anthropic reports fewer tokens per task, and Sonnet 5 is already legacy. The work is in the six migration checks, especially between_tools, forced tool use, and append-only history. For teams on Sonnet 4.5, the November 30 retirement sets the schedule. For teams choosing between tiers, the practical split is Opus 5.5 for planning and hard problems, Sonnet 5.5 for well-scoped execution, and Haiku 5.5 for volume, with effort tuned per workload before any model switch.

A Sonnet price change or a Claude 6 generation would reset this picture. Until then, Claude Sonnet 5.5 is the default choice for everyday Anthropic workloads where Opus-level judgment is not required.