Claude Code Pricing Model: Choosing Sonnet, Opus, and Effort

Practical materials on models and working with agents: Ailoot documentation.

Updated September 23, 2026. Since this article was published, Anthropic has changed model generations twice: first Opus 5 and Sonnet 5 were released, then Claude Opus 5.5 on September 22. The selection logic in this guide still works: use the expensive model for architecture and debugging, and the mid-range model for daily work. The names and prices have shifted. I explain exactly what changed and how to read the tables below in the next section.

Which models do Claude Code’s opus and sonnet aliases select in September 2026?#

Here is a quick summary of what changed in the figures and commands:

Three takeaways that change day-to-day work.

The senior model is cheaper. Anthropic says Opus 5.5 requires less compute, so the price per token fell by 20%, cache reads dropped from $0.50 to $0.20 per million, and typical workloads at default settings cost 40% less than Opus 5. The old reflex of “I turned on Opus—I burned through my limit in half a day” is less compelling, though it has not disappeared.

You now set reasoning depth manually. Opus 5.5 starts at medium, whereas other models with effort support start at high. If you expect deep analysis from the senior model, explicitly set /effort high or xhigh. One further detail: the top-level effortLevel key in user settings does not work for Opus 5.5, because the level is now saved separately for each model.

All three current models have a one-million-token context window. The notes about 200K for the mid-range model and upgrading to 1M with opus[1m] do not apply to the current Opus 5.5 and Sonnet 5: they have one million natively.

The tables and calculations below retain the original model names and rates as a guide to the selection logic. Use the current prices: $4 / $20 for the senior model and $2 / $10 for the mid-range model.

What changes in May 2026: Sonnet 4.6, Opus 4.7, Haiku 4.5, and why it matters#

On May 6, 2026, at the Code with Claude conference, Anthropic rolled out five major updates: managed memory (Dreaming), outcomes, multi-agent orchestration, Remote Control, and Agent View. That same day, Pro, Max, Team, and Enterprise limits were doubled. Peak-hour throttling, in place since late March, was fully removed.

At the same time, a different compute contract emerged. In its S-1, SpaceX disclosed an Anthropic deal worth $1.25 billion per month through May 2029 for Colossus (220,000+ NVIDIA GPUs, 300+ MW). This means Claude will have more capacity in the coming years, not less.

What does this change in practice for a vibe coder? The typical workflow used to sound like this: “I use Opus because it’s smarter.” Now the three models really differ from one another:

• Opus 4.7 ($5 / $25 per million input/output tokens, 1M context) — released April 16, 2026. New tokenizer. SWE-bench Verified: 87.6%, up 13% from Opus 4.6.
• Sonnet 4.6 ($3 / $15, 1M context) — 79.6% on SWE-bench Verified. 91% of Opus 4.7’s score at 60% of its base input/output price, and nearly tied with Opus 4.6 (80.8%)—just a 1.2-point difference.
• Haiku 4.5 ($1 / $5, 200K context) — fast and cheap. For anything that does not require architectural thinking.

And the main point: three new commands in Claude Code that received updates in early May: /model, /effort, /fast. Each can cut token use by 2–5 times if you know when to use it.

In the practice described here, both main models are used every day. Below is the resulting decision map.

How to choose a model: a decision map by task type#

This table is handy to keep within reach and consult when switching between tasks.

The main principle: default to Sonnet. Sonnet 4.6 is the default on most user plans for a reason. Anthropic’s official help says directly that Sonnet is the right choice for most coding tasks.

A dangerous pattern that 80% of newcomers fall into: they set Opus as the default and wonder why their limit runs out in half a day. The limit runs out because Opus costs 1.67 times more per token.

How Sonnet 4.6 differs from Opus 4.7 on real tasks#

A benchmark by itself does not mean much. What matters is the difference on real tasks. Here are both models side by side on the same task.

Scenario 1. Simple refactoring (3–5 files).

Sonnet and Opus perform the same. In the comparison described, no difference in code quality was observed. Time: Sonnet is 15–20% faster. Cost: Sonnet is 1.67 times cheaper, so the winner is obvious.

