Claude Code pricing: every plan, its usage limits and a developer's real monthly cost

Claude Code pricing comes in two shapes. You either pay a flat subscription (Pro, Max, Team or Enterprise seats) and live inside usage windows that reset every five hours and every week, or you pay per token through the Claude API, Amazon Bedrock or Google Cloud and live with a bill that scales with every file Claude reads. As of October 2026, the subscription route runs from $20 to $200 a month for an individual, while Anthropic’s own documentation puts the API-billed average at about $13 per developer per active day.

Which route is cheaper depends less on the sticker price than on three things: how many hours a day a developer runs agentic sessions, which model those sessions default to, and whether prompt caching is doing its job. This guide covers every way to pay for Claude Code, what the usage limits mean in practice, worked monthly costs per developer, and the controls that keep a team’s spend predictable. Every price here was checked against Anthropic’s pricing pages and help centre in mid-October 2026.

Claude Code pricing at a glance

Claude Code is not sold on its own. It is bundled into every paid Claude plan and is also available to anyone with a Claude API key or a cloud account that serves Claude models. The table lists each route with its US list price as of 15 October 2026, taken from Anthropic’s pricing page and the plan articles in the Claude help centre.

Two details in that table catch people out. The first is that Max is billed monthly only, according to the Max plan article, so there is no annual discount on the plans most heavy users want. The second is that the Enterprise seat fee covers access but, in the help centre’s words, “doesn’t include any usage”: every token is billed separately at API rates, as the Enterprise billing article explains.

Figure 1: The choice is mostly about usage pattern and admin needs; the per-token routes win when you need metering more than a flat price.

How Claude Code usage limits work on a subscription

A subscription does not meter dollars. It meters two windows: a session limit that resets every five hours and a weekly limit that resets at a fixed time assigned to your account. Anthropic does not publish either as a token count, and the allowance shrinks faster with longer conversations, bigger files and heavier models.

The Pro plan article says the number of messages “will vary based on message length, including the length of files you attach, the length of your current conversation, and the model or feature you use”. The pricing page’s FAQ adds the relative sizes: Pro gives at least five times the Free plan’s usage per five-hour session, Max gives 5x or 20x Pro, and Team Premium seats give 5x a Standard seat. Anthropic also reserves the right to limit usage “in other ways, such as weekly and monthly caps or model and feature usage”.

One pool for chat and code

The most consequential rule is that the pool is shared. According to the Pro and Max Claude Code article, “these limits are shared across Claude and Claude Code, meaning all activity in both tools counts against the same limits”. IDE usage in VS Code, Cursor and JetBrains draws from the same pool. A developer who spends a morning on a large refactor in the terminal can find that the afternoon’s research chat is rate limited too.

On Team plans the limits apply per member rather than to the team as a whole, so one heavy user cannot exhaust a colleague’s allowance. On usage-based Enterprise plans there are no per-seat windows at all: usage is billed at API rates and controlled with spend limits instead, which makes Enterprise behave much more like the API than like Pro or Max.

Fable has its own ceiling

Anthropic’s most capable generally available models, Fable 5 and Fable 5.1, sit outside the normal arithmetic. The Fable plan article says that on Max and on Team Premium seats you can spend up to 50% of the weekly allowance on Fable at no extra cost, and that Fable draws on the weekly allowance faster than other Claude models. On Pro and Team Standard seats, Fable is not in the plan at all: it runs on pay-as-you-go usage credits from the first request. A promotion that let Pro users run Fable 5 inside their limits ended on 19 July 2026.

What happens at the limit

When a limit is reached, Claude Code shows a message naming which window ran out and when it resets. The costs documentation distinguishes the cases: a session or weekly limit is shared across all models, so switching with /model does not help, while a model-specific “Opus limit” message can be worked around by switching to another model family. Since v2.1.234, Claude Code can wait and resume an interrupted task automatically after the reset.

The other options are to upgrade, or to turn on usage credits, which switch requests to pay-as-you-go at standard API rates once a window is exhausted. Per the usage credits article, credits are prepaid, can carry a monthly spend limit or be set to unlimited, and support auto-reload. They are off until you enable them.

