Why does a long Claude Code session cost so much on the API?

Each prompt costs more than the last because Claude Code sends your full conversation with every request, and each time Claude uses a tool it sends another request carrying that history plus the tool results (Claude Code docs: why usage climbs in a long session). What grows on every call:

• The history. Every earlier prompt, answer and file read rides along on every later call.
• Tool results. A test run, a long log or a large file stays in the history and is sent again on each call after it.
• Cache reads. Prompt caching bills the repeated history at the cached rate, $0.20 per million tokens on Claude Opus 5.5 against $4 for uncached input (Anthropic pricing). The rate is low per token, and it is paid again on every call.
• Cache misses. The first message after a break longer than the cache lifetime misses the cache and reprocesses the full context (why the first message after a break uses so much).
• Other requests. Subagents and agent teammates send their own requests on top of the main conversation's, and a session-scoped scheduled task sends the full context each time it fires, even while the session is idle.
• Compaction. /compact reads the whole conversation it summarizes, so compacting a large context is itself a large request. /clear costs nothing.

We measured this curve in a 120-prompt Claude Code session at Claude Opus 5.5 list prices. Cost per prompt climbed with the history until Claude Code compacted it during prompt 82. A call carried 327k tokens at prompt 30 and 965k just before the compaction (our benchmarks, compare.md, one run). By our arithmetic on the list prices, reading a 965k-token history from the cache costs about $0.19 per call. Writing it to the cache again after a miss costs about $4.83 at the $5 five-minute write rate, or $7.72 at the $8 one-hour rate, before any output. Claude Code uses the five-minute rate for the main conversation on an API key unless you choose one hour (Claude Code docs: which TTL each request gets).

Run /usage in Claude Code. Its Session block shows the session's tokens by model and a dollar figure that Claude Code computes on your machine at list price (Claude Code docs: track your costs). Other places to look:

• /usage splits each model's tokens into input, output, cache read and cache write, and resets when /clear starts a new session. From v2.1.251 its Prompt cache (main) line shows the share of input served from cache and the misses.
• A status line script receives cost.total_cost_usd and context_window.used_percentage, so the session's cost and context size stay on screen as you work (status line docs).
• ccusage, an open-source community tool, reports daily and per-session usage from the data Claude Code keeps on your machine (npx ccusage@latest).
• The Usage page of the Claude Console is the authoritative figure for API billing. What Claude Code shows is an estimate.
• For a team, OpenTelemetry export (CLAUDE_CODE_ENABLE_TELEMETRY=1) sends the claude_code.cost.usage and claude_code.token.usage metrics per user to your own monitoring, on every setup (monitoring docs, costs docs).
• If your organization pays contracted rates, an administrator can set modelPricing in managed settings so the figures match the contract (v2.1.242 or later). It changes what Claude Code reports, not what Anthropic charges.

If ANTHROPIC_API_KEY is set in your environment and you approved it, Claude Code uses that key, billed on the API, even when you are signed in with a Pro or Max plan, because an API key ranks above a subscription login (Claude Code docs: authentication precedence). In non-interactive mode (-p) the key is always used when present. A May 2026 report on Claude Code's issue tracker describes a key kept in a project's .env file for the app's own calls being billed in place of a Max plan login when Claude Code was started from that project (#58083).

1. Run /status. It shows which credential is active, and when a login and an API key are both configured it marks the one not in use.
2. Look for the key where it can come from: your shell profile, a project .env file that your shell or a tool such as direnv loads into the environment, and the env block of your Claude Code settings files.
3. Run unset ANTHROPIC_API_KEY (in PowerShell, Remove-Item Env:ANTHROPIC_API_KEY) and restart Claude Code, or turn off the "Use custom API key" toggle in /config, which appears while the variable is set.
4. If you are signed in with a Console account, run /login and choose your subscription, or claude logout and then claude login with only your Pro or Max account (Help Center: Use Claude Code with your Pro or Max plan).
5. Run /status again to confirm the subscription is the active credential.

Cap it where you are billed: a spend limit on the Claude Code workspace in the Claude Console, or your cloud provider's budget controls on Amazon Bedrock, Google Cloud's Agent Platform or Microsoft Foundry (Claude Code docs: manage costs for your organization).