Scenario 2. Debugging a non-trivial bug. Suppose email receipts stop arriving on an e-commerce platform after a payment gateway migration. Symptom: cron runs, the database gets a record, but the email is not sent.

• Sonnet: in 15 minutes, it checks the logs and obvious places, finds that the email service is in the environment variables, and suggests checking the key. If the key is OK, it starts going in circles.
• Opus with xhigh effort: immediately builds a mental map: “webhook → cron → status check → email service.” In 20 minutes, it finds that the migration changed the order ID format, while the email service filters by the old format.

This is not magic. It is adaptive reasoning: Opus 4.7 decides at every step how much to think, and on a difficult bug it spends tokens for deeper reasoning, not for a faster response.

Scenario 3. Architectural decision. “Should we move analytics into a separate service?” Sonnet will give a good plan for a question like this, but it may miss nuances—for example, that monitoring with two services will require moving the alerts. Opus 4.7 works through such nuances systematically.

The last row matters. When you read that “Opus 4.7 costs such-and-such,” remember: the same file will take 20–35% more tokens than with Sonnet. The real cost for the same task rises even more than the table’s nominal prices suggest.

When to use Haiku 4.5 (and why 80% of Claude Code tasks use Sonnet)#

Where Haiku really pays off:

• One-line scripts: “write a bash script to restart nginx if the process does not respond for 30 seconds.”
• Simple explain code: “what does this function do?”
• Generating conventional commit messages.
• Basic syntax checks / lint fixes.
• Translating comments between languages.

Technically, Haiku works in Claude Code just as it does through /model haiku. But there is a wrinkle: subagents and background tasks use Haiku by default unless you override this with the ANTHROPIC_DEFAULT_HAIKU_MODEL environment variable.

Haiku’s context is 200K tokens. This is plenty for most files, but you will hit the limit if you are working with a monorepo or long transcripts. Sonnet and Opus have 1M in that case.

Cost: 1,000 similar requests (for example, generating commit messages from 200 input tokens + 50 output tokens) cost $0.45 on Haiku. The same workload costs $1.35 on Sonnet and $2.25 on Opus. That is a threefold difference.

The /model command: how to switch within a session#

Six ways to set the model in Claude Code, in order of priority:

1. During a session: /model <alias>—switches instantly. Conversation history, files, and context carry over; only the model processing the next message changes. If there has already been output in the session, the selection menu will ask for confirmation—the next response will reread the entire history without cache.
2. At launch: claude --model <alias>.
3. Environment variable: ANTHROPIC_MODEL=<alias>.
4. Settings file: the model field in ~/.claude/settings.json.

Basic commands:

# Launch with the senior model (currently Opus 5.5)
claude --model opus

# Switch to Sonnet within a session
/model sonnet

# Open the selection menu (for interactive selection)
/model

# Switch to Opus with 1M context
/model opus[1m]

# Switch to a specific version (pin)
/model claude-opus-5-5

Aliases and what they point to in the Anthropic API (as of September 23, 2026):

• opus → Opus 5.5 (requires Claude Code v2.1.280 or later)
• sonnet → Sonnet 5
• haiku → Haiku 4.5
• best → the smartest available model
• default → Opus 5.5 on Pro, Max, Team, Enterprise, and the Anthropic API
• opusplan → a hybrid of Opus + Sonnet (discussed separately below)

⚠️ Defaults differ on cloud providers: on Amazon Bedrock and Google Cloud, the sonnet alias points to Sonnet 4.5; on Microsoft Foundry, opus still resolves to Opus 4.6. If you work through a cloud provider, either pin a specific version (claude-opus-5-5) or set the ANTHROPIC_DEFAULT_OPUS_MODEL variable.

Starting with version 2.1.144, the main change is that /model no longer writes the selection to settings. It applies to the current session and disappears when the session is closed. To save a default permanently, press d on the highlighted row in the selection menu. This writes the model field to ~/.claude/settings.json.

Summarized sessions (claude --resume, --continue, /resume) retain the model used in that session, regardless of the current setting. This prevents another session from changing your model when you resume.