The environment-variable trap

One billing surprise has nothing to do with limits. If ANTHROPIC_API_KEY is set in your shell, Claude Code uses it instead of your subscription login, “resulting in API usage charges rather than using your subscription’s included usage”, as the Pro and Max article warns. A developer who once exported a key for a side project can spend weeks paying API rates on top of a Max subscription without noticing. Running /status shows which credential the session is actually using.

Pro and Max: the individual plans

For one person, the decision is Pro versus one of the two Max tiers. Pro at $20 a month includes Claude Code with the shared five-hour and weekly windows; Max 5x at $100 and Max 20x at $200 multiply Pro’s per-session allowance by five and twenty, add higher output limits and priority access at busy times, and include Fable inside the plan.

Pro’s annual option is the one discount in the individual line-up: the pricing page shows $17 a month with $200 billed up front. Max has no annual price. Anthropic states it does not offer standing discounts on individual plans.

What the multiples buy

Because the windows are relative rather than absolute, the right way to read the tiers is in Pro-sessions. A Max 5x subscriber gets five Pro sessions’ worth of usage per five-hour window for five times the price. A Max 20x subscriber gets twenty for ten times the price, which makes 20x the cheapest per unit of allowance among the individual plans. The weekly cap still applies, so 20x does not mean twenty full windows every five hours all week.

Usage also depends on the model. Anthropic’s Claude Code usage guide says Opus “uses meaningfully more of your quota” and that Opus “costs several times more per turn than Sonnet”. The model configuration docs show that since v2.1.280 the default model on Pro, Max, Team, Enterprise and the API is Opus 5.5, so a new user who never touches /model is spending allowance at the Opus rate.

The API credits that do not apply

Max and Team plans include monthly credits for the Claude Platform: $100 on Max 5x, $200 on Max 20x, and on Team $20 per Standard seat and $100 per Premium seat, pooled and capped at $500 a month. The monthly API credits article is explicit that these credits do not cover “interactive Claude Code in the terminal, IDE, desktop, or web” or extra usage, and they do not roll over. They are useful for building on the API with the Agent SDK, but they do not stretch a Claude Code budget.

Team and Enterprise seats

Organisations have two seat-based options. The Team plan, for 2 to 150 people, mixes Standard and Premium seats with per-member windows; Enterprise charges a flat seat fee and bills all consumption at API rates. Both put the controls in the claude.ai admin console rather than the developer’s terminal.

Team: Standard versus Premium

The Team plan article gives the prices and the multiples. Standard seats cost $25 per member per month billed monthly or $20 billed annually and carry 1.25x Pro’s per-session allowance. Premium seats cost $125 monthly or $100 annually and carry 6.25x Pro. Seat types can be mixed, so the usual pattern is Premium for engineers who live in Claude Code and Standard for everyone else.

The comparison with Max is instructive. A Premium seat on annual billing costs the same $100 as Max 5x but carries 6.25x Pro rather than 5x, plus SSO, role-based permissions and organisation-level spend controls. A team that would otherwise expense individual Max subscriptions usually gets more allowance per dollar, and far more administrative control, on Team Premium. Every Team seat includes Claude Code, and members can enable usage credits to continue past their seat allowance.

Enterprise: seat plus metered usage

Enterprise is priced at $20 per seat per month, billed annually, with a 20-seat minimum, and “usage cost scales with model and task”, in the pricing page’s wording. The seat buys access to Claude on web, desktop and mobile plus Claude Code and Cowork; the help centre states that Enterprise seats “don’t come with an individual token allowance”. A 20-seat minimum therefore means at least $4,800 a year in seat fees before any usage.

Billing then splits by contract type. Self-serve Enterprise buys usage up front in credits that draw down across the whole organisation; when the balance hits zero, usage stops for everyone. Sales-assisted Enterprise is invoiced monthly in arrears, so heavy use raises the bill rather than blocking colleagues. Organisations with US-only inference switched on pay 1.1x standard API rates on Claude Opus 4.6, Sonnet 4.6 and later models.

