Claude Opus vs Sonnet vs Haiku: Which Model to Use When (2026)

Full decision matrix for Claude Opus 5.5, Sonnet 5, and Haiku 4.5 with real cost math, task-by-task recommendations, and how to switch models.

By Muhammad Moeed ·September 24, 2026 ·17 min read

Every new Claude user hits the same wall: which model should I actually use? Opus for everything? Sonnet for coding? Haiku for chat? The pricing gap is 8x from cheapest to most expensive, so the wrong choice quietly bleeds money for months.

This guide is a plain-language decision matrix for the three current Claude tiers as of September 24, 2026: Opus 5.5, Sonnet 5, and Haiku 4.5 (with a note on Fable 5.1 where it matters). You get: verified specs per model, a task-by-task recommendation table, real dollar math for 6 common scenarios, and copy-paste instructions to switch models in Claude Code, the Agent SDK, the raw API, Bedrock, and Vertex.

Written for beginners. Every jargon term has a plain definition below.

Quick answer

One-line per model:

Opus 5.5: frontier reasoning + tool use. Use for architecture, multi-step reasoning, computer use. $4 / $20 per million tokens.
Sonnet 5: the coding default. Anthropic’s own guidance: use Sonnet for most coding tasks. $2 / $10 per million tokens.
Haiku 4.5: fastest and cheapest. Great for simple subagents, classification, chat, mechanical edits. $1 / $5 per million tokens.
Fable 5.1 (for context): Anthropic’s ceiling model for hour-long autonomous work. Only reach for it after Opus 5.5 at max effort falls short. Roughly 2.5x Opus 5.5’s price.

Decision tree in one look:

Simple, high-volume, or latency-sensitive? → Haiku 4.5
Regular coding, feature work, document analysis? → Sonnet 5
Architecture, complex reasoning, computer use, or tough multi-step? → Opus 5.5
Multi-hour autonomous research beyond Opus 5.5’s ceiling? → Fable 5.1

Beginner glossary (skip if you know these)

Token: the unit Claude reads and writes text in. Roughly 3-4 characters or 0.75 words per token on older models. Claude 4.7 and later use a newer tokenizer that produces about 30% more tokens for the same English text.
MTok (million tokens): the unit prices are quoted in. A $4/MTok input price means you pay $4 for every million input tokens sent.
Context window: the maximum tokens (prompt + prior turns + tools + output) a single request can hold. Opus 5.5, Sonnet 5, and Fable 5.1 support 1M tokens without a beta header. Haiku 4.5 caps at 200K.
Max output: the longest single reply, separate from the context window. Opus 5.5, Sonnet 5, and Fable 5.1 top out at 128K output tokens. Haiku 4.5 caps at 64K.
Extended thinking (adaptive vs manual): reasoning tokens the model spends before answering. On Opus 5.5, Sonnet 5, and Fable 5.1 thinking is adaptive and on by default. On Haiku 4.5 it is manual only: you must set thinking.type=enabled with a budget_tokens value.
Effort parameter: a knob (low, medium, high, xhigh, max) that trades intelligence for latency and cost inside one model. Fable 5.1, Sonnet 5, and Opus 5.5 support it. Haiku 4.5 does not (use budget_tokens there).
Prompt caching (cache read): reusing an identical prefix across requests. Standard read multiplier is 0.1x input. Opus 5.5 reads at 0.05x (5% of input price). Fable 5.1 reads at 0.025x. Cache writes cost 1.25x (5-min) or 2x (1-hour) of base input.
Batch API: async requests returned within 24 hours at 50% off both input and output. Stacks with prompt caching.
Tool use / forced tool use: letting the model call your functions. On Opus 5.5 and Sonnet 5, tool_choice: {type: "any"} or {type: "tool"} returns 400. Use tool_choice: {type: "auto"} instead. See our Opus 5.5 migration guide for the fix.

The 3 current tiers, side by side

