How much does Claude Code cost? Plans, API and limits (2026)

What does Claude Code cost on a subscription?

Anthropic's pricing page lists four individual plans^[1]:

• Free: $0. Claude Code is not included.
• Pro: $17 a month with the annual discount ($200 billed up front), or $20 billed monthly.
• Max: $100 a month, with 5x Pro usage every five hours and every week.
• Ultra: $200 a month, with 10x Pro usage every week and no five-hour limit for verified accounts.

Claude Code is marked "Yes" for Pro, Max and Ultra and "No" for Free^[1]. Annual billing is available for Pro and Team, while Max and Ultra are billed monthly^[1]. Prices exclude tax and Anthropic says plans and prices can change^[1].

For organizations, the page lists Team and Enterprise. The FAQ says Enterprise is $20 per seat per month plus usage billed at API rates, billed annually^[1]. I could not find a Team seat price in the page text I read, so I leave it out.

Is Claude Code included, and what are the limits?

Yes. Anthropic's help center says one subscription covers Claude on web, desktop and mobile plus Claude Code in the terminal and supported IDEs^[2]. It also says activity in both tools counts against the same limits^[2].

There is no fixed message count. Most paid plans have a session limit that resets every five hours and weekly limits that reset once a week^[3]. Verified Ultra accounts have no five-hour limit, though weekly limits still apply^[1][4]. The five-hour window starts when you send your first message^[3]. How fast you burn through it depends on conversation length, features, model and effort level^[3].

Anthropic also says it may adjust limits to manage capacity and does not guarantee uninterrupted service^[3]. So a plan gives you a bounded amount of use, not unlimited use.

What happens when you hit the limit?

You have four options, per the help center for Pro: upgrade, enable usage credits, switch to a Console account with API credits, or wait for the reset^[2].

Usage credits are the one most people miss. Anthropic says they let Pro, Max and Ultra subscribers keep working after hitting a limit by switching to consumption-based pricing at standard API rates^[4]. You prepay, can set a monthly spend cap, and can turn on auto-reload^[4]. They are charged separately from your subscription and show up as additional charges on your bill^[4].

One rule here trips people up. The Max and Ultra plans include monthly API credits ($100 and $200). Anthropic says those cannot be used in Claude Code or the Claude apps, including for usage credits^[2][4]. They are for building on the Claude Platform, not for covering your coding overage.

How much does Claude Code cost per developer on the API?

Claude Code charges by API token consumption, and Anthropic's cost page says per-developer cost varies widely with model, codebase size and usage patterns^[5]. It gives one planning anchor: across enterprise deployments, the average is around $13 per developer per active day and $150 to $250 per developer per month, with costs below $30 per active day for 90% of users^[5].

Anthropic's advice is to start with a pilot group and measure before a wider rollout^[5]. Treat the $13 as a starting estimate for team budgets, not a promise for your own usage.

What are the API prices per token?

Anthropic's API pricing page lists these rates per million tokens (MTok) for current models^[6]:

• Claude Opus 5.5: $4 input, $5 for 5-minute cache writes, $0.20 for cache hits, $20 output.
• Claude Sonnet 5.5: $2 input, $2.50 cache writes, $0.10 cache hits, $10 output.
• Claude Haiku 5.5, prompts up to 100,000 tokens: $0.10 input, $0.125 cache writes, $0.01 cache hits, $0.50 output. Over 100,000 tokens it is $0.50 input and $2.50 output.
• Claude Fable 5.1: $10 input, $12.50 cache writes, $0.25 cache hits, $50 output.

Two notes from the same page. Models from Claude 4.7 onward use a newer tokenizer that produces roughly 30% more tokens for the same text^[6], so a per-token price comparison across generations understates the gap. And fast mode, offered for some Opus models, is priced at a premium and is not available with Batch^[6].

What does one session cost on the API?

Here is an illustrative example. The numbers are made up to show the arithmetic, not measured from Claude Code.

Say a session runs 30 requests. The conversation holds 80,000 tokens, written to the 5-minute cache once and read from cache on each request. Each request returns 3,000 output tokens. That is 2.4M cache-read tokens, 80,000 cache-write tokens and 90,000 output tokens. I am ignoring new tool output and thinking tokens, which would add cost.

At the published rates^[6]:

• Opus 5.5: 2.4 x $0.20 = $0.48 reads, 0.08 x $5 = $0.40 write, 0.09 x $20 = $1.80 output. About $2.68.
• Sonnet 5.5: $0.24 reads, $0.20 write, $0.90 output. About $1.34.
• Haiku 5.5: $0.024 reads, $0.01 write, $0.045 output. About $0.08.

