How to Reduce Claude API Costs: A Practical 5-Step Guide
A team spending $5,000 a month on Claude can get to about $2,240 without changing what its product does, and lower by moving simple tasks to Haiku 5.5.
A team spending $5,000 per month on Claude that implements the steps in this guide can reach about $2,240 per month without changing what their product does, and less once simple tasks move to Claude Haiku 5.5. No major architectural rewrites. The savings come from using the right model for each task, enabling features that Anthropic already provides, and removing waste that accumulates in any system that hasn't been deliberately optimized.
This guide is specifically for teams running on Anthropic exclusively or primarily, who suspect they're overspending but haven't had time to audit systematically.
Step 1: Audit Your Model Usage
The current Anthropic lineup has four tiers with very different cost profiles (Anthropic's pricing page, October 2026).
| Model | Input (per MTok) | Output (per MTok) | Best For |
|---|---|---|---|
| Claude Haiku 5.5 (prompts up to 100K tokens) | $0.10 | $0.50 | Classification, extraction, routing, short structured generation |
| Claude Sonnet 5.5 | $2.00 | $10.00 | Most production tasks, coding, analysis |
| Claude Opus 5.5 | $4.00 | $20.00 | Long-running agentic coding and knowledge work |
| Claude Fable 5.1 | $10.00 | $50.00 | Demanding reasoning and long-horizon agentic work |
Opus 5.5 costs 40 times as much as Haiku 5.5 on input and output, and Fable 5.1 costs 100 times as much. If you are routing every task to a top model because it's "the most capable," you are almost certainly paying for capability you are not using on the majority of your calls. One caution when you compare with older models: Anthropic says Claude 4.7 and later use a tokenizer that produces about 30% more tokens for the same text, so compare the cost of a task, not only the price per token.
The practical decision rule is straightforward. Use Haiku 5.5 for tasks where the input is structured and the output is bounded: entity extraction, sentiment classification, routing decisions, short-form transformations, and any task where you can evaluate output quality by matching against a known schema. Use Sonnet 5.5 for the broad middle of production use cases: customer-facing chat, document summarization, code generation, analysis tasks where you need coherent multi-paragraph output. Reserve Opus 5.5, and Fable 5.1 above it, for tasks where the complexity requires it: long-horizon reasoning chains, tasks that routinely fail on Sonnet, or offline workflows where quality is critical and latency doesn't matter.
Start your audit by pulling your last 30 days of usage segmented by model. If more than 20% of your call volume is going to Opus 5.5 or Fable 5.1 and your product is not primarily a complex reasoning product, that's where to start. A detailed breakdown of the Anthropic model lineup and when each tier earns its cost is in the Claude API pricing guide.
Step 2: Enable Prompt Caching
Prompt caching is the single highest-leverage cost reduction available on Claude, and it requires no changes to your application logic or model selection, only a small change to how you structure your API requests.
The economics are striking. Cache reads on Sonnet 5.5 cost $0.10 per MTok, compared to $2.00 per MTok for uncached input: a 95% reduction on cached tokens. Opus 5.5 gets the same 0.05x rate, Haiku 5.5 and most other models 0.1x, and Fable 5.1 0.025x. The cache write costs depend on duration: 5-minute cache writes cost 1.25x the base price, while 1-hour cache writes cost 2x the base price. On the current models the cached part of the prompt must be at least 512 tokens. For any content you're caching across many calls, the math almost always favors enabling caching.
The concrete example: suppose your system prompt is 1,000 tokens and you make 100,000 calls per month on Sonnet 5.5. The uncached cost of that system prompt is 1,000 * 100,000 / 1,000,000 * $2.00 = $200 per month. With prompt caching enabled and a 95% hit rate (typical for a stable system prompt), the math becomes: 5% of calls write the cache at 1.25x, which is $200 * 0.05 * 1.25 = $12.50, plus 95% of calls read it at $0.10/MTok, which is $200 * 0.95 * (0.10/2.00) = $9.50. Total: $22.00 per month. That is an 89% reduction on the system prompt cost from a single configuration change.
Prompt caching applies to any content that is repeated across calls: system prompts, few-shot examples, retrieved document chunks in RAG systems, and conversation history that precedes a new user turn. The longer and more stable the cached content, the larger the savings. If your RAG system retrieves the same 10 documents for a large percentage of queries, those documents are excellent caching candidates. You can find a detailed breakdown of caching mechanics across both OpenAI and Anthropic in the prompt caching cost savings guide.
Paying full price on every request?
PromptUnit checks each request your app sends and moves it to a cheaper model when one is just as good for that request. You change two settings, and your own provider key stays. Free until it has saved you money, then 20% of what it saves.
Try it free →Step 3: Use the Batch API for Non-Real-Time Work
Anthropic's Batch API costs 50% less than the standard API on every model. The only requirement is that your workload can tolerate asynchronous processing, typically up to 24 hours for batch completion.
The list of workloads that qualify is longer than most teams initially assume. Classification pipelines that run on new data nightly, document processing that users don't wait on synchronously, data enrichment runs, evaluation pipelines for prompt testing, and report generation that users schedule rather than trigger in real time, all of these are batch-eligible.
A team spending $2,000 per month on a nightly classification pipeline on Sonnet 5.5 drops to $1,000 per month by switching to the Batch API. The API interface is slightly different, you submit requests and poll for completion rather than streaming responses, but the change is not architecturally significant for workloads that are already asynchronous.
If you haven't mapped your workloads to real-time versus async categories, that's the right starting point. A detailed framework for making the batch API routing decision covers the trade-offs and implementation considerations.
Step 4: Control Output Length
Claude models, Sonnet and Opus in particular, tend toward verbose responses when given latitude. This matters because output tokens on Sonnet 5.5 cost $10 per MTok, compared to $2 per MTok for input. If your calls produce output that is 30-40% longer than necessary, you are paying a significant premium that has nothing to do with quality.
The fixes are direct. Add explicit length constraints to your prompts: "respond in under 200 words," "return only the required JSON with no additional commentary," "summarize in three sentences." When your use case calls for structured data, use structured output mode (Anthropic's tool use with a defined JSON schema) rather than asking Claude to produce JSON in its response text. Structured outputs are more reliable and eliminate the verbose preamble that often precedes JSON in open-ended responses.
The output token savings compound with model selection. Moving a verbose Opus 5.5 call to Sonnet 5.5 halves the price per token, and trimming output length by 35% on top of that leaves 0.5 x 0.65 = 0.325 of the original output cost: about two thirds less on the output side, and half on the input side.
Step 5: Route Simple Tasks to the Cheapest Model That Passes
For tasks where a small model meets the quality bar, the biggest saving no longer needs another provider. Claude Haiku 5.5 costs $0.10 per million input tokens and $0.50 per million output tokens for prompts up to 100,000 tokens, 95% less than Sonnet 5.5 and the same list price as OpenAI's GPT-6 Luna. Google's Gemini 3.5 Flash-Lite, at $0.30 and $2.50, costs more. Above 100,000 tokens Haiku 5.5 rises to $0.50 and $2.50, so very long prompts are worth pricing on other models too.
The key question is whether the task actually requires the strengths of a larger model, instruction-following nuance, long-context coherence and complex reasoning, or something more generic where a small model performs adequately. Short text classification, simple extraction from structured inputs, basic reformatting and FAQ-style question answering are typically well-served by Haiku 5.5 or a small model from another provider. Test on a sample of your own requests before you move a task.
Moving to another provider adds API format differences: if your application is built against the Anthropic SDK, routing to OpenAI requires code changes unless something in between handles the translation. Cross-provider LLM routing covers the architecture options for handling this cleanly.
What the Combined Savings Look Like
A team spending $5,000 per month on Claude, primarily using Sonnet 5.5 and Opus 5.5 without caching, without batching, and without output length controls, typically has a cost profile that looks like this: 40% of spend on Opus calls that could be Sonnet, 25% on uncached system prompts and retrieved documents, 20% on async workloads that could use the Batch API, and 15% from verbose output that explicit constraints would eliminate.
Working through those categories: moving appropriate Opus calls to Sonnet halves their price and saves roughly $1,000 of the $2,000. Enabling prompt caching at an 80% hit rate on the $1,250 of repeated content saves roughly $890 (reads at 0.05x, less the 1.25x write premium on the misses). Switching the $1,000 of async workloads to the Batch API saves $500. Cutting the verbose output in half saves roughly $375 of the $750. That is about $2,760 in reductions, landing at roughly $2,240 per month, before any simple task moves to Haiku 5.5. The categories overlap a little, so treat the total as an estimate.
In this example the bill drops by about 55%. The exact numbers depend on your workload mix, so measure your own before and after.
PromptUnit shows every request with the model asked for, the model that answered, what it cost and what it saved, which makes it straightforward to run this audit against your actual usage rather than estimates. It also checks each request and uses a cheaper model when one is just as good for it.
If you're starting from scratch on cost reduction rather than specifically targeting Claude, the guide to reducing OpenAI API costs covers the same framework applied to the OpenAI model lineup.
Start your Claude cost audit with PromptUnit at promptunit.ai.