Claude Code pricing comes in two forms. You either use it inside a Claude subscription, where it shares one usage allowance with Claude chat, or you pay per token through the Anthropic API. On Anthropic's pricing page, checked on 10 November 2026, Pro is $17 a month billed annually ($200 up front) or $20 monthly, Max is $100 a month, Ultra is $200 a month, Team seats are $20 (Standard) or $100 (Premium) a month billed annually, and Enterprise is $20 a seat a month plus usage at API rates. Ultra is the plan Anthropic used to call Max 20x: same price, 10x Pro's weekly usage and no five-hour limit for verified accounts. On the API, the default model, Opus 5.5, costs $4 per million input tokens and $20 per million output tokens. The free plan does not include Claude Code. The rest of this guide covers which plan to buy, the limits, what a session costs in tokens, and what a solo founder, a five-person team and a heavy agentic user would pay.
Every way to pay for Claude Code
Prices are in US dollars, before tax, as Anthropic's pricing page showed them on 10 November 2026.
| Plan | Billed annually | Billed monthly | Claude Code | Usage, in Anthropic's words |
|---|---|---|---|---|
| Free | $0 | $0 | Not included | Limited usage every 5 hours and every week |
| Pro | $17 a month ($200 a year) | $20 | Included | At least 5x more usage per 5-hour session than Free |
| Max (was Max 5x) | Not offered | $100 | Included | 5x Pro usage every 5 hours and every week |
| Ultra (was Max 20x) | Not offered | $200 | Included | 10x Pro usage every week, no 5-hour limit for verified accounts |
| Team, Standard seat | $20 a seat | $25 a seat | Included | More usage than Pro |
| Team, Premium seat | $100 a seat | $125 a seat | Included | 5x more usage than Standard seats |
| Enterprise | $20 a seat, plus usage at API rates | Annual only | Included | Usage billed at API rates |
| Anthropic API (Console) | Pay per token | Pay per token | Included | Your organisation's API rate limits |
Which Claude Code plan should you buy?
| You are | Buy | Cost a month | Move up when |
|---|---|---|---|
| Trying it on side projects | Pro, billed annually | $17 ($200 a year) | You hit the five-hour limit on most days you code |
| Coding in Claude Code most of the day | Max | $100 | You run out before the weekly reset, or the five-hour window breaks your flow |
| Running long agent sessions all day | Ultra | $200 | Rarely; turn on usage credits for the odd heavy week |
| A team of 2 to 150 | Team, mostly Standard seats | $20 a seat, billed annually | Someone hits limits every week: give that person a $100 Premium seat |
| 20 or more people who need SCIM and audit logs | Enterprise | $20 a seat plus usage at API rates | Usage-based Enterprise has no per-seat limit to outgrow |
| CI jobs, bots and scripts | An API key from the Claude Console | Pay per token | Use a workspace spend limit, not a bigger plan |
For people, a subscription usually beats the API: Anthropic's own average is $150 to $250 per developer a month, above the price of Max. For automation, we use an API key with a spend limit so a CI job never eats a developer's allowance.
Is Claude Code free?
The software is free to install, but using it is not. Anthropic's plan comparison marks Claude Code as not included on the Free plan, and every way of running it draws on either a paid plan or API credit. The cheapest entry is Pro at $17 a month on an annual plan. The other route is a Claude Console account, where you buy prepaid API credit and pay only for the tokens you use.
Claude Code Pro vs Max vs Ultra
Pro is for regular but not all-day use. Max ($100) gives 5x Pro's usage in every five-hour window and every week. Ultra ($200) is the old Max 20x under a new name: 10x Pro's weekly usage and, for accounts Anthropic has verified, no five-hour limit, so a long session is capped only by the weekly allowance. Verification is automatic; if Settings > Usage shows no current-session bar, your account is verified. Both are billed monthly only. Both include Fable, Anthropic's top model, for up to half the weekly limit, priority access at busy times, and $100 or $200 a month in API credits for the Claude Platform, which are separate from your coding allowance.
Claude Code for teams
The Team plan is for 2 to 150 people, and Claude Code is included with every seat. You can mix Standard and Premium seats, so only the heavy users need the $100 seat; Premium seats also get Fable for up to half their weekly limit. Team adds SSO, central billing, server-managed Claude Code settings and a Claude Code analytics dashboard, and admins can turn on usage credits with spend limits for the organisation, a group or one member. Team plans also carry monthly API credits, which Anthropic says can't be used in Claude Code. Enterprise needs at least 20 seats and works differently: the seat is $20 a month and all usage is billed at API rates, with no per-seat usage limit on usage-based plans. It adds SCIM, audit logs, custom data retention and role-based access.
Usage limits, exactly as Anthropic states them
Anthropic does not publish limits as a number of messages or tokens. Its pricing FAQ says usage depends on the length and complexity of conversations, the model and the features you use, "so there's no fixed message count". What it does state:
- Two windows. Most plans have a session limit that resets every five hours and a weekly limit on top. Ultra drops the five-hour limit for verified accounts and keeps the weekly one.
- Fable has its own ceiling. On Max and Ultra, Fable can use up to half the weekly limit. On Pro, Fable is paid from usage credits.
- One pool. Claude chat on web, desktop and mobile and Claude Code in the terminal or IDE all draw on the same limits.
- Discretionary caps. Anthropic says it may limit usage in other ways, such as weekly and monthly caps or model and feature usage.
- Team seats reset on a rolling five-hour window and a weekly window, and the allowance is shared with Claude chat and Cowork.
When you hit a limit you can wait for the reset, move up a plan, or turn on usage credits, which bill further use at standard API rates with a monthly spend cap you set. Depending on your plan and seat, Fable requests may bill to usage credits instead of your allowance. Once you are on usage credits, Claude Code also drops the main conversation's prompt cache from one hour to five minutes, which is cheaper to write.
Claude Code API pricing
On the API, or once usage credits kick in, you pay per million tokens (MTok). These are the current models on Anthropic's API pricing page, checked on 10 November 2026.
| Model | Input | Cache write (5 min) | Cache write (1 hour) | Cache read | Output |
|---|---|---|---|---|---|
| Fable 5.2 | $8 | $10 | $16 | $0.20 | $40 |
| Opus 5.5 (Claude Code's default) | $4 | $5 | $8 | $0.20 | $20 |
| Sonnet 5.5 | $2 | $2.50 | $4 | $0.10 | $10 |
| Haiku 5.5, prompts up to 100K tokens | $0.10 | $0.125 | $0.20 | $0.01 | $0.50 |
Claude Code's model settings say the default resolves to Opus 5.5 on Pro, Max, Team, Enterprise and the API. Anthropic's own cost guidance is to use Sonnet for most coding and keep Opus for hard reasoning. Fast mode on Opus 5.5 costs twice the standard rate, and US-only inference costs 1.1 times.
What a Claude Code session costs on the API
Claude Code sends the whole conversation with every request, and each round of tool results is another request. Prompt caching is what keeps that affordable: history already sent is re-read at the cache-read rate. On an API key, Claude Code caches the main conversation for five minutes by default; on a subscription, within your plan's usage, it asks for a one-hour cache.
Here is a working model, and it is our arithmetic, not Anthropic's. Take one focused hour with 60 requests, an average context of 60,000 tokens of which 90% comes from cache, and 1,500 output tokens per request. Each request is then 54,000 cached tokens, 6,000 newly cached tokens and 1,500 output tokens.
| Model | Per request | Per hour (60 requests) |
|---|---|---|
| Opus 5.5 | $0.011 + $0.030 + $0.030 = $0.071 | about $4.25 |
| Sonnet 5.5 | $0.005 + $0.015 + $0.015 = $0.035 | about $2.12 |
| Opus 5.5 with no cache hits | $0.24 + $0.03 = $0.27 | about $16.20 |
Three hours a day on Opus comes to roughly $13. That lines up with what Anthropic reports in its cost documentation: across enterprise deployments, about $13 per developer per active day and $150 to $250 per developer per month, with 90% of users below $30 per active day. The last row shows why a long session left open over a break, which misses the cache, costs far more than one that is cleared between tasks.
The costs that are not on the pricing page
- Review time. Every change Claude Code makes still needs a person to read it. As an illustration, a senior engineer who spends an hour a day reviewing AI-written pull requests at $100 an hour costs about $2,000 a month in review alone, which is more than any plan here.
- CI minutes. The Claude Code GitHub Action runs on GitHub-hosted runners, which use your Actions minutes, on top of the tokens each run consumes.
- Rework. Code that passes a demo and fails under real users gets written twice. The fix is tests, review and a clear spec, not a bigger plan.
- The wrong login. If an
ANTHROPIC_API_KEYenvironment variable is set and you approve it (or run with-p, where it is always used), Claude Code uses it instead of your subscription, and the usage is billed at API rates./statusshows which login is active. - Background requests. Session recaps, idle compaction and prompt suggestions can use tokens while you are away from the keyboard. Each can be turned off in settings.
- Agent teams. Anthropic says agent teams use about 7x more tokens than a standard session when teammates run in plan mode.
Three worked examples
All three are our arithmetic on the prices above, checked on 10 November 2026.
A solo founder building an MVP
Start on Pro at $200 a year. If you hit the five-hour limit most days, move to Max at $100 a month ($1,200 a year), and only go to Ultra ($2,400 a year) if Max still stops you or the five-hour window keeps cutting off long agent runs. Compare that with the API: Anthropic's average of $150 to $250 per developer per month is more than Max costs, so a founder coding every day is usually better off on a subscription. Turn on usage credits with a low monthly cap for the odd heavy week rather than upgrading for it.
A five-person product team
On the Team plan, five Standard seats are $100 a month, or $1,200 a year billed annually ($1,500 billed monthly). If two of the five are heavy users, give them Premium: three Standard and two Premium seats come to $260 a month, $3,120 a year. All five on Premium is $6,000 a year. Enterprise is not an option at this size because of the 20-seat minimum. On the API, Anthropic's averages would put five developers at $750 to $1,250 a month, so seats are cheaper unless usage is light and irregular.
Heavy agentic use on the API
Say a company runs Claude Code headless in CI to review 400 pull requests a month, and one engineer runs agent teams for four hours a day. Using the session model above, a review of 25 requests at a 40,000-token average context, 90% cached, with 1,000 output tokens each, on Sonnet 5.5 is about $0.59, so 400 reviews are about $236 a month plus GitHub Actions minutes. Four hours a day on Opus at roughly 7x a normal session's tokens is about $119 a day, or $2,380 over 20 working days. At this level, set a workspace spend limit in the Claude Console, move subagents to Sonnet or Haiku, and cap each CI run with --max-turns.
Taking it to production
Most projects built with Claude Code never need outside help. A side project, an internal tool or a prototype that proves an idea is fine as it is. The gap shows up when real users, payments or customer data arrive: access rules that hold, keys kept out of the browser, tests, error monitoring, backups and a deploy you can roll back. Our Prototype Production Review checks exactly those areas (security including Supabase row-level security, exposed keys and auth; the data model; performance; and deploy) for $2,500 fixed over 5 business days, and you get a graded report and a fix plan. The fee is credited in full to a build with us started within 60 days. If we then fix and launch it, the work is done by an embedded team at $3,000–$7,500 per engineer per month.
If you are still choosing tools, our Claude Code vs Cursor comparison covers both side by side, including what each costs. They are not exclusive: Claude Code runs in any terminal, including the one inside Cursor, on the same subscription.