• In the Console, open the Workspaces page, select the Claude Code workspace and set Spend limits to cap monthly spending, with alerts at thresholds you choose. A workspace limit can be lower than the organization's, not higher, and the Claude Code workspace is the only one that supports per-user monthly spend limits (workspace limits).
• A workspace rate limit, set under Rate limits in the Console, caps Claude Code's requests per minute and input and output tokens per minute within the organization's limits.
• On Bedrock, Google Cloud's Agent Platform and Microsoft Foundry, Claude Code is billed per token to your cloud account, so the cap is your cloud's budget controls.
• On a Pro or Max plan with usage credits on, /usage-credits opens the settings where you set a monthly spend limit for usage past the plan.

Keep the context small, because token cost scales with how much context each call carries (Claude Code docs: reduce token usage). Anthropic's list, in short:

• Run /clear when you switch to unrelated work. Run /rename first so /resume can bring the session back.
• At a natural break, compact with instructions, for example /compact Focus on code samples and API usage, and keep standing compaction instructions in CLAUDE.md.
• Use Sonnet for most coding and keep Opus for hard design and multi-step reasoning. /model switches mid-session, and subagents doing simple work can run on haiku.
• Run /context to see what fills the window (what is filling the context window). Disable MCP servers you are not using with /mcp, and prefer CLI tools such as gh where they exist.
• Move workflow-specific instructions from CLAUDE.md into skills, which load only when invoked. Anthropic suggests keeping CLAUDE.md under 200 lines.
• Let a hook filter long output before Claude reads it, for example only the failing tests from a test run.
• Send verbose work such as test runs and log processing to a subagent, so only its summary comes back to the main conversation.
• Lower the effort level with /effort for simple tasks. Thinking tokens are billed as output.
• Write specific prompts, use plan mode (Shift+Tab) before a large change, and press Escape as soon as Claude heads the wrong way.
• On a plan, /usage recommends a change for anything behind 10% or more of recent usage, and pressing f applies some of them (v2.1.305 or later).

We ran the same prompts in Claude Code twice, once directly and once through Perpetuity, a memory proxy that sends a frame of the relevant past in place of the resent history. Claude Code ran on its default 1M-token window. Every call is priced at Claude Opus 5.5 list prices: $4 input, $20 output, $0.20 cache read and $8 cache write per million tokens. That cache write is the one-hour rate our runs were billed at, and a few writes were at the five-minute rate. On an API key Claude Code writes the main conversation at the $5 five-minute rate by default, so the same writes would cost less there, on both sides (our benchmarks, compare.md).

Through Perpetuity, each call of the 120-prompt session started at about 46k tokens from prompt 10 on. Only a prompt's own tool loop raised it, until the next prompt. Without Perpetuity, a call reached 965k before compacting. Most of the 46k is what Claude Code itself sends on every call, its system prompt and tool definitions, about 31k tokens on our measured repo. Cache reads fell from $75.42 to $11.04, while cache writes rose from $13.09 to $25.85, because the frame changes with each prompt, so it is written to the cache again. Prompt caching keeps working through the proxy, and every cost here includes cache pricing (our benchmarks, compare.md, agents.md).

Savings begin only on long sessions, meaning sessions whose context has grown large. The saving follows context size. Prompt count alone does not tell you that, since a call had grown to 327k tokens by prompt 30 of the 120-prompt session (above). /context shows how large yours have grown. Short sessions with small contexts save little or nothing.

Shorter sessions saved less than the 120-prompt session's 52%: two 30-prompt pairs saved 11% and 35%, and the 60-prompt pair in the table 48%. Within the 120-prompt session the saving was largest between prompts 61 and 90 (64% less), the stretch in which Claude Code alone compacted. The saving also differs by project: the 200-prompt sessions saved 38% on the Rust tool and 27% on the Go tool, and the Flask one came out a tie. Against Claude Code capped at a 200k-token window, which compacted 17 times and cost $57.05, Perpetuity's $50.24 was 12% less, and Perpetuity cost more over the first 60 prompts (one run per setup).

Claude subscription usage is metered on the tokens a session uses (Claude Code docs), so long sessions through Perpetuity should draw less of a plan's usage. We have not measured Anthropic's plan meter itself, and Anthropic does not publish how it weighs cached against uncached tokens, so we give token counts and API list prices, never a percentage of a plan's limit and never a promise of more usage.