Claude Haiku 4.5: When to Use It Over Sonnet 4.6

When Anthropic released Claude Haiku 4.5 in October 2025, the usual reaction was "nice, a cheaper model." That framing misses what matters. Haiku 4.5 scores 73.3% on SWE-bench Verified — inside the range of models that cost three times more — and it's the first Haiku to support extended thinking and computer use. On certain agentic tasks, it outperforms Claude Sonnet 4.

This isn't about picking the budget option. It's about routing the right work to the right model. Get this right, and you can cut your Anthropic API bill by 60–90% without touching output quality for most tasks. Get it wrong, and you'll either overpay for simple work or underpay your way to degraded results.

This guide lays out the mechanics: what Haiku 4.5 actually does, where it's genuinely better than Sonnet 4.6, where it isn't, and how to structure pipelines that use both.

What Changed in Haiku 4.5

Haiku 4.5 (claude-haiku-4-5-20251001) isn't just a speed-tuned version of an older Haiku. Three things differentiate it from prior releases in the family.

Extended thinking is now on Haiku. Before Haiku 4.5, extended thinking was exclusive to Sonnet and Opus. Haiku 4.5 is the first compact model to support it, including thinking summarization, interleaved thinking (reasoning and tool use alternating), and budget control so you can cap thinking tokens per request. You can enable it for complex subtasks in a pipeline without escalating to a more expensive model.

Computer use support matches the larger models. Haiku 4.5 supports the full computer use tool suite — screenshot, click, type, scroll. According to Anthropic's own benchmarks, it outperforms Claude Sonnet 4 on computer use tasks. This makes it viable for UI automation workflows that previously needed Sonnet.

The specification baseline is the same as larger models. Haiku 4.5 has a 200K context window and up to 64K output tokens — identical to Sonnet 4.6. That removes one of the historical reasons to avoid Haiku on longer-context tasks.

Core Specifications and Pricing

Specification	Haiku 4.5	Sonnet 4.6
Model ID	claude-haiku-4-5-20251001	claude-sonnet-4-6-20251001
Input price (standard)	$1.00 / 1M tokens	$3.00 / 1M tokens
Output price (standard)	$5.00 / 1M tokens	$15.00 / 1M tokens
Cached input price	~$0.10 / 1M tokens	~$0.30 / 1M tokens
Batch input price	$0.50 / 1M tokens	$1.50 / 1M tokens
Output speed	~91 tokens/second	~45 tokens/second
Time to first token	~0.74s	~1.5s
Context window	200,000 tokens	200,000 tokens
Max output	64,000 tokens	64,000 tokens
SWE-bench Verified	73.3%	[DATA NOT AVAILABLE — varies by evaluation]
Extended thinking	Yes	Yes
Computer use	Yes	Yes
Best for	Sub-agents, high-volume, real-time	Complex reasoning, long builds

Haiku 4.5 is available through the Anthropic API, Amazon Bedrock, Google Vertex AI, and Azure AI. Pricing is consistent across providers, though Bedrock and Vertex may have separate token rate cards — check your specific cloud provider's documentation.

The Cost Math: Why This Model Matters at Scale

The raw per-token prices make Haiku 4.5 look 3x cheaper than Sonnet 4.6. The real savings appear when you layer in the two main cost levers: prompt caching and the Batch API.

Prompt caching reduces cached input to roughly 10% of the standard input rate. For pipelines that repeat a long system prompt or a shared context block across many requests — RAG applications, document classifiers, multi-turn chat — the practical reduction on total input cost is 30–50% even before any other optimization.

Batch API cuts all token prices by 50% for asynchronous workloads. If your job doesn't need a real-time response — nightly document processing, offline code review, bulk classification — Batch API brings Haiku 4.5 input down to $0.50/M tokens and output to $2.50/M tokens.

Stacking both: a pipeline with a repeated 2K-token system prompt and batch-eligible output runs at roughly 5–8% of the standard Sonnet 4.6 cost. For teams processing millions of tokens per day, the difference between these two models on appropriate workloads is measured in thousands of dollars per month.

One concrete calculation: 10 million output tokens per day on Sonnet 4.6 costs $150/day. The same volume on Haiku 4.5 with Batch API costs $25/day. Over a month, that's $3,750 saved — on a single pipeline component.

Where Haiku 4.5 Genuinely Wins

Sub-Agent Execution in Multi-Agent Systems

The most defensible use case for Haiku 4.5 is as the executor model in an orchestrator/executor pipeline. The pattern that works well:

• Orchestrator (Sonnet 4.6 or Opus 4.7): receives the task, plans steps, assigns subtasks
• Executors (Haiku 4.5, multiple in parallel): complete each subtask — file reads, code edits, API calls, search queries

Haiku 4.5's 91 tok/s output speed means multiple executor instances finish subtasks faster than a single Sonnet call would start. When you're running 5–10 parallel subtasks, the latency advantage compounds. Anthropic's own documentation positions Haiku for "sub-agents, parallelized execution, and scaled deployment" for exactly this reason.

The 73.3% SWE-bench score tells you Haiku 4.5 can complete discrete, well-scoped coding tasks competently. The architecture key is that the orchestrator handles the complex reasoning; Haiku handles the execution.

Real-Time Customer-Facing Applications

Haiku 4.5 averages 0.74s time to first token, roughly half Sonnet 4.6's latency. For chat interfaces, voice assistants, and streaming response UIs, this difference is perceptible. Users notice 0.7s vs 1.5s. In customer support, sales chat, or any interactive product where response feel matters, Haiku 4.5's latency profile is a product advantage.

For these workloads, query complexity is usually moderate — follow-up questions, FAQ lookup, status updates, simple form filling. This fits Haiku 4.5's capability range.

Computer Use Automation

Haiku 4.5 is the first compact model to match the full Anthropic computer use toolset. The published benchmarks show it outperforms Claude Sonnet 4 (not Sonnet 4.6) on computer use tasks. If you're automating web UI interactions, desktop workflows, or GUI-based data entry, Haiku 4.5 is worth testing before defaulting to a larger model. The lower cost per action matters if your pipeline triggers hundreds of screen interactions per day.

Document Processing at Scale

Classification, extraction, summarization, and labeling jobs on large document sets are a natural fit. The tasks are structured, short, and repeatable — exactly the profile where Haiku 4.5 matches Sonnet performance while costing far less. Combine with Batch API and you get the 50% discount on top.

Where Sonnet 4.6 Is the Better Call

Long, multi-file feature builds. Haiku 4.5 performs well on isolated, well-scoped tasks. In extended coding sessions where the model needs to track state across many files, reason about architectural decisions, and handle ambiguous requirements, it loses coherence faster than Sonnet 4.6. Variable names change, context from earlier in the session degrades. Sonnet 4.6 handles the cognitive load of a 20-file codebase edit more reliably.

Complex reasoning chains. Haiku 4.5 supports extended thinking, but its reasoning depth at equivalent thinking budgets is shallower than Sonnet 4.6. For tasks requiring GPQA-Diamond-grade reasoning or long chains of logical inference, Sonnet 4.6 produces fewer errors. If you've enabled extended thinking on Haiku to handle complex tasks and see frequent mistakes, that's the signal to route up.

One-shot tasks where quality is the only metric. For a customer-visible report, a legal document review, or an engineering design decision, the cost delta between Haiku and Sonnet is noise. Optimize for quality when the output is high-stakes and low-volume.

Using Extended Thinking on Haiku 4.5

Haiku 4.5 supports extended thinking via the standard thinking parameter in the API. Usage looks like this:

import anthropic

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-haiku-4-5-20251001",
    max_tokens=8000,
    thinking={
        "type": "enabled",
        "budget_tokens": 5000
    },
    messages=[{
        "role": "user",
        "content": "Analyze this function for edge cases and suggest fixes."
    }]
)

The budget_tokens parameter is important for cost control. Setting it to 5,000 means the model can spend up to 5,000 tokens reasoning before producing a response. Those thinking tokens are billed at the input rate. For a sub-agent that runs this 10,000 times per day, thinking budget directly shapes your cost profile.

Extended thinking on Haiku 4.5 adds latency. For tasks where you've already decided Haiku is appropriate but want better output quality on the harder instances, enable it selectively — routing based on a simple classifier or input length heuristic rather than enabling it globally.

Recommended Pipeline Patterns

Pattern 1: Tiered routing

Route requests to Haiku 4.5 by default. Escalate to Sonnet 4.6 if the task matches criteria like: input exceeds 50K tokens, task type is architecture_review, or a previous Haiku attempt returned a retry signal.

def select_model(task: dict) -> str:
    if task["type"] in ("architecture_review", "complex_debug"):
        return "claude-sonnet-4-6-20251001"
    if task.get("token_estimate", 0) > 50_000:
        return "claude-sonnet-4-6-20251001"
    return "claude-haiku-4-5-20251001"

