CostMonStart free

Guide

How to cut your LLM bill without downgrading your product

Five real levers, stacked in the order that actually pays. Modeled as a waterfall against your own token volume, with the exact break-even where prompt caching starts costing you money instead of saving it.

Start freeTry the calculator ↓

Why the math isn't additive, and the prompt-caching break-even

Why "stack five discounts" isn't as simple as adding percentages

Most lists of LLM cost-cutting tips quote each lever's headline discount and imply they add up. Batch at 50% off plus caching at up to 90% off cached reads looks like "140% cheaper." That's not how stacking works. Each lever only ever discounts whatever dollars the levers before it left standing, never the original baseline.

The calculator below runs the same five levers as an ordered waterfall: context trimming, then output discipline, then prompt caching, then model routing, then batch. Each lever's savings are computed against the running remainder, not the starting bill. That is the only arithmetic that reconciles with an invoice at the end of the month.

The order the levers run in, and why it isn't arbitrary

Context trimming and output discipline go first because they change how many tokens exist at all, before anything downstream gets priced. Output discipline is usually the biggest lever on the page. Output tokens are priced several times higher than input tokens on every model in this calculator. A modest cut to response length often outweighs a much larger percentage on a smaller cost base.

Prompt caching, model routing, and batch come next, in that order, because each one reprices whatever token volume and dollar cost the earlier levers left. Caching changes the per-token rate on the cacheable share of input. Routing reprices a share of what's left at a different model's rates. Batch discounts whatever remains after both. A different order changes every downstream dollar figure.

Prompt caching can cost you money: the exact break-even

A cache hit is cheap: it bills at roughly a tenth of the base input rate on every provider in this calculator. But a cache miss isn't free either. It bills as a cache WRITE, at a premium over the base input rate. On Anthropic's published rates, that is 1.25x for a 5-minute entry and 2x for a 1-hour entry. Below a certain hit rate, the write premium on the misses outweighs the discount on the hits. Then caching costs more than never caching at all.

The exact break-even is where the blended rate equals the plain, uncached rate. Solve hit × 0.10 + (1 − hit) × writeMult = 1 for hit. At the 1.25x 5-minute write multiplier that's (1.25 − 1) / (1.25 − 0.10) ≈ 21.7%. At the 2x 1-hour write multiplier that's (2 − 1) / (2 − 0.10) ≈ 52.6%. Drag the cache-hit-rate slider below that line for either TTL. The calculator then reports a negative saving in brick. The commitment-discount calculator on this site treats an under-used Reserved Instance the same way.

Free tool

Model your own five-lever waterfall

Start from a real-world workload, or drop in your own numbers. Every lever below is applied to whatever the levers before it left. It computes live in your browser. Nothing typed here is sent anywhere.

Not sure of your volume? Start from a real-world workload:

The model your baseline cost is priced at today.

60M

Everything sent to the model: prompts, context, tool results

12M

What the model generates back, usually priced several times higher than input

Prompt caching
60%

Share of input tokens that are a stable, repeated prefix, such as a system prompt, tool schema, or reference document

55%

Share of cacheable requests that actually hit a warm cache instead of writing a new one

Cache entry TTL

A 1-hour cache entry costs more to write but stays warm longer, which usually raises your realized hit rate

Break-even hit rate at this TTL: 21.7%

Context & output
20%

How much of the non-cacheable input (history, retrieved passages) you can drop without losing correctness

20%

How much shorter responses get from a max_tokens ceiling or a tighter output format

Routing & batch

The cheaper model the "routable share" below actually sends traffic to.

30%

Requests simple enough that a faster, cheaper model completes them just as well

20%

Requests with no one waiting synchronously on the response, like backfills, evals, or nightly jobs

Your waterfallClaude Sonnet 5
Live
Estimated monthly cost after every lever$137
Baseline (no levers)
$240
Total saved, monthly
$103
Total saved, annualized
$1,238
Effective blended rate
$1.90/1M tokens
LeverSaved this monthRunning costWhat it costs you
Context trimming$10$230

Engineering time to find and cut redundant context: repeated history, unused tool schemas, dead system-prompt sections. Done right, it has no latency or quality cost; done carelessly, it silently drops context the model needed.

Don't trim context the model needs for correctness just to hit a token target. A wrong answer costs far more than the tokens it would have saved.

Output discipline$24$206

A max_tokens ceiling or a stricter output format can truncate a long answer that would otherwise have been correct. Output is priced several times higher than input, so this is usually the biggest lever. Test it against your real task before shipping.

