How Much Claude Code Costs per Month

There are two ways to pay for Claude Code. A Claude subscription (Pro, Max, Ultra, Team, Enterprise) includes it. Its usage limits reset on a rolling five-hour window, and a weekly cap sits on top. An API key, through the Claude Console or a cloud provider, bills every token at list price. The only ceilings are the ones you set. Anthropic publishes averages for API use, and they are the best starting point for a budget. All prices and limits below are as of October 2026.

Source for every row: Manage costs effectively. The same page adds that per-developer costs "vary widely based on model selection, codebase size, and usage patterns such as running multiple instances or automation." An older "$6 per developer per day" figure still circulates in blog posts. It is not on the current page. The old URL now redirects, so we could not confirm it was ever there. Plan with the $13 figure.

Subscription plans

Anthropic's pricing page says "Claude Code is included in all paid plans". It adds that Claude Code "shares the same usage limits as the rest of your plan." Limits "reset on a rolling five-hour session window, and paid plans add weekly limits on top."

The $200 tier goes by two names. The pricing page calls it "Ultra". The help centre still calls it "Max 20x" and gives a different multiplier (20x per session rather than 10x per week). Both are official Anthropic pages, fetched on the same day. Because they disagree, the multiplier that applies today is not settled. A post from the @claudeai account on 30 October 2026 explains the gap. The Max 20x plan was renamed Ultra and prices are unchanged. The five-hour limit is being removed for verified Ultra accounts.

Three details affect cost. First, Claude chat and Claude Code share the limits (and so does Cowork on Team and Enterprise seats). A long chat session eats into the terminal budget. Second, the message "You've hit your session limit" refers to a seat-based window shared across all models. Switching with /model does not restore access. Only the model-specific "You've hit your Opus limit" can be worked around by moving to another model family. Third, Pro, Max, Team and Enterprise default to Opus 5.5, the most expensive of the three everyday models.

Every paid plan can turn on usage credits for work past the limit (older pages say "extra usage"). Credits are "billed at standard API rates" and cover both chat and Claude Code. Settings holds a monthly spending cap, auto-reload and alerts, and /usage-credits opens it from the terminal. Team owners set caps for the whole organisation, per seat group and per member. A member who reaches a cap has credits paused until the end of the month. Once Claude Code draws on credits, it drops the main conversation from the one-hour to the five-minute cache lifetime. It does so because you now pay per token.

API billing

On an API key, "Claude Code charges by API token consumption." The three models Claude Code resolves its aliases to (opus, sonnet, haiku) are priced per million tokens as follows.

A cache read costs 0.05x the input price on Opus 5.5 and Sonnet 5.5, and 0.1x on Haiku 5.5. Thinking tokens are billed as output. None of these three models lets you turn thinking off. Opus and Sonnet 5.5 bill the full 1M context at the standard rate; Haiku 5.5 moves to the higher row once a prompt passes 100k tokens. The October 2026 pricing snapshot has the rest of the price list.

How caching applies in Claude Code

Claude Code sends the whole conversation on every request. Without caching, "the API would reprocess your full history on every turn." Caching changes how the request is laid out. Stable content goes first (system prompt and tool definitions, then CLAUDE.md and rules, then the conversation). The API re-reads the unchanged prefix at the cache rate and processes only the new part in full.

The one-hour lifetime charges more per write (2x input instead of 1.25x) but survives a coffee break. From Claude Code v2.1.242, promptCacheTtl and subagentPromptCacheTtl override both defaults. Each model keeps its own cache. A /model switch therefore re-reads the whole history uncached, and so does every opusplan hop between planning and execution. Compacting, turning on fast mode and upgrading Claude Code also invalidate the stored prefix. So does adding or removing an MCP server whose tools load upfront. Editing files, editing CLAUDE.md mid-session, changing permission mode, invoking skills and spawning a subagent leave it intact.

Worked example of one 40-turn session

The example rests on four assumptions. Each turn is one API request, and a tool-call round-trip counts as a turn. The context grows evenly from 20k tokens at turn 1 to 120k at turn 40, about 2.6k tokens per turn. Each turn produces 2k output tokens, thinking included. All requests fall within the five-minute cache lifetime (API-key billing). Across the 40 requests, the model processes 2.8M input tokens in total. Caching writes 120k of those tokens once; the remaining 2.68M are cache reads.

The arithmetic shows two things. Caching cuts the session bill by about 4.7x on both models. A cached Opus session ($2.74) also costs less than an uncached Sonnet session ($6.40). The one-hour lifetime raises the write rate from 1.25x to 2x input. That adds $0.18 on Sonnet and $0.36 on Opus. After any gap longer than the lifetime, the next request re-writes the full context. At turn 40 that is a 120k-token write, about $0.30 on Sonnet and $0.60 on Opus. This is why "/compact costs the most when you resume an old session."

The first cached block is slightly dearer than the second because it includes the initial 20k-token write. After that, the cached figure per block barely moves, while the uncached one climbs with every turn.