Pattern 2: Orchestrator + executor swarm

# Orchestrator call — plan the task
plan = sonnet_client.messages.create(
    model="claude-sonnet-4-6-20251001",
    messages=[{"role": "user", "content": f"Break this task into subtasks: {task}"}]
)

# Executor calls — run subtasks in parallel with Haiku
import asyncio

async def execute_subtask(subtask):
    return haiku_client.messages.create(
        model="claude-haiku-4-5-20251001",
        messages=[{"role": "user", "content": subtask}]
    )

results = await asyncio.gather(*[execute_subtask(s) for s in plan.subtasks])

Pattern 3: Batch processing for offline workloads

import anthropic

client = anthropic.Anthropic()

# Build requests list
requests = [
    {
        "custom_id": f"doc-{i}",
        "params": {
            "model": "claude-haiku-4-5-20251001",
            "max_tokens": 1024,
            "messages": [{"role": "user", "content": doc}]
        }
    }
    for i, doc in enumerate(documents)
]

# Submit batch — results returned within 24h at 50% cost
batch = client.beta.messages.batches.create(requests=requests)

Common Mistakes

Enabling extended thinking globally. Extended thinking adds latency and token cost. Don't enable it by default on all Haiku calls. Use it selectively for subtasks where Haiku alone produces low-confidence or incorrect output.

Assuming Haiku fails at longer contexts. Haiku 4.5 has a 200K context window. The limitation isn't context length — it's reasoning depth on complex tasks within that context. Feeding a 100K-token codebase to Haiku for a well-defined search-and-extract task is fine.

Not using prompt caching on repeated system prompts. If your agent always sends the same system prompt and tool definitions, those tokens should be cached. Uncached, repeated tokens are the single largest preventable cost in most production pipelines.

Treating model choice as permanent. A/B test Haiku vs Sonnet on your actual tasks. Published benchmarks are aggregates. Your pipeline's specific prompts, task types, and success criteria may show a different crossover point than the general benchmarks suggest.

FAQ

Q: Does Claude Haiku 4.5 support all Claude API features?

Yes. Haiku 4.5 supports the full Claude API feature set: extended thinking, computer use, tool use, function calling, prompt caching, the Batch API, streaming, and vision. The only difference from Sonnet 4.6 is reasoning depth on complex tasks, not API capability.

Q: What is the model ID to use in API calls?

Use claude-haiku-4-5-20251001. The models overview at platform.claude.com lists current model IDs with their deprecation timelines.

Q: Can I use Haiku 4.5 for Claude Code sub-agents?

Yes. Claude Code's sub-agent system supports custom model routing. You can configure a sub-agent definition to use claude-haiku-4-5-20251001 for specific task types while keeping the orchestrator on Sonnet 4.6.

Q: Is the 73.3% SWE-bench score comparable across other models?

SWE-bench Verified is a standardized benchmark, but evaluation methodology differs between labs. Compare Haiku 4.5's score with other models evaluated on the same benchmark version. Anthropic's official announcement cites the methodology used.

Q: How does Batch API interact with prompt caching?

The two stack independently. A batch request that includes a cacheable prefix gets the 90% cache discount on the cached portion and the 50% batch discount on the rest. There's no mutual exclusion.

Key Takeaways

Claude Haiku 4.5 closes the capability gap enough that the cost argument is now quantitative, not qualitative. At 73.3% SWE-bench and full computer use support, the question isn't whether Haiku is "good enough" — it's whether your specific task falls within the range where Sonnet's additional reasoning depth produces a better outcome.

For sub-agent execution, real-time chat, document processing, and UI automation, Haiku 4.5 is the better choice on cost and latency without meaningful quality loss. For complex multi-file architecture work, GPQA-level reasoning, and tasks where the quality ceiling matters more than the cost floor, Sonnet 4.6 earns its premium.

The practical move: run both models on a representative sample of your real tasks, measure output quality against your success criteria, and let the data set the routing cutoff. The stacking of prompt caching and Batch API means the cost argument only gets stronger as volume increases.

Bottom Line

Claude Haiku 4.5 is the right default for high-volume, latency-sensitive, and sub-agent workloads. With batch API and prompt caching stacked, most teams can route 60–80% of their Claude API traffic to Haiku without touching output quality — and cut their bill accordingly. Save Sonnet 4.6 for the tasks where reasoning depth is the bottleneck, not cost.