Claude Plan Prices at a Glance
| Plan | Monthly | Annual (per month) | Claude Code | Usage |
|---|---|---|---|---|
| Free | $0 | — | No | Limited |
| Pro | $20 | $17 ($200 billed up front) | Yes | Standard |
| Max 5x | $100 | — | Yes | ~5x Pro per session |
| Max 20x | $200 | — | Yes | ~20x Pro per session |
| Team — Standard seat | $25/seat | $20/seat | Yes | More than Pro |
| Team — Premium seat | $125/seat | $100/seat | Yes | ~5x a Standard seat |
| Enterprise | $20/seat plus usage, negotiated | — | Yes | Seat allowance plus usage |
| API | Pay per token | — | Yes | No cap, no allowance |
Two things in that table contradict what most Claude pricing articles still say, so they are worth stating plainly.
Claude Code is not on the Free plan. Anthropic's setup documentation is unambiguous: "Claude Code requires a Pro, Max, Team, Enterprise, or Console account. The free Claude.ai plan does not include Claude Code access." The Free plan's own feature list on the pricing page — web and mobile chat, code generation, web search, memory, file creation and code execution, connectors and remote MCP, extended thinking — does not mention Claude Code at all. If you want to try Claude Code, $20 for one month of Pro is the cheapest entry point, not the free tier.
Claude Code is included on Team Standard seats. Several widely-cited pricing guides claim the $20/seat Standard seat excludes Claude Code and that you must buy $100 Premium seats to get it. That was true at one point; it is not true now. The Standard seat's feature list reads "Includes Claude Code and Claude Cowork." The difference between Standard and Premium is usage volume — a Premium seat carries roughly 5x a Standard seat's allowance — not feature access. For a team evaluating Claude Code, that is a 5x difference in the cost of entry, so check it yourself before you budget from someone else's table.
What each plan is actually for
Free ($0). Chat, web search, memory, file creation, extended thinking, and connectors — but no Claude Code. Treat it as an evaluation tier for Claude the assistant, not for Claude the coding tool.
Pro ($20/month, or $17/month billed annually at $200 up front). The entry point for Claude Code, and it covers more developers than they expect. Pro also includes Claude Cowork, Claude Design, and Claude Science alongside chat. No seat minimum.
Max 5x ($100/month). Roughly five times Pro's usage per session. This is the tier for someone who hits Pro's session ceiling most working days but is not living in the tool.
Max 20x ($200/month). Roughly twenty times Pro's usage per session, plus higher output limits and early access to new features. This is the tier for Claude Code as a primary working environment — long autonomous runs, agent teams, heavy Opus use.
Both Max tiers share the same limit structure: a session window that resets every five hours, plus a weekly limit that applies across all models. Anthropic notes it "may limit your usage in other ways, such as weekly and monthly caps or model and feature usage."
Team (Standard $20/seat annually or $25 monthly; Premium $100/seat annually or $125 monthly). Minimum 2 seats, maximum 150 people. Both seat types include Claude Code, Cowork, Design, and Science, plus central billing, SSO, admin controls for connectors, enterprise search across your organization, and no model training on your content by default. You can mix seat types — Standard for occasional users, Premium for the developers who live in Claude Code. Each member's allowance resets on a rolling five-hour window and a weekly window, shared across Claude chat, Cowork, and Claude Code.
Enterprise ($20/seat plus usage, negotiated). Per-seat pricing where usage cost scales with model and task, plus the compliance and reporting surface: an Enterprise Analytics API for per-user cost reports, org-level spend limits, and custom terms.
API (pay per token). No allowance and no ceiling. This is what you choose for automation, CI/CD, per-user cost attribution, and policy-enforced spend caps — not, as the next section shows, to save money on interactive work.
Claude API Pricing per Model
These are Anthropic's first-party API rates, in US dollars per million tokens. The cache columns matter more than they look: on any agentic workload, cached input is the largest line on the bill.
| Model | Input | 5-min cache write | 1-hour cache write | Cache read | Output |
|---|---|---|---|---|---|
| Claude Fable 5 | $10.00 | $12.50 | $20.00 | $1.00 | $50.00 |
| Claude Opus 5 | $5.00 | $6.25 | $10.00 | $0.50 | $25.00 |
| Claude Sonnet 5 | $2.00 | $2.50 | $4.00 | $0.20 | $10.00 |
| Claude Haiku 4.5 | $1.00 | $1.25 | $2.00 | $0.10 | $5.00 |
A freshness note worth acting on: Sonnet 5's $2/$10 rate is now permanent. It launched as introductory pricing scheduled to rise to $3/$15 on 1 September 2026, and Anthropic has confirmed that increase will not happen. Any budget model built on the assumption of a September Sonnet price rise can be corrected downward. Older Sonnet 4.6 and 4.5 remain at $3/$15.
Four modifiers change these numbers:
| Modifier | Effect | Applies to |
|---|---|---|
| Cache read (hit) | 0.1x the base input price | Most of your input on any session past the first message |
| Cache write | 1.25x base input (5-minute cache) or 2x (1-hour cache) | Paid once, when content is first stored |
| Batch API | 50% off input and output | Asynchronous jobs only — not interactive Claude Code |
| Fast mode | $10 input / $50 output on Opus 5 | Opt-in premium speed, first-party API only |
Two more line items people miss. Web search costs $10 per 1,000 searches on top of token costs. And the 1M-token context window carries no long-context premium — a 900,000-token request bills at the same per-token rate as a 9,000-token one, which is a meaningful change from how long-context pricing worked on earlier models.
If you are comparing Anthropic against running models yourself or against other vendors, our self-hosted LLM cost calculator, AWS Bedrock pricing calculator, and Microsoft Copilot cost calculator run the same arithmetic on the alternatives.
What a Claude Code Session Actually Costs
Plan prices tell you the ceiling. Measured costs tell you where you will actually land.
Anthropic publishes cost benchmarks from enterprise Claude Code deployments. Across those deployments the average is around $13 per developer per active day, and $150–$250 per developer per month. Crucially, 90% of users stay below $30 per active day — the average is pulled up by a tail of heavy users running multiple instances and automation, not by typical interactive work.
Individual sessions are much smaller than those daily totals suggest, because a day is many sessions. Anthropic's own documentation example shows a session that used 1.2k input tokens, 5.3k output tokens, 940k cache reads, and 50k cache writes on Sonnet — total cost $0.55, across 6 minutes of API time spread over a 6.5-hour wall-clock window.
Read that example carefully, because it contains the single most important fact about Claude Code cost: the cache reads dwarf everything else. 940,000 cached tokens against 1,200 fresh input tokens. You are not mostly paying for what you type. You are mostly paying to re-read the conversation you have already had.
Why one line of typing costs more than one line of typing
Claude Code is stateless underneath. Every message you send ships the entire conversation so far — your prompts, Claude's replies, every file it read, every command output, every test log. Then each tool call inside a turn sends another request carrying that accumulated history plus the new tool results.
So a one-word "yes" in a session that has been open all afternoon is not a one-word request. It is a request carrying your whole afternoon. Prompt caching softens this enormously (cached tokens bill at 10% of the input rate), but 10% of a very large number is still a real number, and it grows every hour the session stays open.
This is why the cost lever that matters most is not which plan you pick. It is how much context each request is carrying.
Worked example: a focused Sonnet session
A single, disciplined feature-implementation session — one task, cleared context, Sonnet 5:
Fresh input (prompts + first file reads): 15,000 tokens @ $2/M = $0.030
Cached input (re-read across ~25 turns): 600,000 tokens @ $0.20/M = $0.120
Output (code, explanations, thinking): 40,000 tokens @ $10/M = $0.400
Total ≈ $0.55
Worked example: the same work on Opus 5, in a stale session
Same feature, but the session has been open since morning with three unrelated tasks already in it, and Opus is the default model:
Fresh input: 15,000 tokens @ $5/M = $0.075
Cached input (context is 4x larger): 2,400,000 tokens @ $0.50/M = $1.200
Output (higher effort, more thinking): 55,000 tokens @ $25/M = $1.375
Total ≈ $2.65
Nearly 5x the cost for the same delivered work. Neither the plan nor the prompt changed — only the model and the accumulated context. This is the entire cost story of Claude Code in two examples.
Worked example: a month of typical use, priced three ways
Take the measured average of ~$13 per developer per active day and 20 active days:
| Billing route | Monthly cost | Notes |
|---|---|---|
| API (pay per token) | ≈ $260 | 20 days × $13; no cap, no allowance |
| Max 20x | $200 | Cheaper than measured API usage, with a session ceiling |
| Max 5x | $100 | Cheaper still, if you can pace inside its limits |
| Pro | $20 | Dramatically cheaper — viable with /clear discipline and Sonnet as default |
Note what this table does not say: that Pro is enough for everybody. It says the price of the plan is fixed and the price of tokens is not, so the question is only whether you can work inside the plan's windows. That is a behavioural question, and the rest of this guide is about it.
Subscription vs API: Where the Break-Even Sits
Claude Code runs on either a Claude subscription or pay-per-token API billing, and Claude Code is included in every paid Claude plan — there is no separate Claude Code charge on top.
Putting the two together:
- Pro at $20/month is dramatically cheaper than equivalent API spend — if you can live inside its limits.
- Max 5x at $100/month is cheaper than typical measured API usage, and Max 20x at $200 is roughly at par with it.
- The API only wins on economics when your usage is genuinely low or genuinely bursty — a few sessions a week, or intense project sprints separated by quiet months where a subscription bills you for capacity you did not touch.
The honest summary: for steady daily coding, subscriptions are the cheaper product. The API is not primarily a cost play. It is what you choose when you need something a subscription does not offer — no hard ceiling mid-task, per-token attribution across a team, spend caps enforced by policy, or programmatic access from CI/CD.
What a subscription's limits actually are
Subscription plans do not meter you in dollars. They apply a session-based usage limit that resets every five hours, layered with a weekly limit across all models. Anthropic does not publish exact token numbers for these windows and tunes them over time, which is why you should distrust any article that quotes a precise per-window token figure.
Two practical consequences. First, the windows are shared across all models, so switching models with /model when you hit a session or weekly limit does not restore access — though it does keep you working after a model-specific "you've hit your Opus limit" message. Second, because the limit is a rolling window rather than a hard monthly quota, pacing genuinely works: spreading heavy work across windows stretches a Pro plan much further than burning it in one sitting.
If you keep colliding with these ceilings, our guide to fixing Claude Code rate limits covers the recovery paths, and usage credits let you continue past a plan limit at API rates — run /usage-credits to manage them and set a monthly spend cap.
Tracking What You Are Actually Spending
You do not have to estimate. Claude Code reports its own cost.
/usage shows the current session's token breakdown and a dollar figure:
Total cost: $0.55
Total duration (API): 6m 20s
Total duration (wall): 6h 33m 10s
Total code changes: 0 lines added, 0 lines removed
Usage by model:
claude-sonnet-4-6: 1.2k input, 5.3k output, 940.0k cache read, 50.0k cache write ($0.55)
Two caveats. Claude Code computes that dollar figure locally from token counts at standard list rates, so it ignores promotional pricing and contracted discounts and may differ from your bill — the Claude Console usage page is authoritative. And on a Pro or Max subscription, the session cost figure is informational rather than billing-relevant, since your usage is included in the plan; subscribers see plan usage bars instead.
On a paid plan, /usage also breaks down what consumed your allowance — attributing recent usage to skills, subagents, plugins, and individual MCP servers as a percentage of the total, and flagging behaviors such as long context or cache misses when one accounts for 10% or more of recent usage. Press d or w to switch between the last 24 hours and the last 7 days. This is the single most useful cost-diagnosis screen in the product: it tells you which of your own habits is expensive.
/insights goes further, analyzing recent sessions on your machine and writing an HTML report on how you work — friction points, misunderstood requests, and suggestions. It costs tokens to run, on any plan.
For organizations, where you see and cap spend depends on how you authenticate:
| Setup | See spend | Cap spend |
|---|---|---|
| Teams / Enterprise plan | Spend report in org analytics (per user, per model, CSV export) | Seat allowance is the default ceiling; add usage-credit spend limits per org, group, or member |
| Claude Console (API) | Console usage page and the Claude Code dashboard | Workspace spend limits |
| Bedrock / Google Cloud / Foundry | Your cloud billing console | Your cloud's budget controls |
OpenTelemetry export works on every setup and is the only option that streams per-user token and cost metrics into your own observability stack in near real time.
What Drives Claude Code Costs Up
A session that has been open for hours can consume far more than your activity suggests. These are the actual causes, roughly in order of impact.
Long context. The dominant factor. Every request carries the full conversation, and every tool call inside a turn carries it again. A one-line question in an all-day session still draws usage for the whole conversation.
Cache misses. Your first message after a break longer than the cache lifetime reprocesses your entire context at full input price instead of 10%. One hour on a subscription, five minutes on API keys, cloud providers, or once you are on usage credits. You can keep the one-hour lifetime while drawing on usage credits by setting ENABLE_PROMPT_CACHING_1H=1.
Model default left on Opus. Opus 5 is $5/$25 per million tokens against Sonnet 5's $2/$10 — 2.5x on both input and output, applied to every request in the session, including the trivial ones. Fable 5, at $10/$50, is another 2x above Opus.
Extended thinking at high effort. Thinking tokens bill as output tokens, and the default budget can run to tens of thousands of tokens per request. On complex planning work this is money well spent; on a one-line edit it is not.
Agent teams. Each teammate is a separate Claude Code instance with its own context window. Anthropic measures agent teams at approximately 7x the tokens of a standard session when teammates run in plan mode, and each active teammate keeps consuming tokens until it exits.
MCP server overhead. Tool definitions consume context. They are deferred by default so only names enter context until a tool is used, but unused servers still add weight — /context shows what is consuming space.
A large CLAUDE.md. It loads into context at session start and is present on every request, whether or not the current task needs any of it.
Background and idle consumption. Scheduled tasks fire on their interval even while a session sits idle, sending your full context each time. Cross-session messages do the same. Ordinary background jobs (conversation summarization for --resume, some command processing) are small — typically under $0.04 per session.
Compaction itself. /compact reads the conversation it summarizes, so compacting a large context is a large request. When you want a fresh start rather than continuity, /clear costs nothing.
How to Reduce Claude Code Costs
In rough order of return on effort:
1. Clear between unrelated tasks. /clear is free and resets the accumulated context that is inflating every subsequent request. This is the highest-leverage habit in the entire list. Use /rename before clearing so you can /resume the session later if you need it.
2. Match the model to the job. Sonnet handles most coding work well at 40% of Opus's rate. Reserve Opus for genuine architectural reasoning, multi-file refactors, and hard debugging. Use /model to switch mid-session or set a default in /config; for simple subagent work, specify model: haiku in the subagent configuration. Our comparison of Opus vs Sonnet for Claude Code covers where the quality difference actually shows up.
3. Turn effort down on simple work. Lower the effort level with /effort or in /model, or disable thinking in /config for tasks that do not need reasoning. On models with a fixed thinking budget you can set MAX_THINKING_TOKENS=8000; adaptive-reasoning models ignore nonzero budgets, so use effort levels there instead. Note that thinking cannot be disabled on Fable 5, which always uses extended thinking.
4. Use plan mode for complex tasks. Shift+Tab into plan mode lets Claude explore and propose an approach for your approval before implementing. Preventing one wrong-direction implementation saves more tokens than any micro-optimization on this list. Press Escape to stop early when it heads the wrong way; /rewind restores a previous checkpoint.
5. Write specific prompts. "Improve this codebase" triggers broad scanning across many files. "Add input validation to the login function in auth.ts" reads one file.
6. Delegate verbose operations to subagents. Running tests, fetching docs, and processing logs generate a lot of output. In a subagent, that verbosity stays in the subagent's context and only a summary returns to your main conversation.
7. Offload preprocessing to hooks. Instead of Claude reading a 10,000-line log to find errors, a PreToolUse hook can grep for ERROR and return only matching lines — tens of thousands of tokens down to hundreds.
8. Keep CLAUDE.md under about 200 lines. Move workflow-specific instructions into skills, which load on demand only when invoked, rather than riding along in every request.
9. Prefer CLI tools to MCP servers where both exist. gh, aws, gcloud, and sentry-cli add no per-tool listing overhead. Run /mcp and disable servers you are not using.
10. Keep agent teams small and short-lived. Use Sonnet for teammates, keep spawn prompts focused, and shut teammates down when their work is done.
For the prompting side of this specifically, see our guide to optimizing prompts to reduce token costs, and LLM tokens explained if the unit itself is still fuzzy. To estimate a specific prompt or file before you send it, our LLM token counter gives you the number directly.
Choosing a Plan From Your Own Numbers
Rather than guessing, measure for a week:
- Run
/usageat the end of each session and note the cost figure. - Press
wto see the 7-day view and check the attribution breakdown — which skills, subagents, or MCP servers are eating your allowance. - Note how often you hit a session or weekly limit.
Then:
| What your week looked like | Plan | Cost |
|---|---|---|
| Under ~$1/day of measured usage, never hit a limit | Pro | $20/mo ($17 annual) |
| Hitting session limits once or twice a week | Pro, with pacing and /clear discipline | $20/mo |
| Hitting limits most days; Opus-dependent work | Max 5x | $100/mo |
| Living in Claude Code all day, routinely exhausting 5x | Max 20x | $200/mo |
| Intense sprints, then quiet weeks | API — you stop paying during the quiet ones | ~$0–$300/mo |
| CI/CD, automation, scripted pipelines | API — no interactive plan covers this | Usage-based |
| A small team wanting central billing and admin | Team, mixing Standard and Premium seats | $20–$100/seat/mo annual |
| Per-user cost attribution and policy spend caps | API/Console or Enterprise | Usage-based |
A caveat on the API path worth stating plainly: choosing the API to save money usually backfires for steady daily use. Measured typical usage prices out above Max 20x. Choose the API for the capabilities, and treat any savings as situational.
If you have not installed the CLI yet, start with our guide to installing Claude Code. To point Claude Code at an API key, set ANTHROPIC_API_KEY in your environment — see where Claude Code configuration files are stored for how to persist it.
Frequently Asked Questions About Claude Pricing
How much does Claude cost per month?
$0 for Free, $20/month for Pro ($17/month if billed annually at $200 up front), $100/month for Max 5x, and $200/month for Max 20x. Team seats are $20/seat/month billed annually ($25 monthly) for Standard and $100/seat/month annually ($125 monthly) for Premium, with a 2-seat minimum. Enterprise is $20/seat plus negotiated usage.
How much does Claude Max cost?
Max 5x is $100 per month and Max 20x is $200 per month. The difference is usage volume, not features: Max 5x gives roughly five times Pro's usage per session and Max 20x roughly twenty times, along with higher output limits and early access to advanced features. Both use the same five-hour session window plus a weekly limit across all models. Mobile pricing may differ from web.
How much does Claude Pro cost?
$20 per month billed monthly, or $17 per month billed annually — $200 charged up front for the year. Pro includes Claude Code, Claude Cowork, Claude Design, Claude Science, and more usage than Free, with no seat minimum.
Is Claude Code free?
No. Anthropic's documentation states plainly that "Claude Code requires a Pro, Max, Team, Enterprise, or Console account. The free Claude.ai plan does not include Claude Code access." The cheapest way to use Claude Code is one month of Pro at $20, or API billing with no subscription at all.
Is Claude Code included in the Team plan?
Yes — on both seat types. Team Standard ($20/seat annually, $25 monthly) lists "Includes Claude Code and Claude Cowork," as does Premium ($100/seat annually, $125 monthly). The difference is allowance size: a Premium seat carries roughly 5x a Standard seat's usage. Several pricing guides still claim Standard seats exclude Claude Code; that is out of date.
What does the Claude API cost per token?
Per million tokens: Claude Fable 5 at $10 input / $50 output; Claude Opus 5 at $5 / $25; Claude Sonnet 5 at $2 / $10; Claude Haiku 4.5 at $1 / $5. Cache reads bill at 10% of the input rate, cache writes at 1.25x (5-minute) or 2x (1-hour), and the Batch API takes 50% off both input and output. Sonnet 5's $2/$10 rate, originally introductory, is now the standard price — the increase scheduled for September 2026 will not happen.
How much does Claude Code cost per day?
Across enterprise deployments Anthropic measures an average of around $13 per developer per active day, with 90% of users below $30 per active day and monthly figures of $150–$250 per developer. Individual sessions are far smaller — a focused Sonnet session typically lands under a dollar. Your own number depends mostly on which model you default to and how long you leave sessions open, not on how much you type.
Is the Anthropic API cheaper than a Claude subscription?
Usually not, for steady use. Typical measured Claude Code usage prices out at roughly $260/month of API tokens — more than Max 20x. The API is cheaper only when your usage is genuinely light or genuinely bursty. Choose it for capabilities instead: no hard ceiling mid-task, per-user cost attribution, policy-enforced spend caps, and CI/CD access.
Why is my Claude Code session so expensive?
Almost always accumulated context. Every request carries the entire conversation, and each tool call inside a turn carries it again, so a long-running session costs more per message than a fresh one regardless of what you type. The other common causes are Opus left as the default model, a cache miss after a break longer than the cache lifetime, and agent teams — which use roughly 7x the tokens of a standard session. Run /usage and press w; the breakdown flags any behavior accounting for 10% or more of recent usage.
What happens when I hit my plan limit?
Claude Code tells you which ceiling you hit and when it resets. Session limits reset on a five-hour rolling window; there is also a weekly limit across all models. Because the windows are shared across models, switching with /model does not restore access after a session or weekly limit — though it does keep you working past a model-specific Opus limit. If usage credits are enabled, /usage-credits lets you continue past the allowance at API rates within a spend limit you set.
Can I change plans mid-cycle?
Upgrading (Pro to Max, or Max 5x to 20x) takes effect immediately. Downgrading typically takes effect at the next billing cycle.
The Short Version
Claude pricing has two layers, and only one of them is on the pricing page.
The plan layer is simple: $0 Free (no Claude Code), $20 Pro, $100 Max 5x, $200 Max 20x, $20–$100 per Team seat, $20/seat plus usage for Enterprise, and API billing at $2/$10 per million tokens on Sonnet 5, $5/$25 on Opus 5, and $10/$50 on Fable 5. For steady daily development, a subscription beats API billing on cost, and Pro covers more developers than they expect.
The cost layer is where the money actually moves: accumulated context, model default, thinking effort, and agent-team fan-out. A developer on Pro who clears between tasks and defaults to Sonnet will out-last a developer on Max who leaves one Opus session open all day — and will get the same work done. Measure with /usage for a week before you upgrade. The upgrade is often not the fix.
Related Resources
- Claude Code Rate Limits Explained - What the session and weekly windows actually mean
- Opus vs Sonnet for Claude Code - Where the quality difference justifies the price difference
- Optimize Prompts to Reduce Token Costs - Prompt-side savings
- LLM Tokens Explained - The billing unit itself
- LLM Token Counter - Count tokens in a prompt or file before you send it
- Self-Hosted LLM Cost Calculator - Compare API spend against running models yourself
- How to Install Claude Code CLI - Get started
- How to Fix Rate Limits - When you hit a ceiling
- How to Switch Between Models - The single biggest cost lever
- Working with Large Codebases - Context management at scale
- Configure CLAUDE.md - Keep it short, keep it cheap
- Where Configuration Files Are Stored - Point Claude Code at an API key