Spec	Opus 5.5	Sonnet 5	Haiku 4.5
Model ID (API)	`claude-opus-5-5`	`claude-sonnet-5`	`claude-haiku-4-5`
Model ID (Bedrock)	`anthropic.claude-opus-5-5`	`anthropic.claude-sonnet-5`	`anthropic.claude-haiku-4-5`
Released	Sept 22, 2026	June 30, 2026	2026
Status	Active (latest)	Active (latest)	Active (current)
Input price / MTok	$4	$2	$1
Output price / MTok	$20	$10	$5
Cache read / MTok	$0.20 (0.05x)	$0.20 (0.1x)	$0.10 (0.1x)
Context window	1M tokens	1M tokens	200K tokens
Max output	128K	128K	64K
Extended thinking	Adaptive, always on	Adaptive, on by default	Manual (set `budget_tokens`)
Effort parameter	Yes (default: medium)	Yes (default: high)	No
Retirement not sooner than	Sept 22, 2027	June 30, 2027	Not published

Notes:

Prices scale linearly across tiers. Opus 5.5 is 2x Sonnet 5. Sonnet 5 is 2x Haiku 4.5. So Opus is 4x Haiku on raw token price.
Real cost gap is larger than the spec sheet. Opus 5.5 defaults to medium effort. Sonnet 5 defaults to high. Haiku has no effort dial, so it just runs fast. If you leave all three at their defaults, Opus 5.5’s higher intelligence per token can partially close the price gap on complex tasks (see cost math below).
Cache read is where Opus 5.5 pulls ahead. At $0.20/MTok on a 0.05x multiplier, cached reads on Opus are the same price as cached reads on Sonnet, even though the base is 2x. If you build agents with big cached system prompts, this matters.

The decision matrix (by task type)

The pattern that keeps repeating in Anthropic’s own docs: default to Sonnet 5 for coding, reserve Opus 5.5 for architecture and multi-step reasoning, and use Haiku 4.5 for simple or high-volume work.

Task type	Pick	Why	Fallback
Simple code refactor (rename, extract, mechanical edit)	Haiku 4.5	Hits ~90% of Sonnet 4.5’s agentic coding score at 1/3 the price, runs 4-5x faster	Sonnet 5 if the refactor touches architectural boundaries
Everyday feature coding in Claude Code	Sonnet 5	Anthropic’s Claude Code doc: “Sonnet handles most coding tasks well and costs less than Opus”	Opus 5.5 for specific turns that need frontier reasoning
Multi-file architecture design, large refactor	Opus 5.5	”Reserve Opus for complex architectural decisions or multi-step reasoning”; 66.4% Terminal-Bench 4.0	Fable 5.1 if Opus at max effort still falls short
Multi-hour autonomous coding agent (Plan Mode)	Opus 5.5 planner + Sonnet 5 executor (the `opusplan` alias)	Built-in alias in Claude Code: Opus while planning, Sonnet for execution	Sonnet 5 solo if budget-tight; Fable 5.1 + Sonnet 5 workers for >1M-token corpora
High-volume classification, tagging, extraction	Haiku 4.5 + Batch API + prompt caching	$0.50/MTok Batch input, 88 tokens/sec, 0.63s time-to-first-token	Sonnet 5 Batch if accuracy on edge cases matters more than cost
Real-time chatbot / low-latency Q&A	Haiku 4.5	Fastest and cheapest current tier; 200K context is enough for most sessions	Sonnet 5 if answers must reason over long documents
Long-document analysis / RAG (fits in 1M)	Sonnet 5	Full 1M-token context at $2/$10 with adaptive thinking on by default	Opus 5.5 if the reasoning quality gap shows up in eval
Corpus larger than 1M tokens	Orchestrator: Fable 5.1 or Opus 5.5 coordinator + Sonnet 5 workers	Anthropic’s own multi-agent research system pattern uses a lead model over subagent workers; measured 90.2% improvement over single-agent on their internal research eval, at roughly 15x the tokens of a chat interaction	Chunk-and-summarize with Sonnet 5 solo if the fan-out is simple
Data analysis, tables, spreadsheet reasoning	Sonnet 5	Best speed-and-intelligence balance; 1M context handles large tabular dumps	Opus 5.5 for multi-step derivations or chart-heavy work
Computer use / browser automation	Opus 5.5	81.8% on OSWorld 2.0 (partial); `computer_toolset_20260801` is the current tool on Claude API and Vertex	Sonnet 5 for simpler flows. On Bedrock, legacy `computer_20251124` still works
Creative writing, long-form drafting	Opus 5.5	Adaptive thinking always on plus 128K max output covers most drafts	Fable 5.1 for genuinely demanding long-horizon output
Subagents that do one narrow task	Haiku 4.5	Anthropic’s Claude Code doc: “For simple subagent tasks, specify `model: haiku` in your subagent configuration”	Sonnet 5 for coordinator or teammate roles
Frontier research, hour-long agent sessions	Fable 5.1	Anthropic positions Fable 5.1 for the ceiling of long-horizon agentic work	Opus 5.5 at `xhigh` or `max` effort before reaching for Fable’s 2.5x premium

