How Much Does Claude Code Cost?

Claude Code has two totally different pricing shapes. On a subscription (Pro, Max, Team, or Enterprise) you pay a fixed monthly price and Claude Code is bundled in with a usage allowance. Pro starts at $20 if billed monthly source per month ( $17 Per month with annual subscription discount ($200 billed up front) source ), and Max starts From $100 Per month source for a choice of two higher usage tiers. On the API or a cloud provider (Amazon Bedrock, Google Cloud’s Agent Platform, Microsoft Foundry) there is no flat fee at all: you pay per token, and the bill is a direct function of how much context Claude Code sends on every turn. The sticker price on the pricing page answers half the question. The other half, cost per unit of actual work, is what most people asking this are really trying to find out, and it depends far more on how you use the tool than on which plan you picked.

Plan pricing

Full current numbers and footnotes live on the official pricing page; check it before budgeting, since plan prices and usage multipliers change.

Do you need Claude Pro for Claude Code? Yes, for the subscription path. The Free plan does not include Claude Code at all. Pro is the cheapest tier that does, and it is enough for most individual use; Max exists for people who burn through Pro’s allowance regularly, not for people who merely want a higher-end model. The two Max tiers (five times and twenty times the Pro usage) sit under one starting price on the pricing page rather than two separate published dollar amounts, so check the page directly for the current split.

API and cloud-provider billing works differently

If you use Claude Code with an API key instead of a subscription, whether Anthropic’s own API or through a cloud provider, there is no seat price and no plan tier. You pay per input and output token, at whatever rate that model and provider charges, for every request Claude Code sends. This is the mode enterprise deployments typically run, and Anthropic’s own cost management documentation publishes real usage figures from that population: the average cost is around $13 per developer per active day and $150-250 per developer per month, with costs remaining below $30 per active day for 90% of users source across enterprise deployments.

Two numbers worth separating: idle cost and active cost. Background token usage, the housekeeping Claude Code does between your actual requests, is typically under $0.04 per session source . That is close to nothing. The real driver of the bill is active session cost, and that scales with tokens sent per turn, not with how long you leave a session open.

Why two developers on the same plan pay wildly different real costs

On a subscription, everyone pays the same flat fee, but two engineers can consume completely different shares of the same usage allowance, or pay completely different API bills for the same number of days worked. The variable is not skill or plan tier: it is context size per turn, multiplied by number of turns. A session that keeps resending a large, mostly-irrelevant conversation history costs more per message than one that stays focused, regardless of what either engineer is accomplishing. Long sessions also compound this: a stale prompt cache after a break, goal check-ins, and /compact itself all add token volume that has nothing to do with the actual task. See our token usage guide for the mechanics of what inflates a request and how to keep it down.

This is also why “is Claude Code worth it” does not have one answer. On a fixed-price plan, the cost is sunk the moment you subscribe; the return you get is entirely a function of how much useful work fits inside your allowance before you hit a limit. See our usage limits guide for how those windows work and what happens when you hit one.

Cost per unit of work, not per seat

The number that actually answers “is this worth what I’m paying” is cost per finished task, and almost nobody publishes it because it requires tracking real outcomes against real spend. In our own workspace, each finished task is logged as a ticket, the internal name shiploop uses for a unit of dispatched work. From our own workspace’s operational log (PROOF.md), across a sample of thirty-two resolved tickets measured from the window when cost telemetry was wired in, the mean cost per resolved ticket was $4.49 shiploop PROOF.md , the median was $3.03 shiploop PROOF.md , and the range ran from $1.34 shiploop PROOF.md to $12.00 shiploop PROOF.md . Every figure came straight from Claude Code’s own total_cost_usd field, not an estimate.

Read that with its caveats attached, because they matter more than the headline number: the sample is small, the window starts only from when telemetry was added (so it excludes earlier, unmeasured work), and the ticket mix skews toward harder, opus-tier tickets from a self-referential harness rather than routine floor-tier work. That makes it closer to an upper bound on typical cost than a representative average, and it describes one workspace’s mix of tasks, not a general benchmark for what a ticket “should” cost. The point of publishing it isn’t the dollar figure: it’s the method. Cost per resolved unit of work is measurable, from data Claude Code already gives you, and it is a far more honest number than a plan price.

How to track your own cost

Several tools exist depending on how deep you want to go:

• /usage inside any session shows a live session block: total cost, API duration, wall duration, code changes, and a breakdown by model.
• If your organization has negotiated rates, the modelPricing managed setting lets /usage reflect your contracted price instead of Anthropic’s list price.
• The Console dashboard and the Analytics API give account-wide, cross-session totals rather than per-session estimates.
• OpenTelemetry export is the option built for streaming per-user token and cost metrics into your own monitoring stack in close to real time.

One caveat that matters: the dollar figure /usage shows you is computed locally, on your machine, from token counts at list price (or your modelPricing override). It is an estimate for your own visibility, not an invoice, and it resets whenever /clear starts a new session.

/usage

The shiploop angle

On a subscription, the marginal cost of any single token is effectively zero until you exhaust your usage window; you have already paid for the allowance whether you use it efficiently or not. That means the lever worth pulling is not “spend less money,” it is “get more finished work out of the same allowance before you hit the limit,” which is a throughput problem, not a pricing problem.

shiploop is a dispatch harness built around exactly that lever: trimming what gets sent on every request so more of the allowance goes to actual work. In one measured worker spawn, trimming the default tool schema list cut the tool-schema portion of the first-turn request by 66.7% shiploop PROOF.md , which brought the total request size down by 34.5% shiploop PROOF.md . That is one spawn on one CLI version, n=1, not a controlled study, and the source says so; treat the shape as informative and the exact figure as a snapshot that will drift. The direction is the point: smaller requests per turn mean more turns fit in the same subscription window before you hit a usage limit, which is the only thing a fixed-price plan actually rations.

Last updated 2026-09-04.