Claude Code pricing guide: team budgets and API fallbacks

Quick answer: two meters, one budget

Claude Code has no single price tag once more than one developer touches it. Anthropic sells access two ways: a flat per-seat subscription with rolling usage caps, or metered API billing with no cap and no included allowance. Most teams end up running both, seats for people who work interactively in an editor, API keys for CI jobs, scheduled agents, and the developers who blow through a seat cap most weeks. The number that actually decides the budget conversation is not the seat price. It is the token volume every developer's sessions generate, multiplied by the per-token rate the request is billed at. Two teams of five identical developers can land several hundred dollars apart in the same month for one reason: one team put a spending cap and a fallback model on every key, and the other team shared a single uncapped key across the whole roster. The rest of this guide works through what a team actually spends, why the bill surprises people who skip the setup, and how to wire a fallback chain so a rate limit or a budget cap degrades a request instead of stopping someone mid-task.

Where a team's Claude Code bill actually comes from

Seats and API keys solve different problems, and most teams eventually need both. A seat plan fits a developer who has Claude Code open in an editor for a few hours a day and occasionally hits a weekly cap: the interruption is annoying, but a human can wait for the window to reset. It fits badly with anything unattended, because seat plans are licensed to a person, and a rolling cap is built to interrupt a human, not to fail safely inside a script. That gap is where API keys and fallback routing earn their cost. A CI pipeline, a batch code-review job, or an overnight agent needs a key it can call at three in the morning with nobody watching for a cap warning. The moment a team adds one of those jobs, the budget conversation stops being about seat count and starts being about per-key limits, model tiers, and what happens automatically when a key gets close to running out.

• Seat cost is fixed per person per month, covers interactive chat and Claude Code inside the editor, and is capped by rolling usage windows that reset weekly.
• API cost is metered per input and output token, with no seat and no cap, billed against whatever key made the request.
• Seat billing is attributed to a person automatically. API billing is only attributed correctly when each person or job is issued its own key.
• A seat throttles one person against their own cap. A shared API key throttles nothing: every job and every developer draws down the same balance at once.
• CI jobs and scheduled agents only exist on the API side. A nightly job that reviews every pull request runs the same token math as an interactive session, just with nobody watching a usage cap.

Worked example: what three team sizes actually spend

Model it per session instead of guessing a flat monthly number. A typical Claude Code session, after prompt caching, averages out to roughly $4 at direct Sonnet 4.6 rates across a mix of light lookups and heavier multi-file edits; see the token cost breakdown linked below for the full per-session math. Multiply that by how many sessions a team actually runs in a month and the shape of the bill stops being a mystery. Treat the figures below as planning ranges, not invoices: real sessions vary by repo size and how aggressively prompt caching kicks in. The point is the ratio between the three profiles, and between paying Anthropic direct rates and routing the same volume through a lower per-token rate.

Why the bill surprises teams that skipped budgets

None of this is a pricing trick, it is a monitoring gap. A provider console shows spend per key when keys are separated, and it shows nothing useful when five developers and two CI jobs all share one key labeled for production use. The fix is mostly organizational: one key per developer, one key per automated job, a spend cap on each, and an alert set well below the cap instead of at it.

• One shared API key: every developer and every CI job draws down the same balance, so nobody notices a runaway loop until the balance is already gone.
• No per-key spending cap: most consoles let you set a monthly limit per key, and teams that skip this find out about a bug the same day the card gets charged for it.
• A misconfigured agent retries into a wall: a script that retries a failed call in a tight loop with no backoff can turn one bad response into thousands of billed calls before anyone checks a dashboard.
• Seat caps interrupt exactly when it hurts: a developer mid-refactor who hits a weekly cap either stops working or switches to a personal API key on the spot, and that emergency key is rarely tracked as part of the team budget.
• Nightly CI jobs compound quietly: a code-review bot that runs on every pull request looks free on a demo day and becomes a real line item once the team is merging twenty pull requests a week.

Seats vs metered API vs a routed fallback chain

Once a team accepts that seats and API keys solve different problems, the decision becomes which combination to run, and how each option behaves the moment a limit hits. The table below lines up the common paths side by side.

How to build a Claude Code budget that survives a bad week

APIsRouter is one option for that last tier: an OpenAI-compatible API with pay-as-you-go billing and no subscription, where global models such as claude-sonnet-4-6 are priced 20% below official list and Chinese models sit below their own official rates. The first top-up adds a 100% balance bonus, and the /topup checkout takes payment before any signup form and emails the key, which matters when the thing you are provisioning is a CI fallback you want live in minutes, not after a support ticket.

• Issue one API key per developer and one per automated job, never a shared key. Attribution is free once keys are separate, and expensive to reconstruct after the fact once they are not.
• Set a hard monthly spend cap on every key in the provider console, and put an alert at roughly 70 to 80 percent of that cap, not at 100 percent.
• Log model, token counts, and cost per request somewhere central. Even one line per response is enough to catch a runaway job within a day instead of a billing cycle.
• Cap retries. A script that retries a failed call should back off and stop after a handful of attempts, not loop until a person notices the balance is gone.
• Build a fallback chain: a top-tier model for real work, a cheaper same-vendor model for routine calls once a key nears its cap, and a budget cross-vendor model for CI and bulk jobs that do not need top-tier reasoning.
• For that cheapest tier, route through a cheaper OpenAI-compatible endpoint instead of provisioning a second Anthropic key. Switching that tier is a base URL change in one settings file, not a rewrite.

Config example: a primary model and a capped fallback

Claude Code reads its model and endpoint from ~/.claude/settings.json, so a fallback chain is a configuration change, not a rewrite. Keep the primary model pointed at Anthropic directly if that is where the team's seats and caps already live, or point the whole file at one OpenAI-compatible base URL and pick models by ID instead, which keeps the config identical across every developer's machine and every CI runner. For OpenAI-compatible tools, scripts, and CI jobs, the base URL ends at /v1, as shown in the config and script below. Verify a fallback key with a one-off request before wiring it into a script that runs unattended, then let the script itself decide when to drop to the cheaper model.

{
  "env": {
    "ANTHROPIC_BASE_URL": "https://api.apisrouter.com",
    "ANTHROPIC_AUTH_TOKEN": "sk-APIsRouter-...",
    "ANTHROPIC_MODEL": "claude-sonnet-4-6",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "claude-opus-4-7",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "claude-sonnet-4-6",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "claude-haiku-4-5"
  }
}

FAQ