On 15 October 2026, Claude Code spend splits into three bills: the subscription, usage credits after the allowance runs out, and the API on the Console or a cloud provider. The subscription is a fixed monthly or annual fee. The terminal, the web app, the desktop app, and mobile share one allowance. When that allowance is gone, a paid plan can turn on usage credits and continue at API list rates. An API key, Amazon Bedrock, Google Cloud, or Microsoft Foundry meters every request in tokens from the first call.
The figures below come from claude.com/pricing (checked 2026-10-15), the Max plan help article, the Team plan help article, and the API price list effective 2026-10-07. Tax, App Store and Google Play prices, and contract discounts follow the checkout page. For whether Max is the right seat, see Is Claude Code Max worth it? To place this next to other coding subscriptions, see what AI programming costs per month.
- Every paid plan includes Claude Code. Free does not. Chat and the terminal draw from the same pool.
- Opus 5.5 and Sonnet 5.5 bill the 1M window at the standard rate. Haiku 5.5 reprices the whole request once the prompt passes 100,000 tokens.
- The dollar figure in
/usageon a subscription is a list-price estimate. Usage credits and the API are what actually settle per token.
Split the three bills first
A common reading of “how much is Claude Code per month” stops at Pro at $20. That covers work that stays inside the allowance. Anthropic does not publish a fixed message count. How far the allowance goes depends on conversation length, model, and features. Paid plans use a rolling five-hour window, with a weekly cap on top.
- Included allowance: Claude Code inside a Pro, Max, Team, or Enterprise seat. Usage inside the seat is not invoiced line by line in dollars.
- Usage credits: continuing after the allowance. Billed at standard API rates, and capped by the monthly spend limit you set. Toggle them with
/usage-credits. - API or cloud bill: a Console workspace, Bedrock, Google Cloud, or Microsoft Foundry. On the Console, Claude Code lands in a workspace named “Claude Code”, which can carry its own spend limit.
Max 5x also includes $100 a month in Claude Platform API credits. Max 20x includes $200. Those credits are for building on the platform. They are a different pool from terminal usage on the subscription. The terminal draws the subscription allowance first. After that allowance is exhausted and usage credits are on, further work is billed at list rates.
Subscriptions: Pro, Max, Team, Enterprise
Individual prices are web subscriptions, before tax. The help center lists Max 5x at $100 per month and Max 20x at $200 per month, billed monthly. Pro can be paid annually.
| Plan | Price | Claude Code and allowance |
|---|---|---|
| Free | $0 | No Claude Code. Sonnet and Haiku are available |
| Pro | $20/month; $200/year, about $17/month | Includes Claude Code. Each five-hour window is at least 5× Free, plus a weekly cap. Fable runs on usage credits |
| Max 5x | $100/month | About 5× Pro per five-hour window. $100/month in Platform API credits. Fable can use 50% of the weekly limit |
| Max 20x | $200/month | About 20× Pro per five-hour window. $200/month in Platform API credits |
| Team Standard | $25 per person/month; $20 annually | At least two people. More usage than Pro. Includes Claude Code and central billing |
| Team Premium | $125 per person/month; $100 annually | About 5× the Standard allowance. US list price; other regions follow the upgrade page |
| Enterprise | $20 per seat/month plus usage at API rates, billed annually | Team capabilities, plus SCIM, audit logs, custom retention, and role-based access |
Standard and Premium Team prices come from the Team plan update on 28 January 2026 and match the help center. The $20 Enterprise seat fee is from the pricing-page FAQ. Tokens are still billed at API rates, so the seat fee is not a ceiling on coding spend.
Anthropic’s Claude Code cost docs publish an enterprise observation for sizing a pilot: about $13 per person per active day, about $150–250 per person per month, and under $30 per active day for 90% of users. That is the distribution they report, not a quote for your team.
API and tokens: input, output, cache
The table is global routing at standard list price, in USD per million tokens (MTok). Cache writes come in a 5-minute tier and a 1-hour tier. Cache reads on Opus 5.5 and Sonnet 5.5 are 0.05× the input price. Fable 5.1 is 0.025×. Other models are generally 0.1×. Batch is half price on input and output, and cache multipliers stack on top.
| Model | Input | 5-minute cache write | 1-hour cache write | Cache read | Output |
|---|---|---|---|---|---|
| Fable 5.1 | $10 | $12.50 | $20 | $0.25 | $50 |
| Opus 5.5 | $4 | $5 | $8 | $0.20 | $20 |
| Sonnet 5.5 | $2 | $2.50 | $4 | $0.10 | $10 |
| Haiku 5.5, prompt ≤ 100,000 | $0.10 | $0.125 | $0.20 | $0.01 | $0.50 |
| Haiku 5.5, prompt > 100,000 | $0.50 | $0.625 | $1 | $0.05 | $2.50 |
Three more layers change the unit price:
- US-only inference: on Claude 4.6 and later,
inference_geo: "us"multiplies input, output, cache writes, and cache reads by 1.1. Global routing uses the standard price. Foundry’s US Data Zone uses the same 1.1 multiplier. - Fast mode (research preview, first-party API only): Opus 5.5 is $8 input and $40 output. Cache multipliers sit on top of the fast-mode base. Batch cannot use fast mode.
- Newer tokenizer: Claude 4.7 and later produce about 30% more tokens for the same text. Sonnet 4.6 and earlier keep the previous tokenizer. Moving a repo from 4.6 to 5.5 changes the token count even when the price card looks flat.
For a task-level look at Opus 5.5 volume, see how much Claude Opus 5.5 uses while coding. If the request goes through an aggregator rather than Anthropic directly, recheck the route; see OpenRouter pricing for Claude, GPT, and Gemini.
How long context is billed
Claude 4.6 and later (except Haiku 5.5) include the full 1M window at the standard per-token rate. A 900,000-token request and a 9,000-token request pay the same price per million tokens. Cache discounts and the Batch discount cover the whole window. Paid-plan pages also list context up to 1M, varying by model.
The rate stays flat, and the total still grows with the token count. Sending 900,000 uncached input tokens to Sonnet 5.5 costs 900,000 / 1,000,000 × $2 = $1.80, plus output. If those 900,000 tokens are a cache read: 900,000 × $0.10 / 1,000,000 = $0.09. Long-context cost is mostly “how large is the context” and whether that context is recomputed or served from cache.
Haiku 5.5 is the exception. Prompt length counts every input token, including cache reads and cache writes. A request over 100,000 tokens pays the higher prices for the whole request, even when part of it is a cache hit. Earlier requests keep the price they were billed at.
Example: 90,000 cache-read tokens + 15,000 new input tokens = 105,000, so the whole request uses the higher tier. The cache read at $0.05/MTok is $0.0045, and the new input at $0.50/MTok is $0.0075. Under 100,000 tokens, the cache read would be $0.01/MTok and the new input $0.10/MTok. The extra ten thousand tokens lift the cheap tier for the entire request.
Add the roughly 30% tokenizer increase: a repo context of about 80,000 tokens on the old tokenizer can land near or over the 100,000 line on Haiku 5.5. On Haiku, long context is a threshold. On Opus 5.5 and Sonnet 5.5, it is the volume of tokens itself.
What one Claude Code turn costs
Every Claude Code request sends the current conversation. Tool results, subagents, and repository contents all sit in context. The docs say prompt-cache lifetime on a subscription defaults to 1 hour. Once you draw on usage credits, the default drops to 5 minutes unless you set the TTL yourself. API keys and cloud providers also default to 5 minutes. A pause longer than that misses the cache, and the next request rewrites the whole history at the write price.
Use one fixed shape at list price (global routing, standard tier, 1-hour cache): 200,000 cached prefix tokens + 8,000 new input tokens + 4,000 output tokens.
| This turn | Sonnet 5.5 | Opus 5.5 |
|---|---|---|
| Cache warm (200,000 reads) | $0.076 | $0.152 |
| Cold start (200,000 written for 1 hour) | $0.856 | $1.712 |
Warm-turn math: Sonnet 5.5 is 200,000 × $0.10 / 1e6 + 8,000 × $2 / 1e6 + 4,000 × $10 / 1e6 = $0.020 + $0.016 + $0.040 = $0.076. Opus 5.5 is 200,000 × $0.20 / 1e6 + 8,000 × $4 / 1e6 + 4,000 × $20 / 1e6 = $0.152. A cold start prices the 200,000 tokens as a 1-hour write: Sonnet is $0.80 + $0.016 + $0.040 = $0.856; Opus is $1.60 + $0.032 + $0.080 = $1.712.
Assume 40 turns on an active day, with only the first turn cold and the rest hitting the 1-hour cache:
- Sonnet 5.5: 0.856 + 39 × 0.076 = $3.82 per day. Twenty such days are about $76.
- Opus 5.5: 1.712 + 39 × 0.152 = $7.64 per day. Twenty days are about $153.
- If every turn misses (5-minute TTL and longer pauses), Sonnet 5.5 is 40 × 0.856 = $34.24 per day.
These are list prices, for comparing plans. Pro and Max do not invoice this figure while you stay inside the allowance. The Session cost in /usage is a local estimate at list price. If the organization sets modelPricing, the figure uses contract rates. The authoritative bill is the Console Usage page, or the cloud provider’s invoice.
Which plan a month usually lands on
Put the subscription next to the list-price sketch and four working styles fall out. The numbers are orders of magnitude for choosing a plan, not an invoice.
- A few short tasks a week: stay on Pro, $20 monthly or about $17 on the annual plan. With usage credits off, the bill is the subscription.
- One Sonnet 5.5 block each workday, cache kept warm: about $3.82 a day and $76 over 20 days. That often still fits inside Max 5x at $100. After the weekly cap or the five-hour window, the overflow is usage credits at list rates.
- Opus 5.5 by default, same 40 turns: about $7.64 a day and $153 over 20 days. That sits closer to Max 20x at $200, or to an API workspace with its own cap.
- Cache misses often, or several agents in parallel: Sonnet can reach $34.24 a day. In an agent team each teammate has its own context, so tokens scale roughly with headcount. The docs suggest Sonnet for teammates and shutting them down when the work is done.
An enterprise pilot can start with the published $13 per active day as an envelope, then replace it with /usage from your own machines. The average is pulled up by a few long sessions; 90% of people stay under $30 per active day.
How to keep the bill down
The levers, from largest effect to smallest:
- Keep the cache warm. Subscriptions default to 1 hour. On usage credits, set the TTL back to 1 hour so a short pause does not rewrite 200,000 tokens.
/clearbetween unrelated tasks. Session cost resets, and the next block does not carry the previous history.- Default to Sonnet 5.5. Save Opus 5.5 for hard, long tasks. On the same warm turn, Opus is about twice Sonnet ($0.152 versus $0.076).
- Watch 100,000 on Haiku 5.5. Cache reads count toward prompt length. Compact history before you cross the line; that is cheaper than a 5× rate on the whole request.
- Keep always-on MCP servers and a huge CLAUDE.md small. They sit in every turn’s prefix. Cache hits make them cheap. A cold start pays the write rate.
- Give the Claude Code workspace its own spend limit on API teams, and request TPM for the team size. The docs suggest 200k–300k TPM per person for teams of 1–5.
Xcode is a separate bill
The dollars above cover the model. iOS signing, simulators, xcodebuild, and device debugging run on a Mac and are billed as a machine, not on Anthropic’s token invoice. A repo that stays on one cloud Mac keeps Claude Code’s context steadier, and the cache prefix is less likely to miss because the machine changed.
Tokens for the model, a cloud Mac for the build
Claude Code’s subscription and API set the inference bill. Signing, archives, and regression still need a Mac that stays online. Zilmac cloud Macs are rented by configuration, separate from the model bill.
Read the two bills apart, and scale them apart. — View cloud Mac plans
FAQ
Is Claude Code included in Pro, or is it a separate purchase?
Every paid plan includes Claude Code. Free does not. Pro is $20 a month, or $200 a year (about $17 a month). It shares the allowance with web, desktop, and mobile. When the five-hour window runs out often, look at Max 5x ($100/month) or Max 20x ($200/month).
Is long context still surcharged past 200K?
Opus 5.5 and Sonnet 5.5 bill the 1M window at the standard rate, so 900,000 tokens and 9,000 tokens pay the same price per million tokens. On Haiku 5.5, once a single prompt passes 100,000 tokens, input moves from $0.10 to $0.50 and output from $0.50 to $2.50. Cache reads and writes rise with them, and cached tokens count toward that threshold.
Are the dollars in /usage my subscription invoice?
On Pro and Max, the Session dollars are a local estimate at list price. Inside the allowance the subscription is still $20, $100, or $200. The figure shows which turn was expensive. API keys, usage credits, and cloud bills settle in tokens, on the Console or the cloud invoice.
How much does it cost to keep going after the allowance?
With usage credits on, the overflow is billed at standard API rates: about $0.076 for a warm Sonnet 5.5 turn and about $0.856 for a cold start. The cache default drops from 1 hour to 5 minutes, so a pause is more likely to become a cold start. You can set a monthly spend limit at the same time. At the limit, wait for the window to reset or raise the cap.