Real cost math (6 concrete scenarios)

Numbers below use the actual Sept 24, 2026 pricing. Assume prompt caching where it makes sense.

Scenario 1: Typical Claude Code coding session

Assume 500K input tokens (mostly cached), 40K output. Split: 450K served from 5-min cache, 50K fresh input, 40K output.

Model	Cache read	Fresh input	Output	Total
Opus 5.5	$0.09	$0.20	$0.80	$1.09
Sonnet 5	$0.09	$0.10	$0.40	$0.59
Haiku 4.5	$0.045	$0.05	$0.20	$0.295

Verdict: Sonnet 5 at ~half of Opus 5.5. Haiku 4.5 at ~1/4 of Opus 5.5. Anthropic’s own recommendation: default Sonnet, reserve Opus for architecture.

Scenario 2: Long reasoning task (200K fresh input, 20K output at high effort)

Model	Input	Output	Total
Opus 5.5	$0.80	$0.40	$1.20
Sonnet 5	$0.40	$0.20	$0.60
Haiku 4.5	$0.20	$0.10	$0.30 (but no effort dial)

Verdict: Opus 5.5 is worth the 2x premium here because it scored 66.4% on Terminal-Bench 4.0 and 67.7% on Humanity’s Last Exam. For simpler migrations, Sonnet 5 at high effort is usually enough.

Scenario 3: Batch classification job (10M input, 500K output, no cache, Batch API 50% off)

Model	Input	Output	Total
Opus 5.5 Batch	$20	$5	$25
Sonnet 5 Batch	$10	$2.50	$12.50
Haiku 4.5 Batch	$5	$1.25	$6.25

Verdict: Haiku 4.5 with Batch API is the right call. 4x cheaper than Opus and classification rarely needs frontier reasoning. Add prompt caching for the shared system prompt to save another 90% on the repeated prefix.

Scenario 4: Advisor pattern (Anthropic’s measured example)

Opus 5 executor with Fable 5.1 advisor consulted twice per task, on Anthropic’s internal agentic-coding benchmark.

Opus 5 alone: measured baseline
Opus 5 + Fable 5.1 advisor: $7.69 per attempt, +3.5 points over Opus 5 alone

Verdict: only pays off on serial work with occasional hard decisions, not single-turn Q&A. The advisor turns bought +3.5 points for roughly the same money.

Scenario 5: Orchestrator pattern for corpora larger than 1M tokens

For work that spans more than 1M tokens or fans out across many independent files or documents, no single model can fit the whole context. Anthropic’s published pattern (see the multi-agent research system post) uses a lead model as coordinator over subagent workers.

Lead model (Fable 5.1 or Opus 5.5): plans, delegates, integrates
Worker subagents (Sonnet 5 or Haiku 4.5): each takes one chunk and returns a summary
Anthropic-reported gain: their internal research system with Opus 4 lead over Sonnet 4 subagents scored 90.2% higher than a single-agent Opus 4 on their internal research evaluation. Anthropic’s own note: the same pattern used about 15x more tokens than a chat interaction.

Concrete cost implication: 15x tokens is expensive. Orchestrator pays off only when a single-model call would fail entirely (context overflow) or when the quality gap justifies the extra tokens.

Verdict: orchestrator only pays off when the work fans out across independent files or documents and exceeds one context window, OR when a single model at max effort still misses the quality bar. If everything fits in 1M tokens and is one dependent chain, a single Opus 5.5 or Fable 5.1 call wins.

Scenario 6: Enterprise average (Anthropic-reported baseline)

Sonnet 5 as default: $13 per developer per active day, $150-$250 per developer per month, 90% of users under $30/day
Leaving Opus as default: Anthropic’s #1 cited cause of unexpectedly high spend

Verdict: default Sonnet 5, reserve Opus 5.5 for architecture and multi-step reasoning, use model: haiku for simple subagents. That is Anthropic’s own recommended pattern for keeping the monthly bill predictable.

