Claude Code Token Usage Statistics (2026)

Claude Code's token bill comes down to a handful of numbers: how many tokens a session actually consumes, the lopsided split between what it reads and what it writes, the discount caching gives you on repeated context, and the per-million-token rate of the model behind it. This page collects those numbers from primary sources so you don't have to reconstruct them from a billing dashboard at 2 a.m.

I build token-reduction tooling for a living, so I read these analyses with a vested interest — and the headline I keep coming back to is unglamorous: the expensive thing is what the agent reads, not what it writes. Prices, cache multipliers and the default model were re-checked against Anthropic's documentation as of October 2026; model versions and rates move fast, so re-verify at the primary source before you quote them in a contract.

Key Takeaways

How many tokens does a Claude Code session consume?

A typical 50-turn agentic coding session consumes roughly 1,000,000 input tokens and 40,000 output tokens — a 25:1 input-to-output ratio. [1] That ratio is the single most important fact about Claude Code's economics, and it surprises almost everyone the first time they see it.

The mechanism is straightforward once you say it out loud. Claude Code is an agent: every tool call (read a file, run a test, grep the repo) ships the entire accumulated context back to the model — system prompt, tool definitions, conversation history, file contents, command output. By turn 30 of a debugging session, the agent is re-reading 25,000–35,000 tokens of history on every single request. The output it writes — a patch, a paragraph of explanation — is tiny by comparison. [1]

What does that add up to per person? Anthropic's own Claude Code documentation puts the average across enterprise deployments at around $13 per developer per active day and $150–$250 per developer per month, with costs staying below $30 per active day for 90% of users. [11] The long tail is where the stories come from: running several instances in parallel or wiring the agent into automation moves you out of that 90% fast. If your monthly bill looks like a salary line item, the context window accumulation pattern above is why.

Why is input the expensive side, when output costs 5× more per token?

This is the part that trips people up. On every Claude tier, output tokens are priced at 5× the input rate — $50 vs $10 per million on Fable 5.1, $20 vs $4 on Opus 5.5, $10 vs $2 on Sonnet 5.5, $5 vs $1 on Haiku 4.5. [5] So the naive instinct is to make the agent write less.

It's the wrong lever. Input tokens drive approximately 85% of total session cost in production, because the volume gap dwarfs the price gap. [1] A 25:1 volume ratio against a 5:1 price ratio means input still wins the bill by a factor of five. Telling Claude Code to "be concise" trims the cheapest, smallest part of your spend.

The high-leverage move is the opposite: control what the agent reads on each turn. Retrieve only the relevant code instead of dumping whole files, prune stale conversation history, and don't re-feed the model output it already saw. That is precisely the gap output filtering and semantic code search are built to close.

How much do the tokens actually cost?

The per-million-token rate depends on which model is driving Claude Code. Since the Opus 5.5 / Sonnet 5.5 / Haiku 5.5 generation, the current Claude lineup spans a 100× range on input price, from Fable 5.1 at the top to Haiku 5.5 at the bottom. Claude Code's default model setting resolves to Opus 5.5 on Pro, Max, Team, Enterprise and the Anthropic API. [12]

For the full cross-vendor picture — OpenAI's and Google's lineups included — see the LLM API token pricing reference and the AI coding agent token costs breakdown. The detail that matters here: cache reads on Anthropic are no longer a flat 10%. They are billed at 10% of the base input price on Sonnet and Haiku, 5% on Opus 5.5 and 2.5% on Fable 5.1. [5]

How much does prompt caching change the Claude Code bill?

Anthropic prompt caching bills cache-read tokens at 10% of the base input price on most models — 5% on Opus 5.5, 2.5% on Fable 5.1 — while a cache write costs 1.25× the base input price for a 5-minute TTL, or 2× for a 1-hour TTL. The default lifetime is 5 minutes, refreshed each time the prefix is reused. [3] [5]

The catch is that the cached prefix must be byte-identical across requests. Reorder one instruction and the cache misses. GitHub measured the prefix problem in its own agentic workflows in May 2026: the most common waste was unused MCP tool registrations (a 40-tool GitHub MCP server adds 10–15 KB of schema to every turn), and after its fixes, cost-weighted "effective tokens" fell between 19% and 62% depending on the workflow, while one workflow rose 5%. [6] When the prefix drifts — which is the default for many agent harnesses — you pay full freight.