The Enterprise consumption guide describes the control surface: spend limits at organisation, group and user level, pooled group budgets in beta, model allowlists and effort caps per role, spend-threshold alerts at 75% and 90% of an organisation limit, and an Analytics API that groups cost by user, model or RBAC group. It also warns that Claude Code sessions are “significantly more token-intensive than chat” and recommends rolling Claude Code out to groups in waves rather than to everyone on day one.

Claude API pricing for Claude Code

On API billing, Claude Code costs whatever its tokens cost at the model’s list price. The table shows the current models Claude Code is most likely to run, from Anthropic’s pricing documentation as of October 2026, in US dollars per million tokens.

Several modifiers sit on top. Fast mode, a research preview on the first-party API, charges $8 input and $40 output on Opus 5.5, exactly double, and caching multipliers apply on top. US-only inference through inference_geo adds 1.1x to every token category on Claude 4.6 and later. Thinking tokens bill as output, and Claude Code’s docs note that Opus 5.5, Sonnet 5.5, Haiku 5.5 and the Fable models always use extended thinking, so effort level is the lever rather than switching thinking off. Batch pricing halves the bill but does not apply to interactive coding sessions.

Haiku 5.5’s two-tier price matters more for Claude Code than for most workloads. The pricing page says a request’s prompt length “counts all of its input tokens, including cache reads and cache writes”, so a Claude Code turn that carries a long conversation can cross 100,000 tokens and pay five times the headline rate even when most of the prompt is cached. Haiku is cheapest for short, self-contained subagent tasks, not for a main conversation that has run all morning.

A tokeniser note applies when comparing against older figures: Anthropic says Claude 4.7 and later models produce “approximately 30% more tokens for the same text” than Sonnet 4.6 and earlier. A per-token price that looks equal across generations is not equal per line of code.

API tiers and spend caps

The Console route also comes with ceilings that teams discover the hard way. Per the rate limits documentation, each usage tier carries a monthly spend cap: $500 on Start, $1,000 on Build and $200,000 on Scale, with Custom arranged by contract. At the cap, the API returns HTTP 429 until 00:00 UTC on the first of the next month. Five developers spending Anthropic’s quoted $150 to $250 a month each would cross the Build tier’s cap, so a new organisation should request a tier increase before rolling Claude Code out, not after the first outage.

Request and token limits apply per organisation in requests, input tokens and output tokens per minute. On most current models only uncached input counts towards the input-token limit, which means good caching raises effective throughput as well as lowering cost. The Claude Code costs page recommends per-user allocations that fall as teams grow, from 200,000 to 300,000 tokens per minute per user for one to five users down to 10,000 to 15,000 for 500 or more, because fewer people are active at the same moment in larger organisations.

Bedrock, Vertex and other cloud routes

Claude Code can also run against Amazon Bedrock, Google Cloud’s Agent Platform (Vertex AI) and Microsoft Foundry, billed per token to the cloud account. This suits organisations with committed cloud spend or data-residency requirements, but the pricing and controls move to the cloud provider.

Anthropic’s pricing page sends readers to Amazon Bedrock pricing and Google Cloud’s Claude pricing for the official rates, and notes that from Claude Sonnet 4.5, Haiku 4.5 and Opus 4.5 onwards, regional and multi-region endpoints on both clouds carry a 10% premium over global endpoints. Bedrock’s own page notes a 50% cut in Sonnet 5.5 cache-read pricing from 7 October 2026. Fast mode is first-party only and not available on the clouds.

Two Claude Code behaviours affect the cloud bill directly. The Bedrock guide warns that “if you don’t pin a primary model, you’re billed at the Opus rate”, because the primary model defaults to Opus 5.5. It also exposes Bedrock service tiers through ANTHROPIC_BEDROCK_SERVICE_TIER (default, flex or priority) to trade cost against latency. And Claude Code sends no metrics from the cloud back to Anthropic, so the analytics dashboards and the Claude Code Analytics API do not cover cloud usage: per-developer attribution needs OpenTelemetry export or a gateway.

What prompt caching does to the Claude Code bill