How to switch models on every surface

Claude Code CLI

In-session:

/model opus         # or sonnet, haiku, fable
/model opusplan     # Opus for planning, Sonnet for execution
/model sonnet[1m]   # Sonnet 5 with 1M context
/model default      # back to the account default

At launch:

claude --model claude-opus-5-5

Persist across sessions:

// ~/.claude/settings.json or .claude/settings.json
{
  "model": "claude-opus-5-5"
}

Environment variables (precedence order, high to low):

export ANTHROPIC_MODEL=claude-opus-5-5           # hard override, session-wide
export ANTHROPIC_DEFAULT_MODEL=claude-sonnet-5   # soft default for new sessions
export ANTHROPIC_DEFAULT_OPUS_MODEL=claude-opus-5   # pin the "opus" alias to Opus 5
export ANTHROPIC_DEFAULT_SONNET_MODEL=claude-sonnet-5
export ANTHROPIC_DEFAULT_HAIKU_MODEL=claude-haiku-4-5

Full precedence chain: /model command > --model flag > ANTHROPIC_MODEL env var > settings.json model field > ANTHROPIC_DEFAULT_MODEL env var > org default > runtime default.

Claude Agent SDK

from claude_agent_sdk import query

async for message in query(
    prompt="Refactor this function.",
    options={
        "model": "claude-opus-5-5",
        "fallbackModel": "claude-sonnet-5",  # if Opus is rate-limited
    },
):
    print(message)

