Cut Your LLM API Bill by 80%: The Five Levers, Ranked

Most teams discover their AI bill the way people discover a leaking pipe — the number on the invoice, weeks after the damage. The good news: LLM spending is unusually compressible. Unlike server bills, where a 20% cut takes an engineering quarter, an AI API bill can routinely drop 60–80% in a week of focused work, without changing what users see. This guide ranks the five levers by impact, with live prices showing what each one is worth.

Lever 1: Route requests to the right model tier (10–30× on routed traffic)

Nothing else comes close. The price spread between a flagship model and a budget model is one to two orders of magnitude — and most production traffic doesn't need a flagship. Here is the same workload (1,000 requests/day, 1,500 input / 400 output tokens each) priced from our live data, updated 2026-08-02:

The practical pattern is routing, not switching: classify each request (a cheap model can do the classifying) and send the routine 80–90% — extraction, classification, short factual answers, reformatting — to a budget model. Reserve the flagship for the hard tail: multi-step reasoning, nuanced writing, high-stakes answers. Teams that do this well keep flagship quality where users notice it and pay budget prices where they don't.

• Start with one obviously-routine request type and move only that. Measure. Expand.
• Judge quality with a small eval set before and after — "it seems fine" is how silent regressions ship.
• Compare candidate models on your exact workload in the API cost calculator — it reprices all 232 models we track against your numbers.

Lever 2: Prompt caching (up to −90% on repeated input)

Chatbots and agents resend the same system prompt, tool schemas, and conversation history with every single request. Providers bill cached input at roughly 10% of the fresh rate — but only if your prompts are structured so the repeated part is a byte-identical prefix. For a busy chatbot, this one feature commonly cuts the total bill 35–50%.

The full mechanics — provider differences, prefix discipline, the five-minute checklist — are in our prompt caching guide. The short version: static content first, dynamic content last, and never put a timestamp at the top of a prompt.

Lever 3: Batch API (−50% on anything that can wait)

Every major provider sells the same discount: submit requests as an asynchronous batch, accept results within 24 hours (usually much faster), pay half price — on input and output. Nightly report generation, embedding backfills, dataset labeling, content moderation sweeps, evals: none of these need an answer in 800ms, and all of them are probably running at full price right now. Details and provider comparison in the Batch API guide.

Lever 4: Cap and shape your output (output costs 3–5× input)

Output tokens are the expensive ones, and models are chatty by default — they restate the question, hedge, apologize, and summarize what they just said. Three fixes, in order of effort:

• Set max_tokens deliberately on every endpoint. It is a hard cost ceiling per request and your defense against runaway generations.
• Ask for the shape you need. "Answer in one sentence", "return JSON only", "no preamble" — instructions like these routinely cut output length 30–60% with zero quality loss on structured tasks.
• Prefer structured output modes (JSON schema / function calls) over prose you'll parse anyway — shorter, cheaper, and less error-prone.

Lever 5: Stop resending context you don't need

Input volume grows quietly. Conversation history accumulates turn by turn; RAG pipelines stuff ten retrieved chunks where three would do; agents carry a 4,000-token tool schema into every step. Discipline here compounds with every other lever:

• Summarize old conversation turns past a threshold (say, keep the last 4 verbatim, summarize the rest). Our chatbot calculator models exactly how fast resent history grows a bill.
• Tune RAG top-k down and measure answer quality — retrieval count is the single biggest input knob in a RAG system (RAG calculator).
• Give agents only the tools the current step needs — agents multiply every wasted input token by the number of loop steps (agent calculator shows the ×N effect).

Stacking the levers: a realistic example

A support chatbot on a flagship model at $1,000/month. Route 85% of conversations to a budget model (the classifier itself costs almost nothing): the routed traffic drops from ~$850 to ~$40–80. Enable caching on everything: the remaining flagship traffic drops by a third or more. Cap output and trim history: another 15–25% off what's left. Typical landing zone: $150–250/month for the same product — an 75–85% reduction, achieved in days, not quarters.

The order matters: do routing first (biggest win, changes which prices everything else multiplies against), caching second, then the trims. And re-measure after each step — the levers interact, and your mix of traffic is not anyone else's.

The 10-minute audit to find your 80%

1. Pull one day of usage from your provider dashboard: requests, input tokens, output tokens, and which models served them.
2. Put those numbers into the API cost calculator and look at the comparison table — that's your routing opportunity, priced.
3. Check the cached_tokens field in responses. Near zero? Lever 2 is free money.
4. List every job that could tolerate a delay. That list × 50% is your batch saving.
5. Read your five longest responses from yesterday. Count the sentences you didn't need.

Prices on this page refresh automatically from public listings — bookmark the live price table to catch the price drops that quietly change which tier wins.