Prompt caching is the reason Claude Code is affordable on per-token billing at all. Every turn resends the whole conversation, the project’s CLAUDE.md and every file Claude has read; caching lets the API bill that repeated prefix at a fraction of the input price instead of in full.

On Opus 5.5 and Sonnet 5.5, a cache read costs 0.05x the base input price, half the 0.1x multiplier that older models use. Writing to the five-minute cache costs 1.25x the input price and writing to the one-hour cache costs 2x. The Claude Code /usage example in Anthropic’s documentation shows the typical shape: 940,000 cache-read tokens against 50,000 cache-write, 1,200 uncached input and 5,300 output tokens in a session that cost $0.55. Reads dominate the token count, so their price dominates the input bill.

The cache lifetime is different on subscriptions and the API

The Claude Code prompt-caching page explains a default that changes the economics of breaks. On a subscription within plan usage, Claude Code requests the one-hour TTL for the main conversation. On an API key, a cloud provider or usage credits, the default is five minutes. A developer on the API who steps away for ten minutes comes back to a cold cache, and the next message rewrites the entire context at the cache-write price.

A worked example shows the size of the effect. Take an Opus 5.5 session holding 200,000 tokens of context, and a developer who returns after a ten-minute gap twelve times in a day. With the five-minute TTL, each return rewrites 200,000 tokens at $5 per million, or $1.00, so the gaps cost $12 a day. With a one-hour TTL each return is a cache read at $0.20 per million, about $0.04, or under $0.50 for the twelve returns; the one-hour writes cost $8 per million rather than $5, but on a day with a million tokens of writes that premium is about $3. The net saving is roughly $8.50 a day, or about $170 a month over twenty working days.

Setting promptCacheTtl to 1h, or CLAUDE_CODE_PROMPT_CACHE_TTL=1h, gives API and cloud users the longer cache for the main conversation; subagents have their own setting. Through an LLM gateway set with ANTHROPIC_BASE_URL, part of the one-hour request travels in the anthropic-beta header, which the gateway must forward unchanged. On Bedrock, one-hour support varies by model and region.

Actions that throw the cache away

Some habits silently disable caching. The caching page lists switching models, turning on fast mode, connecting or removing an MCP server, enabling or disabling a plugin, denying an entire tool, compacting, accumulating many images, upgrading Claude Code and, on most models, changing effort level as actions that can invalidate the cached prefix. On Opus 5.5, Sonnet 5.5, Haiku 5.5 and Fable 5.1 with an API key or subscription, changing effort keeps the cache, but not on Bedrock or Google Cloud. Since v2.1.251 the /usage screen shows a “Prompt cache (main)” line with the share of input served from cache and the likely cause of the last miss, which is the quickest way to see whether caching is working.

Worked examples: what one developer costs per month

The figures below are illustrative, built from October 2026 list prices and a token mix modelled on the session shape in Anthropic’s own /usage example. They are not measurements of any team. Anthropic’s published benchmark for comparison, from the costs documentation, is an enterprise average of “around $13 per developer per active day and $150-250 per developer per month”, with 90% of users below $30 per active day.

A typical active day

Assume a developer runs Claude Code for most of a working day and the session mix comes to 20 million cache-read tokens, 1 million cache-write tokens on the five-minute TTL, 200,000 uncached input tokens and 300,000 output tokens including thinking.

• On Opus 5.5: $4.00 for cache reads, $5.00 for cache writes, $0.80 for fresh input and $6.00 for output, a total of $15.80.
• On Sonnet 5.5: $2.00, $2.50, $0.40 and $3.00, a total of $7.90.
• On Opus 5.5 without caching: all 21.2 million input tokens billed at $4 per million, plus the same output, comes to $90.80.

Figure 2: Cache reads are 93% of the tokens but about a quarter of the cost; output and cache writes are where the money goes, and model choice halves both.

Two lessons fall out of the breakdown. Output, including thinking, is the largest single line on Opus, so effort level matters as much as model choice. And cache writes cost more than all the reads combined, which is why cold caches after breaks, compaction and frequent context changes are expensive.

Four developer profiles

