Developers building on the Anthropic API face the same decision on every new feature: Sonnet or Haiku? Sonnet 5 is exactly 2x more expensive than Haiku 4.5, but handles tasks Haiku cannot. Most teams hardcode one model and accept the tradeoff. The teams with the best cost-to-quality ratio use both and route each prompt to the right one automatically.
The Models
Claude Sonnet 5 and Haiku 4.5 are the two most-used Claude models in production. They serve different roles in the Anthropic lineup.
Sonnet 5 is the workhorse. It handles multi-step reasoning, code generation, complex analysis, and tasks that require holding multiple constraints in working memory. It supports adaptive thinking, takes a 1M-token context window, and emits up to 128K output tokens. Most teams treat Sonnet as their default model because it covers the widest range of use cases at acceptable cost.
Haiku 4.5 is the speed model. Anthropic rates it the fastest model in the lineup, and it costs a third of Sonnet. For classification, extraction, formatting, and routing decisions, Haiku produces equivalent results to Sonnet because these tasks don't exercise the reasoning capacity that separates the models. Two limits define where it stops: a 200K context window against Sonnet's 1M, and no adaptive thinking.
Opus 5 sits at the top of the lineup. It exists for problems that Sonnet gets wrong: novel problem solving, architecture decisions that require reasoning through many constraints simultaneously, and multi-file refactoring across tightly coupled systems. Most teams never route more than 5-10% of their prompts to Opus.
Think of the Claude models as a cost-quality ladder. Haiku covers the bottom 60% of tasks (simple, fast, cheap). Sonnet covers the next 30% (complex, balanced). Opus covers the top 10% (hardest problems only). Picking one model for everything means overpaying on easy tasks or underperforming on hard ones.
Haiku vs Sonnet: Pricing Comparison
Sonnet 5 costs exactly 2x Haiku 4.5 on both input and output. Opus 5 adds another 2.5x on top of Sonnet.
| Model | Input price | Output price | Context | Relative cost |
|---|---|---|---|---|
| Haiku 4.5 | $1.00 | $5.00 | 200K | 1x (baseline) |
| Sonnet 5 | $2.00 | $10.00 | 1M | 2x Haiku |
| Opus 5 | $5.00 | $25.00 | 1M | 5x Haiku / 2.5x Sonnet |
Sonnet 5's $2/$10 rate launched as introductory pricing through August 31, 2026 and is now the standard price. Anthropic has confirmed the scheduled increase to $3/$15 on September 1, 2026 will not happen. Source: Anthropic pricing documentation, August 2026.
For a concrete example: a coding agent session with 50 prompts averaging 2,000 input tokens and 1,000 output tokens each. Running everything on Sonnet costs $0.20 for input and $0.50 for output, totaling $0.70. The same session on Haiku costs $0.10 input and $0.25 output, totaling $0.35. That is a 50% reduction, but only if Haiku can handle every prompt without quality loss. It can't. Some prompts need Sonnet. The question is which ones.
When to Use Haiku
Haiku wins on tasks where the bottleneck is speed or cost, not reasoning depth. These tasks have clear inputs, well-defined outputs, and don't require the model to reason through multiple steps or hold complex state.
Classification
Sentiment analysis, intent detection, category assignment. Haiku classifies as accurately as Sonnet because these tasks depend on pattern matching, not reasoning chains.
Simple extraction
Pull a name, date, email, or phone number from text. Extract a JSON field from a document. Parse structured data from semi-structured input.
Routing decisions
Yes/no, pick-one, binary classification. 'Is this a support ticket or a sales inquiry?' Haiku answers these instantly at a fraction of Sonnet's cost.
Formatting and templating
Convert JSON to markdown. Apply a template to structured data. Reformat output for a different consumer. These are mechanical transformations, not reasoning tasks.
High-volume pipelines
Processing 10,000 documents per hour for metadata extraction. At $1/M input tokens, Haiku makes high-volume processing economically viable.
Latency-sensitive paths
User-facing responses where sub-second latency matters. Anthropic rates Haiku 4.5 the fastest model in the lineup and Sonnet 5 one tier below it, and that gap compounds across multi-turn interactions.
When to Use Sonnet
Sonnet is the right choice when the task requires the model to reason through multiple steps, hold context across a complex problem, or produce output where errors have real consequences.
Multi-step reasoning
Problems that require chaining 3+ logical steps. 'Read this code, understand the data flow, identify the race condition, and propose a fix.' Haiku loses coherence on chains this long.
Code generation and review
Writing functions, classes, or modules from a spec. Reviewing code for bugs, security issues, or architecture problems. Sonnet's code output is measurably more correct than Haiku's.
Complex analysis
Analyzing a codebase to understand architecture. Comparing multiple approaches with tradeoffs. Synthesizing information from multiple sources into a coherent recommendation.
Creative writing with nuance
Documentation that needs to be precise and clear. API descriptions. Technical blog posts. Sonnet produces more accurate, better-structured prose than Haiku on complex topics.
Error-expensive tasks
Any task where a wrong answer costs more than the price difference between models. A billing calculation, a security review, a database migration plan. Spend the extra tokens on Sonnet.
Long-context reasoning
Tasks that require attending to information spread across a large input. Haiku 4.5 caps at 200K tokens; Sonnet 5 takes 1M. Past 200K the choice is made for you.
When to Use Opus
Opus 5 costs 2.5x Sonnet 5 and 5x Haiku 4.5. It is not a default model for anything. It is the model you reach for when Sonnet fails or when the stakes justify both the cost and the wait: Anthropic rates Sonnet 5 fast and Opus 5 moderate, so you pay more and wait longer.
Novel problem solving
Problems the model hasn't seen patterns for. Unusual edge cases, domain-specific reasoning, or tasks that require genuine creative problem solving rather than pattern application.
Multi-file refactoring
Refactoring across 10+ tightly coupled files where changes in one file cascade to others. Opus holds the full dependency graph in working memory better than Sonnet.
Architecture design
Designing a system from scratch with multiple competing constraints: performance, cost, maintainability, security. Opus reasons through tradeoffs more thoroughly.
When Sonnet gets it wrong
The most practical trigger. If Sonnet produces an incorrect or shallow result, retry with Opus. This is cheaper than always using Opus and catches the cases where Sonnet's reasoning falls short.
The Real Question: Why Choose Manually?
A coding agent session might send 50 prompts. Roughly 30 are simple: add a comment, rename a variable, run a test, format output. About 15 are medium: write a function, fix a bug, refactor a method. And 5 are hard: design a system, debug a race condition, plan a migration.
Picking the model per-prompt manually is impractical. No developer wants to evaluate each prompt's complexity and switch models mid-session. The result is that most teams hardcode one model.
Hardcoding Sonnet wastes money. You pay 2x the Haiku price on 60% of prompts that Haiku would handle identically. For teams sending thousands of API calls per day, this adds up to significant unnecessary spend.
Hardcoding Haiku sacrifices quality. The 40% of prompts that need Sonnet's reasoning produce noticeably worse results. Code has more bugs. Analysis is shallower. Multi-step tasks lose coherence. The cost savings come at the expense of output quality on every non-trivial task.
This is what a model router solves: automatic per-prompt model selection based on task complexity.
Automatic Routing
A model router classifies each prompt by complexity and routes it to the appropriate Claude model. Classification runs in a few hundred milliseconds and costs a fraction of a cent per request.
| Complexity | Routed to | Example tasks |
|---|---|---|
| Easy | Haiku 4.5 | Add a comment, rename a variable, format output, simple extraction |
| Medium | Sonnet 5 | Write a function, fix a bug, refactor a method, code review |
| Hard | Sonnet 5 / Opus 5 | System design, race condition debugging, multi-file refactoring |
| Needs info | Asks for clarification | Ambiguous prompts where the right model depends on missing context |
Routers typically offer a balanced mode that optimizes for cost savings while preserving quality on medium and hard tasks, and an aggressive mode that routes more prompts to Haiku, maximizing savings at the risk of slightly lower quality on borderline medium-complexity tasks.
Cost Savings Breakdown
Take a typical 50-prompt coding agent session. Each prompt averages 2,000 input tokens and 1,000 output tokens.
| Strategy | Input cost | Output cost | Routing cost | Total |
|---|---|---|---|---|
| All Sonnet 5 | $0.20 | $0.50 | $0 | $0.70 |
| All Haiku 4.5 | $0.10 | $0.25 | $0 | $0.35 |
| Routed (balanced) | $0.14 | $0.35 | $0.05 | $0.54 |
The routed session costs $0.54 compared to $0.70 for all-Sonnet, a 23% reduction. The 30 easy prompts run on Haiku ($0.06 input + $0.15 output). The 15 medium prompts run on Sonnet ($0.06 input + $0.15 output). The 5 hard prompts run on Sonnet ($0.02 input + $0.05 output). Routing overhead adds $0.05.
The quality difference on the 30 easy prompts is zero: Haiku and Sonnet produce identical results for classification, formatting, and simple extraction. The quality on the 20 medium and hard prompts is preserved because they still run on Sonnet.
At scale, this matters. A team running 1,000 sessions per day saves $160/day or $4,800/month by switching from all-Sonnet to routed. The routing cost at that volume is $50/day, so weigh the router against a flat Haiku-first policy on the easy tier.
Frequently Asked Questions
What is the difference between Claude Sonnet and Claude Haiku?
Sonnet 5 is Anthropic's balanced model for complex tasks: multi-step reasoning, code generation, and analysis. It costs $2 input / $10 output per million tokens, supports adaptive thinking, and takes a 1M-token context window. Haiku 4.5 is the speed model for simple tasks: classification, extraction, formatting. It costs $1 input / $5 output per million tokens, caps at 200K context, and has no adaptive thinking. Sonnet is exactly 2x more expensive but handles tasks Haiku cannot.
When should I use Haiku instead of Sonnet?
Use Haiku for classification, simple extraction (pull a name from text), routing decisions (yes/no, pick-one), formatting and templating, high-volume low-complexity pipelines, and any task where latency matters more than reasoning depth. Haiku handles these at the same quality as Sonnet at 2x lower cost.
When should I use Sonnet instead of Haiku?
Use Sonnet for multi-step reasoning, code generation and review, complex analysis, creative writing that needs nuance, and any task where errors are expensive. Sonnet's additional reasoning capacity produces measurably better results on these tasks.
How much cheaper is Haiku than Sonnet?
Haiku is exactly 2x cheaper than Sonnet on both input and output tokens. For a 50-prompt coding agent session, all-Sonnet costs $0.70 and all-Haiku costs $0.35. Routing 60% of the prompts to Haiku brings it to $0.54, a 23% saving.
What is a model router and how does it help?
A model router classifies each prompt by complexity and routes it to the appropriate model automatically. Easy prompts go to Haiku. Medium prompts go to Sonnet. Hard prompts go to Sonnet or Opus. On a 50-prompt coding session that is a 23% saving against all-Sonnet, with no quality loss on complex tasks.
When should I use Claude Opus instead of Sonnet?
Use Opus for problems Sonnet gets wrong: novel problem solving, multi-file refactoring across tightly coupled codebases, and architecture decisions requiring many simultaneous constraints. Opus costs $15 input / $75 output per million tokens, which is 5x Sonnet. Most teams need Opus for fewer than 10% of their prompts.
Can I use both Sonnet and Haiku in the same application?
Yes. The most cost-effective approach uses both models with a router that picks per-prompt. In a typical coding agent session, 60% of prompts are simple (Haiku), 30% are medium (Sonnet), and 10% are hard (Sonnet/Opus). A model router automates this selection.