Don't cap output on tasks whose correct answer is legitimately long, such as full documents, complete code files, or exhaustive lists. A truncated answer isn't cheaper. It's wrong.

Prompt caching$28$179

Zero latency or quality cost on a hit, but a real write premium (1.25x–2x base input) on every miss. Below the break-even hit rate above, this lever is actively costing money, not saving it.

Don't enable caching on a prompt whose cacheable prefix rarely repeats between requests. Below break-even, caching is a net loss.

Model routing$27$152

Routing to a cheaper model only pays off if that model finishes the task. A retry, an escalation to the frontier model, or a wrong answer reaching a customer all cost more than the per-token saving bought back.

Don't route tasks that need real reasoning depth to a fast/cheap tier just because the sticker price per call is lower. Measure cost per completed outcome, not cost per call.

Batch API$15$137

Little to no engineering cost beyond an asynchronous code path, but a response can take up to 24 hours to come back. That makes this lever unusable for anything a user is waiting on in real time.

Don't route interactive, user-facing traffic through a batch endpoint. It's built for backfills, evals, and nightly jobs, not synchronous requests.

Start freeSee how CostMon watches AI spend

Model prices as of 2026-09-27 ( Anthropic, OpenAI, Google); batch/caching/routing rates as of 2026-08-02. See the sources below. List prices, not a quote. Computes entirely in your browser. Nothing typed here is sent anywhere.

What each lever costs you, cost-per-outcome, and what CostMon does here

What each lever costs you, not just what it saves

Every lever above has a real cost besides engineering time, and this page states it next to the dollar figure, not in a footnote. Prompt caching writes a fresh entry at a premium whenever the cache misses. Output discipline can truncate a correct but long answer. Context trimming can cut something the model needed. A naive percentage-off calculation shows none of these. This page models the trade-off next to the saving, lever by lever, in the table above.

Model routing and batch carry the largest operational trade-offs of the five. Routing to a cheaper model only pays off if that model finishes the task. A wrong answer, a retry or an escalation to the frontier model erases the per-token saving many times over. Batch trades a real-time response for an asynchronous one, on a completion window that can run up to 24 hours. That makes it a free discount for anything that isn't user-facing, and a non-starter for anything that is.

See how CostMon watches AI spend per-model and per-workload →

Cost-per-outcome, not cost-per-call

A cheaper model's per-token price is only a real saving if it completes the same task at an acceptable quality bar. Comparing models on the sticker price per call, without checking completion rate, is the mistake this page's routing lever is built to catch. A model that's 3x cheaper per call but needs a second call to finish the job isn't cheaper at all.

Route by task, not by default. First, send a representative sample of the routable share through the cheaper model. Measure how often it completes the task, escalates or gets it wrong. Only then trust the routing percentage the calculator above is modeling.

Read the Playbook's AI/LLM spend section →

What CostMon does, and doesn't, here

CostMon pulls actual AI/LLM spend from providers like Anthropic and OpenAI. It normalizes that spend into the same daily view as the rest of the stack. You see it per model and per workload, with anomaly alerts on drift. You can see whether a lever you flipped moved the number it was meant to. Examples are a new cache-hit rate, a routing change or a batch migration. You don't wait for the next invoice.

CostMon does not implement any of the five levers on this page for you. It doesn't write your prompt-caching code, route your requests to a cheaper model, or migrate a workload to a batch endpoint. Those are engineering changes your team makes; what CostMon does is show the real, daily, per-model spend that tells you whether they worked.

See how CostMon tracks AI spend →Set an alert before a regression compounds →

Sources

Where the batch, caching, and routing rates on this page come from

Every discount and multiplier above is attributed to a named provider source, re-verified live as of 2026-08-02. Model list prices come from the same table behind the LLM Cost Calculator, not a forked copy.

  • Anthropic — Prompt caching

    Cache writes bill at 1.25x base input for a 5-minute TTL entry, or 2x base input for a 1-hour TTL entry; cache reads bill at 0.10x base input. Source for CACHE_WRITE_MULTIPLIER and CACHE_READ_MULTIPLIER.

  • Anthropic — Message Batches API

    50% off both input and output tokens vs. standard synchronous pricing; most batches complete in under an hour with a 24-hour maximum. States explicitly that the batch discount stacks with prompt caching's cache-read discount.

  • OpenAI — Batch API

    50% cost discount vs. synchronous API pricing, with a fixed 24-hour completion window.

  • OpenAI — Prompt caching

    Cached input bills at 0.10x standard input price once a prompt prefix reaches at least 1,024 tokens; a cache write carries a 1.25x premium over uncached input on GPT-5.6 and later, including GPT-6.

  • Google — Batch Mode

    50% off standard pricing, with a 24-hour target turnaround; cache hits inside a batch job bill at Gemini's standard context-caching rates.