The example assumes Claude Code reads history at the cached rate, which its cost page says it does when prompt caching applies^[5]. The output line is the biggest piece on the larger models, which is why thinking tokens matter. Anthropic says thinking tokens are billed as output tokens^[5].

Plan or API: which is cheaper?

It depends on how heavily you use it, and I cannot tell you your number. I can show the arithmetic.

Take Anthropic's $13 per active day average. Over 20 active days, that is $260 a month^[5]. Against that, Max is $100 and Ultra is $200^[1]. On those assumptions a plan looks cheaper for a heavy daily user, as long as the plan's limits are enough. The catch is that the $13 is an average from enterprise API deployments, not a plan comparison, and a plan has limits that API billing does not. If you hit them, you pay API rates anyway through usage credits^[4].

Light or occasional use usually points to Pro. Daily heavy use that keeps hitting limits points to Max, or to the API where you control the spend. That is my reading of the numbers, not Anthropic's advice.

Why does usage climb in a long session?

Anthropic's cost page lists the reasons^[5]:

• Long context. Claude Code sends your full conversation with every request. Even with prompt caching, a one-line question in a session open all day still draws usage for the whole history.
• Cache misses. Your first message after a break longer than the cache lifetime reprocesses your full context.
• Scheduled tasks, cross-session messages and goal check-ins that fire while the session is idle, each sending your full context.
• Subagents and agent teammates, which send their own requests on top of the main conversation.
• Compaction. Running /compact reads the conversation it summarizes, so compacting a large context is itself a large request. /clear costs nothing.

The page says the /usage command breaks this down and recommends a change for behaviors behind 10% or more of recent usage^[5].

How do you cut Claude Code costs?

The cost page gives a short list. These are the ones that matter most^[5]:

• Choose the model. Sonnet handles most coding tasks well and costs less than Opus. Use /model to switch mid-session, and set model: haiku for simple subagent tasks.
• Clear between tasks. Use /clear when you switch to unrelated work, because stale context is re-sent with every message.
• Compact with instructions, for example telling it what to preserve.
• Lower thinking effort. Extended thinking is on by default and the budget can be tens of thousands of tokens per request. You can lower effort with /effort or turn thinking off in /config. On Opus 5.5, Sonnet 5.5, Haiku 5.5 and the Fable models you cannot turn it off.
• Reduce MCP server overhead and delegate verbose operations to subagents.
• Write specific prompts for complex work instead of letting it explore broadly.

These are Anthropic's recommendations. I have not measured how much each one saves, and the size of the saving will vary with your project.

Which mistakes cost the most money?

Four come straight from Anthropic's own pages.

A leftover API key. If an ANTHROPIC_API_KEY environment variable is set, Claude Code uses it instead of your subscription, and you get API usage charges rather than your plan's included usage^[2]. If you pay for a plan and still see API bills, check this first. You can run /login to switch back to the subscription^[2].

Expecting Max credits to cover overage. They do not apply to Claude Code^[2][4].

Unlimited usage credits. The spend cap is optional, and you can set it to unlimited^[4]. Set a cap you can live with.

Subscribing through a phone app. For usage credits, Anthropic says you can only enable them on the web version of Claude^[4].

How do you track what you spend?

Claude Code has a /usage command that shows token use and, on plans, a breakdown of plan usage with recommendations^[5]. You can also show token counts in the status line^[5]. On Pro, Max or Ultra, the /usage-credits command opens Settings > Usage in the browser, where you can see balance, this month's spend and your monthly limit^[5].

For Console API organizations, the cost page says to use workspace spend limits and the Console cost reporting^[5]. For Team and Enterprise, usage inside the seat allowance is not metered in dollars, and spend limits for usage credits are set in admin settings^[5]. On Bedrock, Google Cloud or Foundry, billing and budgets live in your cloud console^[5].

One caution. Claude Code computes cost figures at list price by default, so if your organization pays contracted rates, the figures in /usage will not match your bill unless you set the modelPricing managed setting^[5]. Anthropic says the figures are estimates, not an invoice^[5].

How do you sign in and set it up?

Anthropic's setup docs say Claude Code requires a Pro, Max, Ultra, Team, Enterprise or Console account, and that the free claude.ai plan does not include it^[7]. You can also use it through Amazon Bedrock, Google Cloud's Agent Platform or Microsoft Foundry^[7]. After installing, you log in by running claude and following the browser prompts^[7].