Per-subagent override in .claude/agents/*.md:

---
name: test-runner
description: Runs the test suite and reports failures
model: claude-haiku-4-5
---

Or set a default for subagents that do not specify one:

export CLAUDE_CODE_SUBAGENT_MODEL=claude-haiku-4-5

Raw Anthropic API

import anthropic
client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-5-5",   # required, top-level
    max_tokens=4096,
    messages=[{"role": "user", "content": "Hello."}],
)

The model parameter is authoritative per request. There is no env var override for the raw Messages API itself.

Amazon Bedrock

Newer models (Fable 5.1, Opus 5.5, Sonnet 5, Opus 4.8, Opus 4.7) use the “Claude in Amazon Bedrock” integration with the Messages API shape at /anthropic/v1/messages.

Older models use the legacy InvokeModel or Converse API with anthropic.claude-* IDs and an inference-profile prefix like global. or us.:

import boto3
bedrock = boto3.client("bedrock-runtime", region_name="us-east-1")

response = bedrock.invoke_model(
    modelId="global.anthropic.claude-opus-4-6-v1",
    body='{"anthropic_version": "bedrock-2023-05-31", "messages": [...], "max_tokens": 1024}',
)

Google Cloud Vertex

from anthropic import AnthropicVertex

client = AnthropicVertex(project_id="my-gcp-project", region="global")

response = client.messages.create(
    model="claude-opus-5-5",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Hello."}],
)

Model goes in the URL path, not the body. The body must include "anthropic_version": "vertex-2023-10-16". Auth is GCP Application Default Credentials. Region global is recommended (regional endpoints add a 10% premium).

Rate limits per model on subscription plans (honest note)

Every Claude plan (Free, Pro, Max 5x, Max 20x, Team, Enterprise) uses a rolling 5-hour session window as its base limit. Paid plans add weekly limits on top. All four current models (Fable 5.1, Opus 5.5, Sonnet 5, Haiku 4.5) are available on every paid plan.

Important: Anthropic does not publish a fixed per-model hour count on claude.com/pricing or the support articles reviewed on Sept 24, 2026. Actual capacity varies with conversation length, model choice, extended thinking, and tool use. Treat any specific “you get X hours of Opus per week on Pro” number circulating on Reddit or blogs as unverified.

For a concrete take on how the September 14 weekly-limit cut and the September 22 rate-limit expansion interact, see our weekly-limit survival guide.

FAQs

Is Claude Opus better than Sonnet for coding?

Not for most coding tasks. Anthropic’s own Claude Code documentation says: “Sonnet handles most coding tasks well and costs less than Opus. Reserve Opus for complex architectural decisions or multi-step reasoning.” The one place Opus wins is deep architectural work, multi-file refactors that need whole-codebase context, and computer use.

Is Claude Haiku good for coding?

For simple, mechanical tasks: yes. Haiku 4.5 hits about 90% of Sonnet 4.5’s agentic coding score at one third the price and runs 4-5x faster. Use it for renames, extractions, single-file edits, and subagents that do one narrow thing. Not recommended for architecture or work that spans several files with shared context.

How much does Claude Opus cost per token?

Opus 5.5 (the current version): $4 per million input tokens, $20 per million output tokens. Cache reads are $0.20 per million (0.05x input, an exception to the standard 0.1x). Batch API is 50% off: $2 in, $10 out.

What is the cheapest Claude model for API?

Haiku 4.5 at $1 input, $5 output per million tokens. With Batch API and prompt caching stacked, cached input drops to $0.05 per million (0.1x of Batch input). That is under 5 cents per million tokens on repeat prefixes.

Which Claude model is best for creative writing?

Opus 5.5 for most long-form drafting. Adaptive thinking is always on, and the 128K max output handles novellas, long essays, and detailed reports. Reach for Fable 5.1 only when Opus at max effort still falls short and you can absorb the 2.5x price premium.

Claude Haiku vs Sonnet cost: which is cheaper?

Haiku 4.5 is 2x cheaper than Sonnet 5 on both input ($1 vs $2 per MTok) and output ($5 vs $10). Cache reads are also 2x cheaper ($0.10 vs $0.20 per MTok). The tradeoff: Haiku has no adaptive thinking (manual budget_tokens only), no effort dial, and a smaller 200K context window vs Sonnet 5’s 1M.

Claude Sonnet vs Opus: which is faster?

Sonnet 5 is faster on wall-clock for most tasks. Opus 5.5 spends more time in adaptive thinking by default (default effort medium, but response quality reflects deeper reasoning). Haiku 4.5 is the fastest of the three at 88 tokens/sec and 0.63s time-to-first-token.

When should you use Opus in Claude Code?

Three specific cases: (1) multi-file architecture or design decisions, (2) complex debugging that needs multi-step reasoning across the whole codebase, (3) computer use with the new computer_toolset_20260801 on Claude API or Vertex. Anthropic’s recommended pattern is the opusplan alias: Opus in Plan Mode, Sonnet for execution.

Is Claude Opus 5 better than Sonnet 5?

Depends on the task. Opus 5 (the previous frontier) still outperforms Sonnet 5 on the hardest reasoning benchmarks. Opus 5.5 (current) is cheaper and better than Opus 5 on most tasks. For coding day-to-day, Sonnet 5 wins on price/quality ratio. For architecture and computer use, Opus 5.5.

Can I run Haiku 4.5 in Claude Code as the main model?

Yes. Set /model haiku in a session, or add {"model": "claude-haiku-4-5"} to ~/.claude/settings.json. It works well for exploratory or high-volume repos where most work is mechanical, and for subagents. For architecture-heavy work, stay on Sonnet 5 or Opus 5.5 as the main model and delegate mechanical tasks to Haiku via subagents.

What we still do not know

Exact per-model rate limits on each subscription plan. Anthropic publishes tier multipliers but not per-model hour counts. Treat unverified numbers from Reddit or blogs with skepticism.
Fable 5.1’s stated benchmark ceiling relative to Opus 5.5 at max effort. Anthropic positions Fable 5.1 as the frontier, but published head-to-head numbers on the same benchmark tables are limited.
When Haiku 5 might ship. No release date has been announced as of Sept 24, 2026. Haiku 4.5 remains the current small-tier model.

Where to go next

Claude Opus 5.5 Migration Guide: the four breaking changes you hit when switching Opus 5 code to Opus 5.5.
Claude Code Weekly Limit Cut Sept 14: how the September 14 cut and September 22 rate-limit expansion interact per plan.
Claude Agent SDK Credit Pool: the billing side of the model-choice decision when running long jobs.
Claude Code Skills vs MCP vs Hooks vs Plugins: where the model-selection choice sits alongside the other Claude Code primitives.
Claude Code Slow Fix: if Opus feels slow, try Sonnet before you upgrade the plan.

Last updated: September 24, 2026. I will re-check this page when Anthropic publishes per-model rate-limit numbers, when Haiku 5 ships, or when the next Sonnet or Opus point release changes the defaults.