Related reading

What is your AI bill actually telling you?

Drop in a real Claude or OpenAI usage export. See which of these levers your own numbers point to, instead of guessing at a starting scenario.

What does your AI usage actually cost?

Model token volume, input/output pricing, and prompt caching to see the plain cost of a workload before you start cutting it.

The AI agent cost guide

Why agentic, multi-step tool-use workloads cost far more than a single call. It also shows where the fan-out comes from that the routing and batch levers on this page can't fix.

Should you commit, and how much?

The cloud-side version of this. A break-even calculator reports a negative saving when a commitment goes underused, as this page does for prompt caching.

Training or serving on your own GPUs?

Self-hosted models run on GPU nodes, and an idle node bills by the hour. Price nine EC2 GPU instance types.

FAQ

Common questions about cutting AI/LLM cost

Why don't the five levers' savings just add up to the sum of their percentages?

Each lever only discounts whatever dollars the levers before it left standing. It does not discount the original bill. Batch at 50% off plus caching at up to 90% off cached reads is not "140% cheaper." The calculator runs them as an ordered waterfall. Each lever applies to the running remainder. That is the only arithmetic that reconciles with an actual invoice.

What is the prompt-caching break-even, and why does it matter?

It's the cache-hit rate below which caching costs MORE than never caching at all. It is about 21.7% at the 1.25x 5-minute write multiplier. It is about 52.6% at the 2x 1-hour write multiplier. A cache miss bills as a write at a premium over the base rate. At a low enough hit rate, the write premium on the misses outweighs the discount on the hits. Below that line, the calculator reports a negative saving.

Which lever usually saves the most?

Output discipline, more often than not. Output tokens are priced several times higher than input tokens on every model. A modest cut to response length often outweighs a bigger percentage applied to a smaller input cost base. The answer depends on your actual input/output mix and cacheable share. The calculator above shows it.

Is model routing safe for every workload?

No. Routing to a cheaper model only saves money if that model completes the task at an acceptable quality bar. A retry, an escalation back to the frontier model, or a wrong answer reaching a customer all cost more than the per-token saving bought back. Route by measured completion rate on a representative sample, not by assuming a lower sticker price transfers directly to a lower real cost.

Can I run interactive, user-facing traffic through a batch endpoint?

No. Batch processing trades a real-time response for an asynchronous one, on a completion window that providers publish as up to 24 hours. It's a free discount for anything nobody is waiting on synchronously (backfills, evals, nightly jobs) and unusable for anything a user is waiting on.

Where do the model prices and workload numbers in this calculator come from?

Model list prices come straight from the same table behind the LLM Cost Calculator (src/data/llmPricing.ts); this page doesn't fork or re-key them. The default scenario mirrors the Support Chatbot preset from that same calculator's workload library, so the two tools start from a consistent baseline.

Does CostMon implement caching, routing, or batching for me?

No. Those are engineering changes your team makes to your own request code; CostMon doesn't write prompts, route calls, or migrate workloads to a batch endpoint. It normalizes your actual AI/LLM spend into a daily, per-model, per-workload view. You can see whether a change you shipped moved the number. You don't wait for next month's invoice.

Does the 50% batch discount really stack with prompt caching?

Yes, for Anthropic's Message Batches API: its own documentation states the batch discount stacks with prompt caching's cache-read discount. That's why this page runs batch last in the waterfall. It discounts whatever cost caching (and every earlier lever) already left behind, rather than being modeled as a separate, unrelated saving.

Why is a negative saving shown in a brick/red color instead of just being hidden?

It is a real number, not an error state. Below the cache break-even hit rate, caching costs more than not caching at all. An under-used commitment discount in the commitment-discount calculator on this site works the same way. It costs more than staying on-demand. Hiding a negative result would make the calculator wrong at the one point where it matters most.

Token spend moves every day.

Model prices and rate limits change between invoices. CostMon tracks your AI spend daily, so a change shows up before the bill does.

Start freeSee what a token costs
Esc