If you are already logged in through a Console pay-as-you-go account and want your plan instead, run /login from inside Claude Code^[2].

Build a budget from work, not a subscription name

A useful budget separates three things: the fixed subscription, any usage-credit overage and any separately authenticated API work. Do not treat a subscription as a prepaid API wallet. Anthropic documents those as different billing paths, and the monthly API credits attached to Max and Ultra do not cover Claude Code^[2][4].

Here are three illustrative monthly budgets, not estimates of how much coding any plan buys. Taxes are excluded. The overage amounts are chosen spending allowances, not measured usage:

• Occasional individual use: $20 monthly Pro subscription, usage credits disabled, no separately billed API sessions. Planned total: $20. The tradeoff is accepting a pause when the included allowance runs out.
• Daily individual use: $100 Max subscription plus a self-imposed $30 usage-credit budget. Planned total: $130 if that entire allowance is spent, before tax. This does not prove Max can handle a particular workload. It limits how much the example user intends to spend beyond the plan.
• API-only experiment: no individual subscription allocated to the experiment, and a $50 workspace budget. Planned API allowance: $50. Whether it lasts a month depends on the models, tokens and task shape, not on the number of times someone opens the terminal.

The subscription prices come from Anthropic's pricing page^[1]; the extra budgets are mine. Individual usage-credit caps and Console workspace spend controls are documented in the help center and cost guide^[4][5]. A chosen budget is not a guarantee about billing enforcement timing or the final invoice. Confirm the controls on your own account before relying on them.

This is how I would choose between a bigger plan and occasional overage. First, write down the maximum total I want to spend. Then subtract the fixed plan price. The remainder is the most I would allocate to usage credits. If that leaves nothing, I would keep usage credits off rather than assume the subscription's name implies unlimited access.

Do the comparison over a normal week and a busy week. One urgent deadline can justify occasional overage without making a higher recurring subscription the right choice every month. Conversely, repeated pauses every afternoon are evidence to review the plan, not proof that an API account will be cheaper. Record actual costs and interruptions before changing the recurring commitment.

Use break-even arithmetic without promising equivalent capacity

At current monthly prices, the fixed-price gap from Pro to Max is $80, and from Max to Ultra is $100^[1]. Those differences are easy to calculate and useful, but they do not tell you how many tasks each plan will complete.

Suppose, as an illustrative example, someone pays $20 for Pro and spends $15 on usage credits in a typical month. That is $35 before tax. Moving to $100 Max would raise the fixed bill by $80 to avoid $15 of measured overage. On cost alone, that change does not follow from these numbers. It might still make sense if the user values fewer interruptions or the extra allowance, but that is a workflow decision rather than a demonstrated saving.

Now suppose a different Pro user spends $110 in usage credits. The combined bill is $130 before tax. Max's $100 fixed price becomes worth investigating, but it is not automatically a $30 saving. You still need to know whether that person's work fits inside Max's included limits. If it does not, the new total is $100 plus whatever usage-credit overage remains.

The same caution applies to the $13-per-active-day API average. Multiplying it by 20 days gives $260, but an average enterprise deployment is not a controlled comparison with your subscription. The vendor's monthly range and active-day average describe different summaries of usage. Do not force them into a precise forecast for one developer^[5].

My rule would be to compare actual monthly totals alongside completed work. Track time lost to limits, how often expensive models were needed and whether usage credits were spent on valuable tasks or repeated failed attempts. The cheapest invoice is not useful if work stops halfway through the tasks you bought the tool to do.

Diagnose the limit before buying more capacity

Several different messages can feel like the same problem: Claude Code stops. The response should depend on which ceiling you hit, not on a reflex to upgrade.

Anthropic's cost guide distinguishes these cases^[5]:

• A session or weekly usage limit is a subscription allowance. A limit shared across all models does not disappear when you switch models. A model-family-specific limit is different: switching outside that family can let work continue.
• An individual, organization or team spend-limit message means a usage-credit budget has been reached. Raising that budget is permission to spend more money, not a free reset of included usage.
• A context or auto-compaction warning is about the conversation's size. It is not the same as exhausting a subscription allowance.
• A rate-limit message while fetching the usage display can mean the display cannot refresh. It does not, by itself, mean Claude cannot continue your coding task.

Before paying more, read the exact message and check the reset time it shows. If an administrator owns the budget, pass along the message and the task that is blocked rather than requesting an unspecified larger allowance. A useful request is a bounded one: what work remains, what budget is needed and when that extra permission should end.