To check which model is currently active, use /status—it shows both the account and the current model.

/model opusplan: compare planning and execution costs separately#

In the practice described here, this mode is used for tasks that will take more than 10 steps.

The logic:

• In Plan Mode (/plan), you discuss the architecture and options and agree on an approach. Opus is expensive here, but earns its price because its reasoning is fundamentally different.
• As soon as Plan Mode ends and Claude starts editing files, writing tests, and running commands, that is execution. For execution, Sonnet 4.6 matches Opus in quality.

To enable:

# At launch
claude --model opusplan

# Or within a session
/model opusplan

A specific calculation. Suppose a 50-step refactor has a typical distribution:

• Planning (5 steps, ~30,000 input + 8,000 output tokens): Opus 4.7
• Execution (45 steps, ~200,000 input + 50,000 output tokens): Sonnet 4.6

The baseline uses 230,000 input and 58,000 output tokens: $2.60 at the table’s historical Opus rates. Opusplan keeps 30,000 input and 8,000 output tokens on Opus ($0.35) and uses 200,000 input and 50,000 output tokens on Sonnet ($1.35), for $1.70 total. Savings are ($2.60 − $1.70) / $2.60 = 34.6%. With identical token counts and these rates, replacing execution saves 40% of that portion; even if execution were 90% of baseline cost, total savings would be 36%. A tokenizer difference requires explicit per-model input/output counts and cannot justify a 75–80% claim by itself.

⚠️ One detail: plan-mode Opus in opusplan uses the standard 200K context. The automatic upgrade to 1M, available with the opus alias, does NOT apply to opusplan. If you plan a huge task with millions of tokens of context (for example, analyzing a large monorepo), either explicitly use /model opus[1m] or switch to opusplan AFTER planning.

The /effort command: 5 levels of adaptive reasoning#

This is the second most important command after /model. Effort is adaptive reasoning: at each step, the model decides how deeply to think based on the task’s complexity. The higher the level, the deeper the reasoning and the more tokens it uses.

Levels (depending on the task):

Three models are supported: Opus 4.7, Opus 4.6, and Sonnet 4.6. Effort is unavailable on the others.

What changed by September 2026. The low, medium, high, xhigh, and max levels are available on Opus 5.5, Opus 5, Sonnet 5, Opus 4.8, and Opus 4.7; Opus 4.6 and Sonnet 4.6 do not have xhigh, and a requested xhigh runs as high on those models. The default level is high on all models that support effort, except Opus 5.5 (medium) and Opus 4.7 (xhigh). That means deep analysis has to be requested explicitly on the current senior model. A separate ultracode mode has also appeared: it is a Claude Code setting, not a model level—it sends xhigh and also asks Claude to build dynamic workflows for large tasks.

How to set it:

# Open the interactive slider
/effort

# Set the level directly
/effort high
/effort xhigh

# Reset to the model default
auto

# Through a launch flag
claude --effort high

# Through an environment variable (applies at launch)
export CLAUDE_CODE_EFFORT_LEVEL=high

# In settings (max does not work—max is session-only)
{
  "effortLevel": "high"
}

# In skill / subagent frontmatter
---
name: my-skill
effort: low
---

The level appears next to the logo and spinner in Claude Code, for example, “with low effort,” so there is no need to open /model to check.

The effort slider also appears inside the /model selection menu—use the left/right arrows to set it.

One important detail. When you switch to Opus 4.7 from any other model, effort is forcibly set to xhigh—even if you had high for Opus 4.6 or Sonnet 4.6. To restore the desired level, run /effort again.

One more technique: ultrathink in the prompt. If you include the word ultrathink in the prompt text, Claude will use deeper reasoning for that one turn without changing the session effort. Similar phrases (“think,” “think hard,” “think more”) do not trigger this behavior—they are simply passed as ordinary text.

The /fast command: Opus is 2.5x faster for 6x the price—when does it pay off?#

Fast mode is a research preview feature. It requires Claude Code v2.1.36+ and can be checked with claude --version.

To enable:

# Toggle fast mode (available in the Claude Code CLI and VS Code Extension)
/fast

# Or in settings
{
  "fastMode": true
}

After it is enabled:

• If you are on another model, Claude Code will automatically switch to Opus.
• A “Fast mode ON” confirmation will appear.
• A ↯ icon will appear next to the prompt.

Options and details:

• The default model in fast mode is the most capable available Opus. As of September 23, 2026, that is Opus 5.5; fast mode does not work on Opus 4.7 at all, and switching to it turns fast mode off.
• Fast mode is saved across sessions by default. Team/Enterprise admins can require explicit opt-in for each session with fastModePerSessionOptIn: true.
• When you turn fast mode off by running /fast again, you stay on Opus—the model does not revert to the previous one. To switch, use /model.
• Enabling it mid-conversation charges the fast mode price for the entire conversation context. So it is more economical to enable fast mode at the very start of a session, not halfway through.

When to use fast mode:

• Live debugging: You are watching a trace and response time is critical.
• Tight deadline for interactive work: You are writing a demo by 18:00 and need fast iterations.
• Rapid code iteration: You are testing hypotheses one after another.

When not to use it:

• Long autonomous tasks where speed is not critical. You pay 6x for 2.5x the speed—it does not pay off if you go to lunch while Claude works.
• Batch processing, CI/CD pipelines—not for interactive mode at all.
• Cost-sensitive workloads—the choice is obvious.

Availability:

• Does NOT work on Bedrock, Vertex, or Foundry.
• Requires usage credits in the account (billing beyond the plan’s included limit). For individual accounts, it is enabled in Console billing settings. For Team/Enterprise, an admin must enable it.
• Fast mode tokens are NOT deducted from the plan’s included limit. They come directly from usage credits, at fast mode prices from the very first token.

If you hit the fast mode request limit or run out of usage credits, fast mode automatically switches to standard speed and pricing, the ↯ icon turns gray, and work continues. When the limit resets, fast mode turns itself back on.

Fast mode and effort are not competing settings. You can combine them: fast mode + low effort = maximum speed on simple tasks.

How much each model really costs: a breakdown of your monthly bill#

Prices per million tokens (Anthropic API, USD):

What actually reduces the bill:

1. Prompt caching. Anthropic caches repeated sections of prompts: the system prompt, CLAUDE.md, tool descriptions. A cache hit costs 10% of the input price. On Sonnet, that turns $3 per million tokens into $0.30—10 times cheaper. It is enabled automatically through cache_control: { type: "ephemeral" } in the API request. In Claude Code, it works by default.

2. Batch API: 50% off input and output for tasks you can wait for (reports, bulk text generation in batches). Sonnet via Batch API = $1.50 / $7.50. It does not work directly in Claude Code, but if you build automations with the Anthropic SDK, use it.

3. opusplan instead of pure Opus: about 34.6% savings in the worked historical example; the actual total depends on the execution share, token counts, rates, caching and retries.

4. Sonnet by default + Opus when needed: the main source of savings. If Opus is enabled “just in case,” the practice described here switches to Sonnet. If the task requires Opus, that becomes apparent by the third or fourth step, and I switch explicitly with /model opus.

5. Remember Opus 4.7’s new tokenizer. On the same file, Opus 4.7 uses up to 35% more tokens than Sonnet 4.6. The real cost for the same task rises more than the table might suggest.

A specific example: a typical task for a real estate agency building a website prototype for a new client: “create a page with three sections, a form, and payment gateway integration.” The results were:

• Opus 4.7 only (high effort): ~$4.80 per session (1.5 hours of work).
• opusplan: ~$1.90 (Opus plans, Sonnet executes).
• Sonnet 4.6 only (high effort): ~$1.30, but the architectural decision was worse (Sonnet took a template-based approach, while Opus in opusplan came up with its own for the non-standard requirements).

The winner for this task is opusplan. Savings are 60%, with Opus quality for the critical part.

Claude Code does not show token counts directly for limits—they are dynamic and depend on the plan. But in /status, you can see your plan and current usage. For closer control, there is a detailed guide: How to avoid burning through Claude Code limits in a day.

