What It Costs

Every Claude CLI call costs money. Input tokens, output tokens, and cache operations all have a price. Understanding the minimum per-call overhead (~$0.016 for Opus) and cache economics (90% savings on repeated prompts) is essential before you run anything at scale. This chapter breaks down exactly where your dollars go and how to keep them under control.

Token Pricing

The cache read row is the one that matters most. Once a system prompt or conversation prefix is cached, subsequent calls read it back at one-tenth the input price. This is where the real savings come from.

The Minimum Per-Call Cost

Every call pays a “tax” for the system prompt, regardless of what you actually ask:

• Opus: ~$0.016 minimum per call
• Sonnet: ~$0.005 minimum per call

The system prompt is approximately 14,253 cache read tokens. Even a trivial question like “What is 1+1?” costs $0.016 with Opus because those tokens must be read before Claude can respond.

This has a direct consequence: --max-budget-usd 0.01 will always trigger error_max_budget_usd with Opus because the system prompt alone exceeds the budget. Set a minimum of $0.02 for Opus, or better yet, $0.10 to give Claude room to actually answer.

Budget Is Not a Hard Cap

The --max-budget-usd flag is checked between turns, not mid-generation. Here is what actually happens:

1. Claude starts generating a response
2. The response completes (full turn)
3. Then the budget is checked
4. If exceeded, the next turn does not start

This means a single turn can blow past the budget by any amount. A $0.001 budget can result in $0.15 of spend if the first turn generates a long response.

Here is a real response from setting a $0.001 budget and asking for a long essay:

The subtype field changes from "success" to "error_max_budget_usd", but is_error remains false — this is a controlled stop, not a crash. Always check subtype rather than is_error to detect budget limits.

Cache Economics

Caching is where the real savings happen. Here is what a typical call looks like under the hood.

First call to a new session:

• ~14K tokens read from cache (system prompt, cached from a previous session)
• ~1.4K tokens written to cache (new session-specific content)

Subsequent calls (same session or same system prompt):

• Almost everything hits cache reads at the 0.1x rate
• Only new content creates cache entries

Savings calculation for a 10-turn Opus session:

The takeaway: keep conversations in the same session whenever possible. Every resumed turn benefits from cache reads at 90% off.

5 Cost Optimization Strategies

1. Use Sonnet for simple tasks — Run claude -p "Format this JSON" --model claude-sonnet-4-6. Sonnet is 5x cheaper per token. Reserve Opus for complex reasoning.

2. Disable tools for pure text tasks — Run claude -p "Summarize this text" --tools "". No tool descriptions in the system prompt means fewer input tokens.

3. Use --effort low for simple questions — Run claude -p "What is 2+2?" --effort low. Lower effort means shorter thinking and fewer output tokens.

4. Set realistic budget caps — Minimum $0.10 for Opus single-turn, $5.00 for multi-turn sessions. Anything below $0.02 for Opus will always trigger a budget error.

5. Batch similar prompts to maximize cache hits — Run prompts with the same system prompt back-to-back. Subsequent calls benefit from cache reads at 90% off.

Industry Benchmarks

The difference between cached and uncached sessions is dramatic — up to 5x cheaper. This is why session management and cache awareness matter so much for teams running Claude at scale.