Claude Haiku vs Sonnet vs Opus: Which Model Should You Use?

Anthropic ships three tiers of Claude models under the same family: Haiku, Sonnet, and Opus. The names signal the progression — a haiku is short and sharp, a sonnet is structured and balanced, an opus is long and complex. The models follow the same pattern.

Choosing the right one isn't just about capability — it's about matching the model to the task, the latency budget, and the cost. Here is how they actually differ.

The Quick Answer

If you are building a product and cost matters: Haiku for lightweight automation, Sonnet for the main loop, Opus only when Sonnet fails.

If you are an individual developer using Claude Code or the API for your own work: Sonnet is the right default. Upgrade to Opus for the tasks that genuinely need it.

Haiku: Fast, Cheap, Surprisingly Capable

Haiku is the smallest model in the family. "Small" is relative — it outperforms GPT-4-level models on many tasks — but compared to Sonnet and Opus it trades raw capability for dramatically lower latency and cost.

What it handles well:

• Classification and routing (is this message a support request or a billing question?)
• Summarisation of well-structured text
• Simple data extraction from a known format
• Autocomplete-style code suggestions in narrow contexts
• High-throughput pipelines where you're processing thousands of items

Where it struggles:

• Multi-step reasoning with many dependencies
• Ambiguous instructions that require inference
• Complex codebases where context spans many files
• Tasks that require extended thinking or backtracking

The practical use case for Haiku in a product is as a first-pass filter. Use Haiku to categorise, summarise, or route — then escalate to Sonnet or Opus only for the items that need more. This pattern can cut your API costs by 80% or more on high-volume applications without degrading the user-facing output.

import anthropic

client = anthropic.Anthropic()

# Haiku for fast, cheap classification
response = client.messages.create(
    model="claude-haiku-4-5-20251001",
    max_tokens=50,
    messages=[{"role": "user", "content": f"Classify this support ticket as billing, technical, or general: {ticket_text}"}]
)

Sonnet: The Developer's Default

Sonnet is the model most developers should reach for first. It hits a balance point that makes it the right choice for the majority of real-world tasks: fast enough for interactive use, capable enough to handle genuine complexity, and affordable enough to use generously.

Claude Code runs on Sonnet 4.6 by default. That is not an accident — Anthropic built the agentic coding workflow around Sonnet because it can hold large codebases in context, reason through multi-step problems, and handle edge cases without failing constantly.

What it handles well:

• Code generation and refactoring across multiple files
• Debugging with full stack trace context
• Writing and summarising technical documents
• API integrations where the request structure is moderately complex
• Agent loops that need to reason about tool results
• Most tasks you'd reach for Opus on — try Sonnet first

Sonnet also supports extended thinking, which lets it reason through harder problems by working through them step by step before answering. You don't get extended thinking with Haiku.

# Sonnet with extended thinking for a harder reasoning task
response = client.messages.create(
    model="claude-sonnet-4-6",
    max_tokens=16000,
    thinking={"type": "enabled", "budget_tokens": 10000},
    messages=[{"role": "user", "content": "Refactor this authentication module to support OAuth 2.0 and SAML simultaneously without breaking existing session handling..."}]
)

The honest answer for most developers: Sonnet handles 90% of what you need. Before upgrading to Opus, try Sonnet with extended thinking — it closes a lot of the gap.

Opus: When You Need the Best

Opus is Anthropic's most capable model. It reasons more thoroughly, handles more ambiguity, and produces better output on genuinely hard problems. It is also slower and more expensive.

The current model is Opus 4.7. It's what you use when Sonnet fails — not as the default.

What it handles well:

• Architecture decisions with many competing constraints
• Debugging obscure failures where the cause isn't obvious from the stack trace
• Writing that requires nuance, judgment, or sustained coherence over long outputs
• Tasks that require deeply reasoning about complex domain knowledge
• Agentic tasks where a mistake early in a long chain is expensive to recover from

Where the cost is justified: Opus costs roughly 5-6x more per token than Sonnet. For interactive use on a personal project, that difference is negligible — use Opus whenever you feel like it. For a product processing thousands of requests per day, it matters. Route to Opus only when the task genuinely needs it.

A pattern that works well in production: run every task through Sonnet, log tasks that Sonnet flagged as uncertain or produced low-confidence output on, and route those to Opus for a second pass.

# Opus for a hard architectural decision
response = client.messages.create(
    model="claude-opus-4-7",
    max_tokens=8000,
    thinking={"type": "enabled", "budget_tokens": 15000},
    messages=[{"role": "user", "content": "We need to migrate a 10-year-old Rails monolith to a microservices architecture without downtime. Current setup: Postgres, Sidekiq, 2M daily active users. What's the migration strategy?"}]
)

Picking by Use Case

Building a product:

• User-facing chat: Sonnet
• Background processing, summarisation, tagging: Haiku
• Critical decision paths, complex reasoning: Opus
• Cost-sensitive pipelines: Haiku first, escalate to Sonnet on low confidence

Using Claude Code:

• Default: Sonnet (this is what Claude Code uses)
• Hard debugging sessions: switch to Opus with /model claude-opus-4-7
• Fast mode (quick suggestions): Opus 4.6 with faster output via /fast

API experiments and personal projects:

• Start with Sonnet. It's good enough that many developers never need to go higher.
• Reach for Opus when you hit a wall, not before.

High-volume batch jobs:

• Haiku unless you genuinely need deeper reasoning. The speed difference and cost difference are both significant at scale.

The Context Window Is the Same

All three models share a 200K token context window. A common misconception is that Opus "sees more" — it doesn't. The difference is in how well the model reasons over what it sees, not how much it can see.

At 200K tokens you can fit roughly 150,000 words — the equivalent of a medium-sized novel, or a substantial codebase. All three models can work with full repositories in context.

Prompt Caching Works Across All Three

If you're hitting the API directly, enable prompt caching on any model. Repeated context — system prompts, codebase files, large documents — can be cached and served at 90% reduced cost. This matters most with Opus, where the baseline cost is highest, but the pattern applies to all three.

# Cache a large system prompt across all model tiers
messages_create = client.messages.create(
    model="claude-sonnet-4-6",
    system=[
        {
            "type": "text",
            "text": large_codebase_context,
            "cache_control": {"type": "ephemeral"}
        }
    ],
    messages=[{"role": "user", "content": user_question}]
)

The Short Version

Use Haiku when volume and speed matter more than depth. Use Sonnet for almost everything else — it is fast, capable, and the model Anthropic built their own developer tools around. Reach for Opus when Sonnet can't quite get there, not as a default. Treat them as a tiered system, not as three separate products you need to evaluate from scratch each time.