There is also a reporting trap. Anthropic says `/usage` can show last-known plan bars from the previous 60 minutes when the usage endpoint is rate limited, and labels them accordingly^[5]. A stale bar is not a live balance. Retry when the message permits and use the account's billing surface for the authoritative financial record.

Read the cache numbers before blaming the model price

A long conversation can be expensive even when your next prompt is short. The cost guide says each request carries conversation history, and prompt caching changes the rate charged for repeated content rather than making that content free^[5]. That is why a cheap-looking follow-up can still move the usage bar.

The documented Prompt cache (main) line in `/usage` helps separate two questions: how much input was served from cache, and how often the session had to rebuild cached content. It shows request counts, cache-served input share, misses and whether the cache is warm. This display needs Claude Code v2.1.251 or later, and the likely-cause text for a cache miss needs v2.1.260 or later^[5].

Use those numbers as diagnostics, not as a savings percentage. A high cache-hit share does not imply the whole request is nearly free: output and thinking still cost money, and the amount of cached history can be large. A low share may reflect a new task or an expected rebuild rather than waste. The display covers the main conversation, not subagents, and `/clear` resets its session statistics^[5].

My practical sequence would be to note the session's task, inspect the cache line, and compare it with the usage breakdown. If an unrelated old task dominates the context, start fresh. If the current task still needs that history, compact carefully rather than deleting needed requirements just to lower a number. Save the resulting code and task outcome alongside the cost so the comparison has meaning.

Run a small team pilot before buying for everyone

Anthropic recommends a pilot to establish a baseline before wider rollout^[5]. I would make that pilot representative rather than selecting only the people with the smallest tasks.

Include someone doing routine fixes, someone exploring an unfamiliar repository and someone handling a larger change with tests. Keep a short record for each active day: billing route, model, completed task, usage-credit or API spend, interruptions and the amount of human correction needed. Avoid mixing API dollars with a subscription's local token-cost estimate. Anthropic says that session estimate is intended for API users, not an additional subscription bill^[5].

For a team budget, separate fixed seats from variable usage. As illustrative arithmetic, five developers each allocated $150 a month for API use imply $750 of variable budget. Ten imply $1,500. Those are chosen allocations, not predictions, and they do not include any separate seats, taxes or cloud charges. Replace the allowance with measured pilot data before making a purchasing decision.

Assign reporting and budget controls to the correct system. Anthropic documents usage-credit limits in the Claude Team or Enterprise admin settings, API controls in Console workspaces, and cloud-provider costs in the provider's billing console^[5]. Its cost guide also says cloud-provider usage is not covered by Anthropic's Claude Code analytics dashboards. Do not call a partial dashboard a complete team bill.

Finally, define an owner for unexpected spend. A developer should know whom to ask when a budget blocks an urgent task, and the administrator should know whether the request concerns a usage allowance, a money cap or a shared API rate limit. A pilot is complete when the team can explain both the cost and what useful work it bought, not merely when everyone has successfully logged in.

What I did not test

I did not run Claude Code, measure real session costs or compare it against other coding tools. The $2.68, $1.34 and $0.08 figures are arithmetic on published rates under stated assumptions. Plan limits are not published as fixed message counts, so I cannot say how many hours of work each plan covers. Those numbers depend on your model, codebase and habits.

What should you pick?

My judgment, based on the documentation above:

• Trying it out or coding a few hours a week: Pro, with usage credits off or capped low.
• Coding most days and hitting limits: Max, and watch the weekly limit.
• Need predictable team spend controls: Team or Enterprise with spend limits, or Console workspaces with limits.
• Want exact per-token control or automation: API billing, with a workspace spend limit.

Whatever you pick, set a spend cap on usage credits, check for a stray ANTHROPIC_API_KEY, and run /usage after your first week.

FAQ

Sources

1. 01Plans and pricing - Claude (opens in a new tab)
2. 02Use Claude Code with your Pro, Max, or Ultra plan - Claude Help Center (opens in a new tab)
3. 03How do usage and length limits work? - Claude Help Center (opens in a new tab)
4. 04Manage usage credits for paid Claude plans - Claude Help Center (opens in a new tab)
5. 05Manage costs effectively - Claude Code docs (opens in a new tab)
6. 06Pricing - Claude API docs (opens in a new tab)
7. 07Set up Claude Code - Claude Code docs (opens in a new tab)

Elsewhere on this site

The LLM cost optimization guide covers caching, batching and routing in depth, and the LLM API cost calculator lets you try your own token counts.