Clawy / Guides / Cut your LLM API costs

How to cut your LLM API costs without dumber answers

Six levers that lower your OpenAI or Claude bill — ordered by impact. Most teams leave the first two on the table.

LLM bills balloon for boring reasons: the wrong model on easy tasks, uncapped output, the same context re-sent uncached every call. None of these require accepting worse answers. Here's where the money actually goes, biggest lever first.

1. Match the model to the task

This is the single biggest lever, and it's free. Frontier models are priced for frontier work; most production calls aren't frontier work. Claude's list rates span a 5× range on input and output:

Routing your high-volume, low-difficulty calls to Haiku instead of Opus is a 5× cost cut on those calls with no quality loss — because they never needed Opus. Reserve the expensive model for the requests that actually move your quality metric. (Not sure which to pick? See which Claude model to use.)

2. Cache your repeated context

If every request re-sends the same big system prompt, few-shot examples, or document, you're paying full input price for identical tokens. Prompt caching charges the cached prefix at roughly 10% of normal input price on a hit. For an agent with a 10k-token fixed preamble, that's most of your input cost gone.

The catch is that caching is a prefix match: one byte change anywhere in the prefix invalidates everything after it. Silent cache-killers to audit for: a datetime.now() or UUID in the system prompt, unsorted JSON serialization, or a tool list that changes per request. Verify hits with the cache_read_input_tokens field in the response — if it's zero across identical-prefix calls, something is invalidating it.

3. Cap your output

Output costs 3–5× more than input per token, and an unbounded max_tokens lets a single chatty response run up the bill. Set a max_tokens that fits the job — a classifier needs 50 tokens, not 4,000. If you've enabled extended/adaptive thinking, remember those reasoning tokens bill as output too.

4. Send less context

Input tokens are real money, and "stuff the whole document in" is the most common waste. Retrieve and send only the relevant chunks instead of the full corpus. Trim conversation history (or summarize it) once it's long. Every 10k tokens you don't send to Opus is $0.05 you keep, per call.

5. Batch the non-urgent work

If a workload doesn't need an instant answer — overnight classification, bulk summarization, evals — the Batch API runs the same requests at 50% off, typically completing within an hour. Anything that can tolerate latency should go through it.

6. Default to the cheapest model that works

Make "cheap" the default and escalate deliberately, not the other way around. A simple router — try the cheap model, fall back to a stronger one only when the task needs it — captures most of lever #1 automatically.

None of these trade quality for cost — they stop paying frontier prices for non-frontier work and stop paying twice for the same tokens. Measure first (know your per-call cost), then pull the levers in order.