The “cheapest subscription that likely fits” column is a judgement, not a guarantee, because Anthropic does not publish the windows as token counts. The mixed profile lands inside Anthropic’s quoted $150 to $250 range, which suggests the assumptions are in the right neighbourhood.

Reading the table

For a developer who uses Claude Code on most working days, a subscription is cheaper than list-price API billing at every profile from typical upwards. The API wins in three situations: very light or irregular use where a $20 plan would sit idle; automation such as CI jobs and scheduled agents, which should never run on a personal subscription; and organisations that need per-token metering, cloud billing or contract pricing. The heavy profile is also where agent teams appear: Anthropic’s costs page says agent teams use “approximately 7x more tokens than standard sessions” when teammates run in plan mode.

For a team, the arithmetic changes. Ten developers on Team, with seven Standard seats and three Premium seats on annual billing, cost $440 a month in seats ($550 on monthly billing), plus any usage credits beyond the allowances. The same ten developers at the mixed API profile would cost about $2,050 a month at list price. On Enterprise, the same team would pay the 20-seat minimum of $400 a month in seat fees plus its usage at API rates, which buys controls and compliance rather than a lower token price. For how these line items fit into the wider cost of running AI in production, see our line-by-line ledger of what an AI product costs, and for why per-token prices alone mislead, our analysis of who keeps the saving when inference prices fall.

How teams control Claude Code spend

Spend control comes down to three things: making the cheap choice the default, capping what each person can spend, and seeing spend per developer early enough to act. Anthropic ships controls for each billing route; the gaps are mostly on cloud and multi-provider setups.

Figure 3: Subscriptions cap spend by design; every per-token route needs someone to set a dollar limit.

Make the cheap path the default

Model choice is the largest lever. Anthropic’s guidance across the costs page and the consumption guide is consistent: Sonnet for most coding, Opus for hard debugging and architecture, Haiku for mechanical subagent work. The opusplan alias automates the common pattern of planning on Opus and executing on Sonnet. Administrators can enforce this through managed settings: availableModels restricts which models developers can select, an organisation default model applies on Enterprise, and role-level effort caps limit thinking spend.

Context hygiene is the second lever. The costs page recommends /clear between unrelated tasks, custom compaction instructions, keeping CLAUDE.md under about 200 lines and moving workflow-specific instructions into skills that load on demand, preferring CLI tools over MCP servers where both exist, and using hooks to filter test and log output before Claude reads it. Background traffic is small, typically under $0.04 per session, but scheduled tasks, idle goal check-ins and teammates each resend the full context when they fire.

Cap spend per person

The controls differ by route. Team and Enterprise admins set spend limits for usage credits at organisation, group and member level in the claude.ai admin console. Console API organisations get an automatically created “Claude Code” workspace whose spend limit and rate limit can be set separately from production workloads, which stops a busy afternoon of coding from starving a customer-facing application. Cloud users rely on their provider’s budgets and alerts. Anthropic’s self-hosted Claude apps gateway adds per-developer daily, weekly or monthly spend caps that return HTTP 429 once a developer passes the cap.

See spend per developer

Visibility varies too. Team exports a spend report CSV per user and model; Enterprise adds the Analytics API. Console customers get a Claude Code dashboard and the Claude Code Analytics API. For cloud routes, Anthropic’s docs point to OpenTelemetry export from each developer’s machine or a gateway that logs spend per key. One subtle setting helps finance teams: modelPricing in managed settings makes the cost figures in /usage, the status line and OpenTelemetry reflect contracted rates rather than list prices, without changing what Anthropic charges.

Running Claude Code through a gateway on API billing

Teams on API or cloud billing often add an AI gateway between Claude Code and the provider. Claude Code supports this natively through ANTHROPIC_BASE_URL and a gateway credential, and the gateway becomes the place where per-developer identity, budgets, rate limits, cost logs and model routing live. Anthropic’s costs documentation lists an LLM gateway as one of three ways to attribute cloud spend per user, alongside OpenTelemetry and its own Claude apps gateway.

