Claude Code Pricing (October 2026): Pro vs Max vs API, and Which One to Pick

Short answer: Claude Code pricing starts at $20 a month with Claude Pro ($17 a month if you pay yearly). Claude Max costs $100 a month (5x Pro usage) or $200 a month (20x). Team seats are $25 or $125 a month per person ($20 or $100 billed yearly). The Free plan doesn’t include Claude Code. If you’d rather pay per token, you can sign in with a Claude Console API key and pay standard API rates, for example $2 per million input tokens and $10 per million output tokens on Sonnet 5.5. Every subscription runs on a rolling 5-hour limit plus a weekly limit, and your chats on claude.ai draw from the same pool.

Last updated: October 21, 2026. All prices and limits below were checked that day on claude.com/pricing, the Claude API pricing docs, the Claude Help Center articles on Claude Code with Pro or Max, the Max plan and the Team plan, and the Claude Code docs on costs and prompt caching. Prices are US prices before tax.

Full disclosure: I don’t pay Anthropic for Claude right now (I run Claude Code against a cheap API, more on that below), so this isn’t a “my Max bill” story. It’s what I’d do before spending my own money: read the fine print, look at what heavy users report, and do the math.

The fine print matters because the forum complaints this month aren’t about the sticker price. They’re about the weekly limit. On r/Anthropic, a Max 20x subscriber used up a whole week in about two and a half days; on X, people report losing 30% to 50% of a week in one day. Meanwhile other Max users say they never get past half. Same price, different habits.

Claude Code pricing at a glance (October 2026)

Plan	Price	Claude Code?	Usage vs Pro	Good for
Free	$0	No	n/a	Trying Claude chat, not coding
Pro	$20/mo, or $17/mo billed yearly ($200 up front)	Yes	1x (baseline)	Learning, side projects, a few hours a week
Max 5x	$100/mo (monthly billing only)	Yes	5x per 5-hour session	Daily coding, hitting Pro limits often
Max 20x	$200/mo (monthly billing only)	Yes	20x per 5-hour session	All-day agents, parallel sessions
Team Standard	$25/seat/mo, or $20 billed yearly (2 to 150 seats)	Yes	1.25x per session	Small teams that also want admin and SSO
Team Premium	$125/seat/mo, or $100 billed yearly	Yes	6.25x per session	The power users on a team
Enterprise	$20/seat/mo plus usage at API rates (annual)	Yes	Billed by usage	Larger companies
API pay-as-you-go	Per token, no subscription	Yes, via a Console API key	No weekly cap, you pay for every token	Automation, CI, bursty or overflow work

Three details from the plan pages that most comparison posts skip:

• “5x” and “20x” are per 5-hour session. The Max help article defines both tiers as multiples of Pro’s per-session allowance. The weekly cap is separate and not published as a multiple. One unofficial tracker that measures real accounts put a Max 20x week at about 9.7 times a Pro week (October 12 to 19). Treat that as a rough estimate, but the lesson holds: 20x buys longer bursts more than 20 times the week.
• Max includes $100 or $200 a month in API credits, but they don’t pay for Claude Code. The help center says they can’t be used in Claude Code or the Claude apps, including for extra usage. They only help if your own product calls the Claude API.
• Fable, Anthropic’s top model, has its own rules. On Pro it runs on paid usage credits. On Max it’s capped at 50% of your weekly limits, and Max has a separate weekly Fable limit.

The three ways to pay for Claude Code

There are three billing routes, and mixing them up is how people get surprise charges.

1. Subscription (Pro, Max, Team). You sign in with your Claude account. Usage counts against your 5-hour and weekly limits. No per-token bill.
2. Usage credits on top of a subscription. When you hit a limit, you can turn on usage credits and keep working at standard API rates until you reach a monthly spend limit you set. It shows up as an extra charge on your bill.
3. API key (Claude Console). You pay per token for everything, with no weekly cap. Good for automation and for agents that run unattended.

The trap: if an ANTHROPIC_API_KEY environment variable is set on your machine, Claude Code uses that key instead of your subscription, and you get billed API rates for work your plan would have covered. Anthropic’s help center calls this out directly. If you’re paying for Pro or Max, check it:

# macOS / Linux / Git Bash
echo "${ANTHROPIC_API_KEY:+API key is set - Claude Code will bill the API}"

# Windows PowerShell
if ($env:ANTHROPIC_API_KEY) { "API key is set - Claude Code will bill the API" }

Then run /status inside Claude Code. It shows which account and model the session is using, so you can confirm you’re on your plan.

Claude Code usage limits: what they mean in practice

Here’s how the limits work, according to the help center and the pricing FAQ:

• Rolling 5-hour session limit. Your session allowance resets on a rolling five-hour window. Pro gives at least 5x the Free plan’s usage per session; Max 5x and 20x multiply Pro’s.
• Weekly limit on all paid plans. It resets at a fixed day and time assigned to your account, no matter when you subscribed or started working. Settings > Usage shows the next reset.
• One shared pool. Claude on web, desktop and mobile, Claude Code in the terminal, and the IDE extensions all draw from the same limits. A long research chat in the afternoon is coding budget you won’t have in the evening.
• No fixed message count. How far the allowance goes depends on context size, model, effort level and features. Anthropic also reserves the right to add other caps for capacity.
• What happens at the limit. You wait for the reset, upgrade, or turn on usage credits. Some accounts are getting a small “wrapping up” allowance so Claude Code can finish the step it’s in the middle of.

Day to day: the 5-hour limit decides how long one sitting lasts; the weekly limit decides how many good days you get. That’s why Pro users complain about the 5-hour wall and Max users about the weekly one.

What burns the allowance is context, not the number of prompts. Claude Code sends your whole conversation with every request, so per the costs docs a one-line question in a session open all day still pays for the whole history. A popular X thread this week added the other half: a setup that loads lots of MCP tool definitions and a long CLAUDE.md pays for all of it again every time the prompt cache expires.

Is the Claude Code Max plan worth it?

Max makes sense when the limits cost you more than $80 or $180 a month in lost time. In practice, that looks like this:

• Pro to Max 5x: you hit the 5-hour limit most workdays and lose an hour or more each time.
• Max 5x to Max 20x: you hit the weekly limit most weeks. Anthropic’s help article frames it the same way: upgrade if you consistently hit limits. One bad afternoon doesn’t count.
• Stay where you are: you hit a limit a few times a month. Fix your context first.

Heavy users who never hit the cap tend to split the work. One Max 20x subscriber on r/ClaudeCode said they rarely pass 50% of the week because the expensive model only plans, a small model searches the codebase and a mid-size model writes the code. People who burn a week in two or three days describe the opposite: the top model on everything, long sessions, lots of subagents.

My opinion: don’t buy Max 20x to solve a context problem. If a week of Max 5x disappears in two days, it’s usually a session that never gets cleared, the top model on routine edits, or lots of always-on tooling. Fixing those is free.

API pay-as-you-go: a worked cost example

If you skip the subscription and pay per token, here are today’s list prices for the two models most people use in Claude Code (per million tokens):

Model	Input	5-min cache write	1-hour cache write	Cache read	Output
Sonnet 5.5	$2	$2.50	$4	$0.10	$10
Opus 5.5	$4	$5	$8	$0.20	$20

Now one made-up but realistic session. These are my assumptions, not anyone’s bill: a focused two-hour session with 60 requests, an average context of 80k tokens per request, and about 2.5k output tokens per reply. That’s 4.8 million input tokens. Assume a healthy cache: 4.56M served from cache, 0.2M written to the 5-minute cache, 0.04M uncached, plus 0.15M output.

Line	Tokens	Sonnet 5.5	Opus 5.5
Cache reads	4.56M	$0.46	$0.91
Cache writes (5 min)	0.20M	$0.50	$1.00
Uncached input	0.04M	$0.08	$0.16
Output	0.15M	$1.50	$3.00
Per session		$2.54	$5.07
Two sessions per workday, 22 days		about $112/mo	about $223/mo

Three things jump out:

1. Output is 3% of the tokens and about 60% of the cost. Asking for diffs instead of full-file rewrites does more than trimming your prompt.
2. A heavy month on Opus lands right around the Max 20x price. Anthropic’s costs page puts the average enterprise developer at about $13 per active day and $150 to $250 a month. If your API estimate is steadily over $100 a month, a subscription is likely cheaper; if it’s $30, Pro plus occasional usage credits wins.
3. The cache is everything. Without it, the Sonnet input alone would cost $9.60 instead of about $1. That’s why long idle breaks and editing CLAUDE.md mid-session are expensive.

One API-only setting: with an API key, Claude Code uses the 5-minute cache for the main conversation by default. If you take long breaks, set promptCacheTtl to 1h (v2.1.242 or later). One-hour writes cost more ($4 instead of $2.50 on Sonnet), so it only pays off if you’d otherwise rebuild the cache after every break.

{
  "promptCacheTtl": "1h"
}

To get your own number, work normally for two days on an API key and check the Console usage page, or /usage at the end of each session.

Decision guide: which Claude Code plan fits you

Your usage	Pick	Why
A few hours a week, learning or a side project	Pro ($20)	Enough for a couple of sessions a week, and you also get Claude chat
Every weekday, hitting the 5-hour wall now and then	Pro + usage credits with a low spend limit	You pay API rates only on bad days
Every weekday, blocked most days	Max 5x ($100)	Five times the session size; cheaper than API for steady work
Parallel agents all day, weekly limit hit most weeks	Max 20x ($200)	Biggest sessions; check the weekly cap before upgrading
CI jobs, scheduled agents, scripts	API key with a workspace spend limit	Plans are sized for a person at the keyboard
Bursty: nothing for a week, then a 3-day sprint	API key, or Pro plus usage credits	You don’t pay for idle weeks
Two or more people	Team Standard, Premium seats for the heavy users	Per-member limits, central billing
Very tight budget	Pro for the hard thinking, a cheap API model for the long loops	See the budget lane below

If you’re also weighing Codex or Cursor at the same price points, my Claude Code vs Codex vs Cursor comparison puts all three side by side, and the real monthly cost of an AI indie dev stack shows $0, $40 and $150 setups.

How to check your Claude Code usage

All of these are in the official commands reference:

• /usage shows the session cost estimate, your plan’s 5-hour and weekly usage bars, and on paid plans a breakdown of what’s eating your allowance (skills, subagents, MCP servers) with suggestions. Press d or w to switch between the last day and the last week. /cost and /stats are aliases for it.
• /status shows your version, model, account and connectivity. Use it to confirm you’re on the subscription and not an API key.
• /context shows what fills your context window right now.
• /usage-credits opens your usage-credit settings (subscription logins only).
• /rate-limit-options shows your choices when a limit blocks you: wait and continue automatically after the reset, add usage credits, or upgrade.
• Outside the terminal, Settings > Usage on claude.ai shows the current session, the weekly limit and the reset time.

The /usage breakdown only counts sessions on that machine, not claude.ai or other computers.

Stretch your limits: settings and a prompt to copy

Most of this comes from Anthropic’s costs page; I’ve gone deeper in 15 ways to reduce Claude Code token usage.

1. Make the cheaper model the default. Put this in .claude/settings.json in your project (or .claude/settings.local.json if only you should get it):

{
  "model": "sonnet",
  "effortLevel": "medium",
  "env": {
    "CLAUDE_CODE_SUBAGENT_MODEL": "haiku"
  }
}

Switch to Opus with /model when you hit a genuinely hard problem, then switch back. Thinking tokens are billed as output, so lower effort on routine edits saves real money.

2. Clear between unrelated tasks. /clear costs nothing. /compact reads the whole conversation to summarize it, so it’s a big request itself.

3. Keep the always-loaded stuff small. Anthropic suggests keeping CLAUDE.md under 200 lines and moving workflows into skills, which only load when used. Disable MCP servers you aren’t using with /mcp (my MCP servers guide has a lean setup).

4. Plan before you build. Press Shift+Tab to get to plan mode on anything bigger than a small fix. A wrong direction you approve and then undo is the most expensive thing an agent can do.

5. Use this prompt at the start of a heavy session:

