Claude Code Cost Optimization

Quick Answer

Cut Claude Code spend by compacting context aggressively, picking cheaper models for routine work, keeping sessions short, and writing a tight CLAUDE.md. The 4 biggest wins typically cut monthly bills by 40 to 60 percent. TLDR: track spend with /cost, use Haiku for mechanical tasks, Sonnet for daily work, Opus only for hard architecture problems, and compact when context passes 40k tokens.

Summary of the 9 tactics

1. Compact context when it exceeds 40k tokens
2. Switch models mid-session with /model
3. Track usage with /cost at session end
4. Write a tight CLAUDE.md to avoid repeated clarifications
5. Open short sessions for unrelated tasks
6. Batch related work in one session
7. Use Pro or Max OAuth subscription when heavy daily use
8. Run headless mode for scripted jobs
9. Set spend alerts at the API console

Where the cost comes from

Claude Code bills input tokens and output tokens separately. Input tokens (the system prompt, CLAUDE.md, all prior turns, and the files Claude reads) make up the majority of session cost. Output tokens (Claude actual responses and tool call arguments) are smaller but priced higher per token.

That means a long session with a growing context window costs more than 2 short sessions of equal total work. Every turn resends the full context to the API, which gets billed again as input. A session that reads 15 files and continues for 30 turns can pay for those same files 30 times in input cost.

The 3 main drivers of cost are context size, model choice, and session count. Attacking each of these cuts spend without hurting quality.

Compact aggressively

The /compact command takes the current session, summarizes it, and restarts the context with the summary as the starting point. Claude loses granular memory of earlier turns but keeps the key decisions and artifacts.

A good rule: compact whenever context crosses 40k tokens, or whenever you switch topics. A session that accumulates 100k tokens of context costs roughly 2.5x per turn what a compacted 40k session does. Compacting costs roughly 5000 output tokens (small one-time hit) and then every subsequent turn is cheaper.

You can also compact preemptively before a long task. If you know you are about to read 10 large files, compact first so the reads do not stack on top of existing context.

Pick the right model

Claude Code ships 3 tiers. Haiku is the fastest and cheapest, roughly one third the cost of Sonnet. Sonnet is the default and handles most coding tasks well. Opus is the slowest and most expensive, roughly 5x Sonnet, and it wins on hard architecture reasoning and tricky debugging.

A 2026 cost-efficient policy looks like this. Haiku for mechanical work such as import rewrites, lint fix runs, renaming variables across a file, and boilerplate test scaffolding. Sonnet for daily feature work, refactors under 500 lines, and most debugging. Opus only when you hit a problem Sonnet gave up on after 3 attempts.

Switch mid-session with the /model command. If you start on Sonnet and realize the task is mechanical, drop to Haiku for the rest of the work. If you hit a wall, bump up to Opus for one turn and then switch back.

Use /cost every session

The /cost command shows tokens used and running cost for the current session. Run it at the end of every session for a week. You will build a mental model of which kinds of tasks cost what. Quick bug fixes tend to land at 5 to 25 cents on Sonnet. Feature tickets land at 50 cents to 2 dollars. Multi-hour refactors with many file reads land at 3 to 10 dollars.

Once you know the distribution, outliers become obvious. A 6 dollar session for a 15-minute bug fix signals that you forgot to compact, or that the agent read a huge file 4 times in a row.

Write a tight CLAUDE.md

A good CLAUDE.md cuts cost in 2 ways. First, it reduces the number of back-and-forth clarification turns per task. Every avoided clarification saves the roundtrip input and output tokens. Second, it reduces the amount of exploration Claude does to figure out conventions.

The cost math works out to roughly 10 to 15 percent savings on a project with a well-tuned CLAUDE.md versus none. On a team spending 500 dollars a month that is 50 to 75 dollars saved per month for a 20-minute writing task done once.

Keep CLAUDE.md under 400 words. Every token also loads on every turn, so a bloated file costs more than no file.

Short sessions for unrelated work

If you are about to switch topics from debugging a backend bug to writing a marketing email, start a new session. The old session context is useless for the new task and still costs input tokens if you stay in it.

A practical pattern is the 5-minute rule. If you are idle for 5 minutes and come back to a new topic, run /compact or start fresh. You will save roughly 20 percent over a week compared to keeping one mega-session running.

Batch related work

The inverse is also true. If you have 5 small related tasks, do them in 1 session. The shared context pays for itself once, instead of 5 times. A session that adds 5 related features to the same file costs about 40 percent less than 5 separate sessions each paying the file-read cost.

OAuth subscription vs API billing

Claude Code supports 2 auth paths. API key billing charges per token at standard rates. OAuth through a Pro or Max subscription hits rate limits instead, with no per-token bill.

For heavy daily use (3 or more hours of coding), the Max tier subscription typically breaks even at 15 to 20 dollars a day of API-equivalent usage. Power users running 8 hours a day land at 40 to 80 dollars a day on API billing, which the Max subscription dominates on value.

For occasional use (30 minutes a day), API billing wins because you pay only for what you use.

Headless mode for automation

The --print flag runs Claude Code non-interactively. You pass a prompt, get a single response, and exit. Headless mode skips the interactive loop overhead and works well in CI pipelines, cron jobs, and scripted workflows.

A typical headless job is cheaper than an interactive session for the same task because there is no exploratory back-and-forth. Use headless for scheduled jobs like nightly dependency audits, scheduled test runs, or scripted refactors.

Spend alerts and monitoring

At the Anthropic console you can set a monthly spend cap and alert threshold. Set the cap 20 percent above your expected usage. The alert fires at 50, 80, and 100 percent of the cap, giving you time to investigate before the hard stop.

Monitor 3 metrics weekly. Total monthly spend vs budget. Average cost per session. Sessions over 5 dollars (outliers worth investigating).

Real-world benchmarks

Here is a reference table of typical task costs on Sonnet as of April 2026. A small bug fix reading 3 files runs 5 to 25 cents. A feature ticket with 10 to 15 tool calls runs 50 cents to 2 dollars. A multi-hour refactor reading 50 or more files runs 3 to 10 dollars. A whole-app audit across 200 files runs 10 to 30 dollars.

Daily spend for active developers lands at 3 to 15 dollars on Sonnet with normal workflows. Teams of 5 using Claude Code for 6 hours a day each land at 500 to 2000 dollars a month depending on model mix.

Cutting that bill 40 to 60 percent is achievable without hurting productivity. The biggest single win is usually compacting aggressively. The second biggest is dropping to Haiku for mechanical work. The third is writing a tight CLAUDE.md that eliminates 2 or 3 clarification turns per task.

The combined effect on a 1000 dollar monthly bill is roughly 400 to 600 dollars saved. That pays for a lot of extra sessions.