The options fall into three groups. Anthropic’s Claude apps gateway is self-hosted and Anthropic-specific. LiteLLM, named in Anthropic’s docs as a proxy several large enterprises use, tracks spend by key. General-purpose AI gateways go further by routing across providers, which lets a team send Claude Code’s cheap sub-tasks to cheaper models. Our ranking of AI gateways for Claude Code, Codex CLI and Cursor compares five on exactly these criteria, and the AI gateway explainer covers the request path in general.

How Bifrost handles Claude Code spend

Bifrost, an open-source AI gateway written in Go by Maxim AI, documents a Claude Code integration that maps directly onto the cost problems above. Claude Code points ANTHROPIC_BASE_URL at the gateway’s /anthropic path and sends a Bifrost virtual key as its token, so developers need no Anthropic account and the organisation’s provider keys never reach a laptop.

Each developer’s virtual key can carry its own dollar budget and its own token and request rate limits, and can be restricted to particular providers and models. The budget and limits documentation describes a hierarchy in which a request must pass every applicable budget: the provider configuration, the virtual key, the team and the customer. Budgets reset daily, weekly, monthly, quarterly or yearly, optionally aligned to calendar boundaries in UTC, so “$300 per developer per calendar month, $5,000 for the platform team” is a configuration rather than a spreadsheet. Costs are calculated from model pricing, token counts and cache status, and each request appears in the gateway’s logs with its virtual key or user, provider and model. That combination of budgets, limits and audit is the AI governance layer that per-token Claude Code billing otherwise lacks.

Routing is where a gateway can lower the bill rather than only cap it. Claude Code maps its sonnet, opus and haiku aliases through environment variables, and Bifrost’s routing rules can match those requests by model name and the claude-cli user agent and send them to a chosen target, for example a Bedrock or Vertex deployment, or a cheaper model for the Haiku slot that handles background and subagent work. Claude Code sends an x-claude-code-session-id header on every request, and Bifrost uses it for session affinity, so a session stays on the provider and key that served it and keeps hitting the same prompt cache. For teams that want to stay on subscriptions, the guide also documents a mode in which developers sign in with their Claude plan and send the virtual key in an x-bf-vk header, keeping subscription billing while the gateway applies governance and logging.

Bifrost’s published benchmark reports 11 µs of added overhead per request at 5,000 requests per second on an AWS t3.xlarge, which is negligible against model latency measured in seconds. Enterprise tier. Advanced controls such as SSO, RBAC, audit logs, guardrails and clustering come with Bifrost Enterprise; virtual keys, budgets, rate limits and routing are in the open-source gateway.

Choosing a Claude Code plan in October 2026

Most of the decision follows from usage pattern and from who needs to see the bill.

1. You code with Claude a few times a week. Pro at $20, or $17 a month annually, is the cheapest route. Leave usage credits off unless you want a pay-as-you-go overflow, and check that no ANTHROPIC_API_KEY is set.
2. You run Claude Code most of the day. Max 5x at $100 fits a Sonnet-first habit; Max 20x at $200 fits an Opus-default habit or parallel sessions. At list prices the API would cost $158 to $316 a month for the same work.
3. You are buying for a team of 2 to 150. Team with Premium seats for heavy coders and Standard seats for everyone else usually beats expensed Max subscriptions on allowance per dollar and adds spend limits and SSO.
4. You need compliance, audit or more than 150 seats. Enterprise’s $20 seat plus API-rate usage buys controls rather than cheaper tokens; budget with Anthropic’s $150 to $250 per developer per month as a starting point and use group spend limits from day one.
5. You need per-token metering, CI or cloud billing. Use the Console API, Bedrock or Vertex, request a higher API tier before rollout, pin the model rather than inheriting the Opus default, set the one-hour cache TTL, and put per-developer budgets in front of the shared credential with workspace limits or a gateway.

The single habit that matters on every plan is the same one Anthropic’s support team keeps repeating: clear context between tasks and pick the model for the job. Claude Code pricing looks like a choice between $20, $100 and $200, but for most teams the bigger number is the gap between a session that reuses a warm cache on Sonnet and one that drags a cold, day-old Opus context into every message.