Before you start: we're on a usage budget.
- Read only the files you need. Ask before reading more than 8 files.
- Show changes as minimal diffs, never full-file rewrites.
- Don't restate my request or the plan back to me.
- Run only the tests related to the change, and show only failures.
- When the task is done, stop. Suggest a /clear if the next task is unrelated.

The budget lane: Claude Code on DeepSeek

This is the setup I actually use. Claude Code can talk to any Anthropic-compatible endpoint, and DeepSeek offers one. It’s not the smartest model you can put behind Claude Code, but it’s the cheapest I know of. DeepSeek’s pricing page today lists deepseek-flash at $0.003 per million cache-hit input tokens, $0.15 per million cache-miss input, and $0.60 per million output off-peak, and double that at peak (01:00 to 04:00 and 06:00 to 10:00 UTC on weekdays).

Run the worked example through those prices and the same session costs about $0.14 off-peak, roughly $6 for 44 sessions. That’s a ballpark only: tokenizers differ, and so does how much work each model gets done per token. For my real numbers, see my AI stack cost post: about $40 for 5.3 billion tokens in 30 days, almost all of it cache hits.

DeepSeek’s guide uses environment variables; I prefer one project’s local settings, so it can’t take over every Claude Code session on the machine:

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.deepseek.com/anthropic",
    "ANTHROPIC_AUTH_TOKEN": "<your DeepSeek API key>",
    "ANTHROPIC_MODEL": "deepseek-flash[1m]",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "deepseek-flash[1m]",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "deepseek-flash[1m]",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "deepseek-flash",
    "CLAUDE_CODE_SUBAGENT_MODEL": "deepseek-flash"
  }
}

Two gotchas. First, never commit a file that contains a key: use .claude/settings.local.json and make sure it’s in .gitignore. Second, DeepSeek maps any model name starting with claude-opus to its pricier Pro model, so set the Opus alias explicitly as above if you want Flash prices everywhere. For other no-subscription options, see my free Claude Code alternatives.

Pitfalls and my take

• Comparing “API-equivalent dollars” across weeks. A September r/ClaudeCode thread started as “my weekly cap got cut in half” and ended, after the poster checked their own logs, as “the measuring stick changed”: new model prices and cache-read accounting moved the dollar math, not necessarily the cap. Compare the same model on the same kind of work.
• Buying Max for the API credits. They don’t cover Claude Code. Only count them if your product already calls the Claude API.
• Forgetting the pool is shared. Heavy chat use on claude.ai eats your coding week.
• Leaving agents running. Scheduled tasks, idle check-ins and agent teammates keep sending your full context while you’re away (the costs docs list each one).
• Usage credits with no spend limit. If you turn them on, set a monthly cap the same day.

My take: start on Pro, measure for two weeks with /usage, fix your context, then decide. Most people asking “is Max worth it” in forums would get more from a cleaner session than a bigger plan. The ones who really need Max know it, because they’re blocked every day on paid work.

FAQ

How much does Claude Code cost per month?

$20 on Pro ($17 billed yearly), $100 on Max 5x, $200 on Max 20x, and $25 or $125 per Team seat per month ($20 or $100 billed yearly). On an API key there’s no monthly fee: you pay per token, which for a heavy daily user is often $100 or more a month.

Is Claude Code free?

No. The Free Claude plan doesn’t include Claude Code. The app costs nothing to install and can point at another provider’s API, but you always pay someone for the model. New Claude API accounts get a small free credit for testing.

What are the Claude Code usage limits?

Every subscription has a session limit that resets on a rolling five-hour window and a weekly limit that resets at a fixed time assigned to your account. Max adds a separate weekly limit for Fable. Claude chat and Claude Code share both limits. Anthropic doesn’t publish exact token or message numbers, so watch /usage or Settings > Usage.

Is the API cheaper than a subscription for Claude Code?

For light or bursty use, often yes. For steady daily use, usually no: the worked example above lands at about $112 a month on Sonnet and $223 on Opus, while Max costs $100 or $200 with no per-token bill. Measure a week before you decide.

If you’re new to all this, start with Claude Code for non-developers, and for the full build-to-launch workflow, see my AI workflow for indie products.