What daily workflow should you set up? 4 ready-made presets#

These four presets can be switched depending on the workday and task.

Preset 1. Daily Code—80% of working time in the practice described here.

claude --model sonnet --effort high
# Inside the session, escalate to Opus if needed
/model opus

What it is: new features, small refactors, debugging simple bugs, documentation. Sonnet at high effort is the sweet spot.

Preset 2. Heavy Refactor—a major architectural change.

claude --model opusplan
# First use /plan to discuss the structure
# After leaving Plan Mode, Sonnet handles execution

What it is: rewriting a module across 15+ files, switching an integration from one gateway to another. Opus handles architecture (thinking through dependencies), and Sonnet handles execution (editing files quickly). These tasks can save 70%+.

Preset 3. Quick Fix—one-line edits and scripts.

claude --model haiku --effort low

What it is: “change the name of a variable in all files,” “write a bash script to restart nginx,” “what does this function do?” Haiku handles these tasks and costs three times less than Sonnet.

Preset 4. Architecture Session—a strategic decision.

claude --model opus --effort xhigh
# Use maximum effort when entering Plan Mode:
/plan
# Add the word ultrathink to the prompt for critical questions

What it is: “should X be a separate service?”, “which tools should we use for the prototype?”, “how should we organize a database schema for multi-tenant use?” This is where Opus 4.7 is expensive—and worth it, because a mistake here costs weeks of work.

These presets can be saved as Skills (one model per skill) or as aliases in ~/.zshrc:

alias claude-daily='claude --model sonnet --effort high'
alias claude-refactor='claude --model opusplan'
alias claude-quick='claude --model haiku --effort low'
alias claude-architect='claude --model opus --effort xhigh'

If you work on a team, you can standardize through managed settings. An admin sets availableModels: ["sonnet", "haiku", "opusplan"] in the organization policy, and users physically cannot choose Opus directly, only through explicit opt-in. This is a good safeguard against accidentally burning through the limit.

For those building subagents, you can also set different models for different subagents through CLAUDE_CODE_SUBAGENT_MODEL or the model field in the agent definition’s frontmatter. This adds another level of optimization.

What to do when you run out of capacity: 5 practical techniques#

If /status shows that you have hit the Opus limit:

1. Switch to Sonnet 4.6: /model sonnet. It has a separate pool, and you will not notice a difference on 80% of tasks. On the Anthropic API, even when you hit the Opus limit, Claude Code may automatically fall back to Sonnet if you are approaching the threshold.

2. Use opusplan for the work still ahead: /model opusplan. If you have Plan Mode tasks left for the day, they will use Opus minimally (for planning only); execution will be entirely on Sonnet.

3. Check prompt caching: make sure you have not disabled it with DISABLE_PROMPT_CACHING=1. If your CLAUDE.md or system prompt contains a megabyte of settings, it should be cached. On 90% reads, this reduces usage tenfold.

4. Move batch tasks: if you have bulk generation (reports, texts, translations), move it to a script with the Batch API—50% off input and output. It does not work directly in Claude Code, but takes 30 minutes to set up with a tsx script + Anthropic SDK.

5. Use Haiku for secondary tasks: for routine tasks such as “write a commit message” or “explain what this file does,” switch Claude Code to Haiku. It uses three times less than Sonnet and five times less than Opus.

And the main reminder: since May 6, 2026, limits on Pro, Max, Team, and Enterprise have doubled, and peak-hour throttling has been removed. If Opus burns through your capacity in half a day, the problem is not the limits—it is that Opus is being used where Sonnet would do the job. The decision map in the second section of this guide puts you back in control.

For an in-depth look at limits and eight practical rules for saving tokens, see this pillar article: How to avoid burning through Claude Code limits in a day: 8 rules for saving tokens in 2026. Another useful companion is Plan Mode in Claude Code: a step-by-step guide, because opusplan does not work without Plan Mode. And the foundation for every model is How to configure CLAUDE.md in 2026.

Practical materials: Ailoot documentation.

More materials and tools: Ailoot.