Caching helps with the stable prefix. It does nothing for the part of the bill that is genuinely new-but-redundant: the same file re-read three turns apart, the test output you already acted on, the directory listing you've now seen five times. That residue is the bulk of what context compression targets.

How much of the Claude Code bill is just re-sent context?

A lot. A 2026 LeanOps audit of 30 engineering teams running agentic AI in production found that re-sent context accounts for ≈62% of the total bill. [4] The same audit reported that teams hitting 50–70% cost reductions within two weeks consistently combined per-user budget caps, prompt caching, model-tier routing, and context-window pruning. [4]

That is the headline number for anyone trying to cut a Claude Code bill: roughly six of every ten dollars is the model re-reading things it has already seen. You cannot fix that by switching models or writing terser prompts — only by changing what gets sent.

What does Claude Code actually cost at scale?

Enterprise and individual data points from 2026 give a concrete sense of how token spend scales with usage intensity.

Uber burned through its entire 2026 AI tools budget by April — four months in — after Claude Code adoption jumped from 32% to 84% across its 5,000-engineer workforce. The average engineer cost $150–$250 a month; heavy users were running up $500–$2,000 per engineer per month, and Uber's leadership acknowledged they could not yet quantify the productivity return despite around 70% of committed code coming from AI tools. [2]

Peter Steinberger's team ran roughly 100 Codex instances in the cloud for a month, working on the OpenClaw project, and posted a bill of $1.3 million — 603 billion tokens across 7.6 million requests. One caveat worth carrying: the exact figures come from a screenshot in Steinberger's own post rather than a published statement. But the numbers remain the most concrete public benchmark for autonomous agentic coding at scale. [7]

A Reddit developer left a Claude Code loop running overnight — polling for software updates every 30 minutes — and woke up to a $6,000 bill. The culprit was a combination of an 800,000-token context window being rebuilt from scratch on every cycle (Claude Code had started writing many requests with a 5-minute cache TTL instead of 1 hour in early March 2026; Anthropic later said in the GitHub thread that the client now picks the TTL per request to lower total cost) and no spending cap. There was no real-time dashboard to warn him; the first alert was the email confirming the damage. [8]

At the other end of the scale, Henry Godnick documented a surprise $80 bill from a batch-processing script he left running unattended — a reminder that even small loops compound fast when each iteration rebuilds a multi-turn context. [9]

These data points share a common structure: the cost spike is not a single large model call but many medium calls, each re-sending a growing context. The practical implication is that the savings dashboard matters most precisely when a session is long or a loop is running — the exact moments when you're least likely to be watching.

What does research say about agent context management costs?

A study by Lindenbauer et al. (JetBrains Research), arXiv:2508.21433, first posted August 2025 and presented at the DL4C workshop at NeurIPS 2025, benchmarked context-management strategies for LLM-based software engineering agents on SWE-bench Verified across five model configurations. [10]

The headline finding is counter-intuitive: simple observation masking (truncating older tool outputs) halves cost relative to the raw agent baseline while matching the solve rate of more expensive LLM-based summarisation. With Qwen3-Coder 480B, observation masking cut cost per instance by 52.7% ($1.29 to $0.61) against the raw baseline while the solve rate went from 53.4% to 54.8%. The October 2025 revision adds a hybrid of masking and summarisation that trims cost by a further 7% versus masking alone. The study challenges the assumption that smarter context management necessarily means more LLM calls — sometimes it just means not sending old data.

The broader implication for Claude Code users: the agent harness design (what it keeps, what it discards, how it handles long tool outputs) is as important a cost variable as the model tier you choose.

Methodology note

Per-token prices are from Anthropic's official pricing page (primary source, verified October 2026). Prompt-caching multipliers are from Anthropic's pricing and prompt caching documentation (primary source). The per-developer daily and monthly averages and the default model come from Anthropic's Claude Code documentation (primary source, October 2026). Session-volume and cost-split figures are from the Vantage production analysis. The 62% re-sent-context figure is from an industry audit of 30 production teams, not an academic study, and should be treated as indicative. Enterprise cost data (Uber, OpenClaw) is from contemporaneous press reporting. The Lindenbauer et al. arXiv preprint (2508.21433) is the academic source for context-management cost benchmarks on SWE-bench Verified. Indicative session costs use the published Anthropic rates with the Vantage volume profile and no caching applied. Re-verify every figure at its primary source before citing in commercial contexts.