Claude Code token cost: what one task really costs
Short answer: Claude Code burns about 60K input tokens (70% cached) and 4K output tokens per typical task, so one task costs $0.0810 on Grok 4.7. At 200 tasks a month that is $16.20; without caching the same task would cost $0.1440. Evidence: documented.
Cost per task, three price points
One row per scenario from our tool data. The three price columns price the identical token counts on the cheapest, mid and premium reference models, so the difference is the model rate, not the workload.
| Scenario | Input tokens | Cached input | Output tokens | Cheapest current model | Mid-tier reference model | Premium reference model |
|---|---|---|---|---|---|---|
| Light task one short request with a small context and one or two tool calls | 15K | 50% | 1,500 | $0.00158 | $0.0278 | $0.3150 |
| Typical task one coding or agent task with several tool calls and a medium context | 60K | 70% | 4K | $0.00422 | $0.0810 | $0.8440 |
| Heavy session a multi-turn agent session with a large repo or long history; input counts all tokens re-sent across turns | 250K | 80% | 12K | $0.0130 | $0.2720 | $2.60 |
Rates: input $2 / cached $0.5 / output $6 per 1M on Grok 4.7. Prices checked 2026-11-18.
Monthly budget
| Scenario at 200 tasks / month | Cheapest current model | Mid-tier reference model | Premium reference model |
|---|---|---|---|
| Light task | $0.3150 | $5.55 | $63.00 |
| Typical task | $0.8440 | $16.20 | $169 |
| Heavy session | $2.60 | $54.40 | $520 |
At 200 tasks a month, one task at the typical size costs $0.0810 on Grok 4.7, so $100 covers about 1235 tasks. The same budget buys 118 tasks on the premium reference and 23697 on the cheapest one.
Server-rendered from the typical task on Grok 4.7 at 200 tasks a month. Change a field to recalculate; nothing is sent anywhere and the formula is the one under Method.
Where the tokens go
- 60K input tokens, 70% of them cached. Claude Code re-sends the full conversation on every request, and each tool call adds another request carrying that batch of tool results. System prompt, CLAUDE.md, skill descriptions, tool definitions and extended-thinking output all count, and auto-compaction rewrites history so the prefix has to be cached again. of the input is the tool's prompt, tool schema and history; the cached share is what the provider can reuse on the next step without re-reading it at the full rate.
- 4K output tokens — 15.0× fewer tokens than the input. The answer is short relative to the context the tool sends with it, which is the normal shape for an agent step.
- Output is 6% of the token count but 30% of the bill on Grok 4.7. Output is priced higher than input, so the visible answer still matters even when most tokens are input.
- Per 1,000 tasks: $81.00. That is the number to put in a budget line, not the per-token rate: 1,000 tasks at the typical size cost $81.00 on Grok 4.7 and $844 on GPT-6 Cyber.
- At 200 tasks a month: $16.20 on Grok 4.7 and $169 on GPT-6 Cyber. The premium reference is 10.4× the mid-tier bill; the cheapest reference is $0.8440.
The provider basis behind these numbers
Anthropic's cost docs report an enterprise average of about $13 per developer per active day and $150-250 per developer per month, and show a real session breakdown of 1.2k input, 5.3k output and ~990k cache tokens ($0.55). The tiers split that usage into a 15k-token light task, a 60k-token typical task and a 250k-token heavy session, with 50-80% of input served from prompt cache; the docs' mature-session cache example reports 91% of input tokens from cache. The monthly total assumes 200 typical tasks per developer, while Anthropic's enterprise average also includes heavier multi-session and parallel-instance use.
What caching is worth here
Our data does not assume a cached prefix for this tool (70% cached share), so the task price above is already the uncached input price. If the tool does repeat a stable prefix, adding it to the provider cache cuts the input side to $0.5 per 1M on Grok 4.7.
How to reduce it
- Run /clear between unrelated tasks; stale context is billed on every later message.
- Keep CLAUDE.md under ~200 lines and move long procedures into skills that load on demand.
- Prefer CLI tools (gh, aws, gcloud) over MCP servers when one exists; tool definitions are deferred but server instructions still enter context.
- Lower effort or thinking budget for simple edits, and route routine subagent work to a smaller model.
- Delegate log reading and test runs to subagents so verbose output stays out of the main context.
Each tip changes a different part of the formula: caching changes the input rate, trimming history changes the input count, and routing simple steps to a cheaper model changes the rate for part of the work.
Sources and evidence
| Source | Read on | What it establishes |
|---|---|---|
| code.claude.com | 2026-11-04 | Enterprise cost averages ($13/active day, $150-250/month), a session token breakdown, prompt-cache statistics and token-reduction guidance. |
| code.claude.com | 2026-11-04 | What loads into context at startup, how compaction works, and the 5k-token per-skill / 25k-token total caps on re-injected skill bodies. |
| code.claude.com | 2026-11-04 | Documents MCP tool search and the default deferral of tool definitions to keep context small. |
Evidence label: Documented
Anthropic's cost docs report an enterprise average of about $13 per developer per active day and $150-250 per developer per month, and show a real session breakdown of 1.2k input, 5.3k output and ~990k cache tokens ($0.55). The tiers split that usage into a 15k-token light task, a 60k-token typical task and a 250k-token heavy session, with 50-80% of input served from prompt cache; the docs' mature-session cache example reports 91% of input tokens from cache. The monthly total assumes 200 typical tasks per developer, while Anthropic's enterprise average also includes heavier multi-session and parallel-instance use.
Method
The formula
Cost per task = (uncached input × input rate + cached input × cached rate + output × output rate) ÷ 1,000,000. Rates are the standard list prices in the price table (checked 2026-11-18); token counts come from src/tools.json (tool data reviewed 2026-11-05).
Why three reference models
The columns are the cheapest, median and most expensive current models by the cost of one typical agent task, named above so you can check each rate. They are a range, not a prediction of which model Claude Code uses.
What the monthly figure assumes
200 tasks a month (the tasks-per-month field in our tool data), the same count for every scenario, at the standard rate with no batch discount. A heavy session can count as several tasks, so replace the number with your own before you put it in a budget.
Official links
Related skills & plugins
Other entries in the AI coding agents category. Each name links to its token-cost page or its official site.
- OpenAI Codex CLI — OpenAI's open-source terminal coding agent, billed via ChatGPT credits. ($0.0722 per task, Documented)
- Cursor — AI-first code editor and agent with per-token third-party model billing. ($0.0760 per task, Estimated)
- Claude Skills — Claude Code skills that load only when invoked and cap at 5k tokens. ($0.0444 per task, Documented)
- All skills, plugins and MCP token costs
Related models
The three reference models in the cost table, with their full price tiers.
- GPT-6 Luna — $0.1 input / $0.5 output per 1M tokens, $0.00422 per typical task in the table above
- Grok 4.7 — $2 input / $6 output per 1M tokens, $0.0810 per typical task in the table above
- GPT-6 Cyber — $20 input / $100 output per 1M tokens, $0.8440 per typical task in the table above
More
- Benchmark comparison: price vs performance
- Best LLM for coding in 2026
- Find a model for your use case
- Compare two to four models on price
Related
- All skills, plugins and MCP token costs
- Best LLM for coding in 2026
- Find a model for your use case
- Token cost calculator
- Compare two models on price
- OpenAI Codex CLI token cost
- Cursor token cost
Questions
How much does Claude Code cost per task?
One typical task costs $0.0810 on Grok 4.7, $0.00422 on the cheapest reference model (GPT-6 Luna) and $0.8440 on the premium reference (GPT-6 Cyber). The spread is the model rate: the token counts are identical in all three columns.
What does Claude Code cost per month at 200 tasks?
$16.20 a month on Grok 4.7 at the typical task size. Without the 70% cached input assumption it would be $28.80. Per 1,000 tasks the token bill is $81.00.
Why does Claude Code use so many input tokens?
Claude Code re-sends the full conversation on every request, and each tool call adds another request carrying that batch of tool results. System prompt, CLAUDE.md, skill descriptions, tool definitions and extended-thinking output all count, and auto-compaction rewrites history so the prefix has to be cached again. The token shape is 60K input tokens (70% cached) against 4K output per typical task; input is resent every step, output is not.
Are the Claude Code token numbers measured or estimated?
The evidence label is "Documented". Anthropic's cost docs report an enterprise average of about $13 per developer per active day and $150-250 per developer per month, and show a real session breakdown of 1.2k input, 5.3k output and ~990k cache tokens ($0.55). The tiers split that usage into a 15k-token light task, a 60k-token typical task and a 250k-token heavy session, with 50-80% of input served from prompt cache; the docs' mature-session cache example reports 91% of input tokens from cache. The monthly total assumes 200 typical tasks per developer, while Anthropic's enterprise average also includes heavier multi-session and parallel-instance use. Sources and read dates are in the table above; if a number is an estimate, the basis says what it assumes, and it is never described as a measurement.
Next step → See every tool cost side by side
Price data last checked 2026-11-18 against official sources · how we verify
Price-change alerts
One short email when a provider changes a price or a promo ends. No spam, unsubscribe any time.