What drives the bill

The reasons below come from Anthropic's costs page, from its list of why usage climbs in a long session and from its tips section. One pattern sits behind all of them. Claude Code sends the whole context on every request.

• Long context: "a one-line question in a session that has been open all day still draws usage for the whole conversation."
• Cache misses: "your first message after a break longer than the cache lifetime misses the cache and reprocesses your full context."
• Large files and verbose tool output: reading a 10,000-line log pulls tens of thousands of tokens into context, and every later turn re-reads them.
• Subagents and workflows: "every subagent, and every agent a dynamic workflow spawns, sends its own requests on top of the main conversation's." A subagent starts cold, because its prefix differs from the parent's.
• Agent teammates: "each active teammate keeps consuming tokens until it exits", and teams use about 7x the tokens of a standard session when teammates run in plan mode.
• Compaction: "/compact reads the conversation it summarizes, so compacting a large context is itself a large request." By default Claude Code compacts when the conversation reaches the model's context limit, with a few per-model exceptions. Setting autoCompactWindow (100k to 1M) changes that point.
• Idle work: scheduled tasks, cross-session messages and goal check-ins each start a new turn with the full context while you are away.
• Thinking: billed as output, with a default budget that "can be tens of thousands of tokens per request depending on the model."

The same page gives a blunt admin-side diagnosis. Unexpectedly high spend on an API or cloud-provider plan "usually traces back to long sessions that were never cleared or to Opus left as the default model."

Keeping a month under budget

• Watch the numbers. /usage (aliases /cost and /stats) shows session tokens and cost at list price, plus the plan-limit breakdown. From v2.1.251 it also reports a "Prompt cache (main)" hit ratio. It attributes usage to skills, subagents and MCP servers, with suggestions such as "Trim ~/code/api/CLAUDE.md". /context shows what fills the window. The --max-budget-usd flag in print mode (claude -p) stops the run once estimated spend reaches a dollar figure.
• Set caps. Pro and Max: a monthly spending cap on usage credits. Team and seat-based Enterprise: caps organisation-wide, per seat group and per member. API: only the auto-created "Claude Code" Console workspace supports per-user monthly spend limits. It can also take a rate limit "to cap Claude Code's share and protect other production workloads." Organisation-wide limits always apply on top.
• Clear between tasks. "/clear costs nothing" and resets the counters. Run /rename first so you can /resume later. Give /compact an instruction such as "Focus on code samples and API usage".
• Match the model to the task. "Sonnet handles most coding tasks well and costs less than Opus." Use model: haiku for simple subagents. A switch to Opus also applies to subagents that inherit the session's model.
• Keep CLAUDE.md under 200 lines and move specialised instructions into skills, which load only when invoked. Prefer CLI tools (gh, aws, gcloud) over MCP servers, and disable servers you are not using with /mcp.
• Keep noisy output out of context. Let hooks grep a log and return only matching lines; send test runs and documentation fetches to a subagent so only the summary comes back.
• Protect the cache. Do not switch models mid-session without a reason. On older models a change of effort level also resets the cache; on the 5.5 generation and Fable 5.1 it does not. Avoid opusplan on API billing if you toggle plan mode often. Lower effort with /effort for simple tasks.
• Keep teams small, run teammates on Sonnet, and shut them down when their work is done.

Subscription versus API

The two billing routes suit different usage levels. The API column below is plain arithmetic on Anthropic's published averages. The subscription column lists the plans that include Claude Code at that level. Anthropic does not publish how many hours of Opus or Sonnet a plan's limits cover, so the comparison stops at prices.

API versus subscription covers the general version of this question. For Claude Code, one fact decides it. Opus 5.5 is the default model on every plan and on the Anthropic API. A subscriber pays nothing extra for that default until the limit. An API user pays double Sonnet's rate from the first token.

Other coding agents

A fuller comparison of the IDE and agent tools is in the cost-efficient coding IDE guide. The budget guardrails for agents in general, including loops and parallel runs, are in how not to overspend with AI agents.

What to do next

• Run /usage at the end of your next three sessions and note the cache hit ratio and the cost line. Those figures make a better baseline than the $13 average.
• If you are on an API key, open the Console, find the "Claude Code" workspace and set a monthly spend limit and a per-user limit before anyone else joins.
• Change the default model to Sonnet 5.5 in /config and switch to Opus with /model only for the tasks that need it.
• Trim CLAUDE.md to the essentials and move the rest into skills; check the result with /context.
• If the bill is still unclear after a month, we audit Claude Code and agent spend as part of a wider LLM cost audit.

Sources

• Manage costs effectively, Claude Code docs
• Prompt caching in Claude Code
• Model configuration, Claude Code docs
• Claude pricing
• Pricing, Claude Developer Platform
• About Claude's Max plan usage
• Usage credits in Claude paid plans
• Workspaces, Claude Developer Platform
• Cursor pricing
• GitHub Copilot plans