Cost at Scale

When a single developer uses Claude CLI, costs are intuitive — you see the bill and adjust. When ten developers run thousands of API calls per day, costs become a system design problem. This chapter covers the budgeting, model selection, and optimization strategies that keep production workloads predictable and affordable.

See What It Costs for per-call pricing and cache economics.

Team Cost Benchmarks

Before setting organizational budgets, you need a baseline. These figures come from real-world Claude Code usage across development teams.

These numbers assume a mix of Opus and Sonnet usage with caching enabled. Without caching, multiply by 3-5x. A 100-turn Opus session costs $50-100 uncached versus $10-19 cached — that difference compounds fast across a team.

Budget Controls

Claude CLI provides budget controls at three levels: per-call, per-session, and organizational.

Per-Call Budgets

The --max-budget-usd flag sets a spending limit on a single invocation:

# Cap a code review at $2
claude -p "Review this PR for issues" --output-format json --max-budget-usd 2.00

# Cap a quick lookup at $0.10
claude -p "What does this function do?" --output-format json --max-budget-usd 0.10

In scripts that run unattended, always set a budget. Without one, a multi-turn agent loop can burn through dollars before anyone notices.

Experimentally measured overshoot ratios for Opus (2026-03-19):

The minimum API call floor for Opus is ~$0.02-0.05 (system prompt + one turn). Any budget below this floor guarantees a massive overshoot ratio because the first turn always completes regardless. For practical budget control, use $0.05+ for single-turn tasks and $0.10+ for multi-turn.

Per-Session Budgets

When using --resume to continue a conversation, the budget tracks cumulative cost across all calls in that session:

# First call — uses part of the $5 budget
claude -p "Analyze the codebase" --output-format json --max-budget-usd 5.00

# Resumed call — shares the same $5 budget
claude -p "Now refactor the auth module" --resume $SESSION_ID --max-budget-usd 5.00

A $5 budget shared across 5 resumed calls averages about $1 per call. Plan your per-session budget around the total work you expect, not individual turns.

Organizational Limits

For teams, per-call budgets are not enough. You need a wrapper that enforces organizational policy:

#!/bin/bash
# team-claude.sh — wrapper that enforces org-wide daily limits
DAILY_LIMIT=15.00
DAILY_LOG="/tmp/claude-cost-$(whoami)-$(date +%Y%m%d).log"

# Sum today's spend
SPENT=$(awk '{sum += $1} END {printf "%.4f", sum}' "$DAILY_LOG" 2>/dev/null || echo "0")

REMAINING=$(echo "$DAILY_LIMIT - $SPENT" | bc)
if (( $(echo "$REMAINING <= 0" | bc -l) )); then
  echo "Daily budget exhausted ($DAILY_LIMIT). Resets tomorrow." >&2
  exit 1
fi

# Run with remaining budget as cap
RESULT=$(claude -p "$@" --output-format json --max-budget-usd "$REMAINING")
COST=$(echo "$RESULT" | jq -r '.total_cost_usd // 0')
echo "$COST" >> "$DAILY_LOG"
echo "$RESULT"

This pattern gives you a daily per-developer cap while still letting individual calls use --max-budget-usd for finer control underneath.

Model Selection for Cost

Model choice is the single biggest lever for cost at scale. Sonnet is 5x cheaper than Opus per token — $3/$15 per million input/output versus $15/$75.

Switch models with the --model flag:

# Sonnet for routine tasks — ~$0.005/call
claude -p "Add JSDoc comments to this file" --model claude-sonnet-4-6

# Opus for complex reasoning — ~$0.016/call minimum
claude -p "Find the race condition in this auth flow" --model claude-opus-4-6

In CI pipelines, default to Sonnet and escalate to Opus only when Sonnet’s output fails validation or quality checks. A two-pass strategy — Sonnet drafts, Opus reviews only when needed — can cut pipeline costs by 60-80%.

Effort Levels at Scale

The --effort flag controls how much thinking Claude does before responding. Lower effort means fewer output tokens, which directly reduces cost.

At scale, effort tuning adds up. If 70% of your team’s calls are simple lookups or formatting tasks, routing them through --effort low can cut total output token costs nearly in half for those calls:

# Low effort for simple tasks
claude -p "What is the return type of this function?" --effort low

# Default effort for standard work
claude -p "Write unit tests for the auth module"

# Max effort for the hardest problems
claude -p "Diagnose why this distributed lock fails under contention" --effort max

Cache Optimization

Caching is automatic in Claude CLI, but how you structure your workload determines whether you get 90% savings or pay full price on every call.

Batch Similar Prompts

Calls that share the same system prompt benefit from cache reads at one-tenth the input price. Run similar tasks together rather than interleaving different workloads:

# Good: batch similar tasks — second call gets cache hits
claude -p "Review src/auth.ts for security issues" --output-format json
claude -p "Review src/auth.ts for performance issues" --output-format json

# Wasteful: interleave different system contexts
claude -p "Review src/auth.ts" --output-format json
claude -p "Format this JSON" --model claude-sonnet-4-6 --output-format json
claude -p "Review src/db.ts" --output-format json

Maintain Sessions

Resuming a session is cheaper than starting fresh. Every resumed turn reads the accumulated context from cache at the 0.1x rate instead of re-ingesting it:

# Start a session
RESULT=$(claude -p "Analyze the codebase structure" --output-format json)
SESSION=$(echo "$RESULT" | jq -r '.session_id')

# Resume — context is cached, subsequent turns are cheaper
claude -p "Now focus on the API layer" --resume "$SESSION" --output-format json
claude -p "Suggest improvements" --resume "$SESSION" --output-format json

The Cache Math

Understanding the numbers helps you make better decisions about session management:

For a team of 10 developers each running 50 calls per day, the difference between cached and uncached workloads is roughly $240/day — over $5,000/month in savings from session management alone.

Disable Tools When Not Needed

Tool descriptions inflate the system prompt. For pure text tasks, stripping them out reduces input tokens:

claude -p "Summarize this document" --tools ""

This removes tool definitions from the system prompt, trimming the per-call input token count. The savings are modest per call but compound across thousands of daily invocations.