To reduce LLM costs, send fewer tokens to cheaper models, and stop paying full price for work you repeat. In practice that means routing easy tasks to small models, caching the parts of your prompt that never change, batching anything that can wait and capping what the model writes.
None of it requires a weaker model for the hard parts, and every discount below is documented on the vendors’ own pages. Prices were checked on September 22, 2026. They change often, so confirm them before you plan a budget.
- Your bill is tokens times price, and output tokens cost five or more times as much as input tokens.
- Send each task to the smallest model that handles it well. Within one vendor’s lineup, prices vary up to 100 times.
- Cache the start of your prompt. Repeated input costs 90% less at Anthropic, OpenAI and Google, and more on some models.
- Batch anything that can wait up to a day, for half price.
- Measure cost per finished task, not per token, because retries, tools and tokenizers change the math.
How to reduce LLM costs: the eight levers
Every lever below either lowers the price per token or cuts the number of tokens.
| Lever | What it saves | Effort |
|---|---|---|
| Use a smaller model | Small models can cost a tenth, or even a hundredth, of a flagship | Medium: needs a test set |
| Cache repeated input | 90% or more off the cached part | Low |
| Batch what can wait | 50% off input and output | Low, for offline jobs |
| Trim the context | Every token you cut, on every call | Low |
| Cap the output | The most expensive tokens | Low |
| Set reasoning effort | Hidden thinking tokens, billed as output | Low |
| Reuse results | The whole call | Medium |
| Pick the right meter | Depends on how much you use | Low |
Watch the input you never typed. In a chat or agent loop, the whole conversation is resent on every turn. Tool definitions ride along too: Anthropic’s computer use toolset alone adds about 4,500 input tokens per request. Anthropic also notes that its newer tokenizer produces about 30% more tokens for the same text than older Claude models. Compare cost per task, not price per token.
For scale, Anthropic’s own worked example puts 10,000 support conversations of about 3,700 tokens each at roughly $37 on Claude Haiku 4.5. New to tokens? Start with tokens and context windows.
Use the smallest model that does the job
This is the biggest lever. Anthropic’s docs make the point directly: “you can sometimes improve latency and cost more easily by selecting a different model.”
| Model | Input | Output |
|---|---|---|
| GPT-6 Luna | $0.10 | $0.50 |
| Gemini 3.5 Flash-Lite | $0.30 | $2.50 |
| Gemini 3.8 Flash | $0.75 | $3.75 |
| Claude Haiku 4.5 | $1 | $5 |
| GPT-6 Sol | $2 | $10 |
| Claude Sonnet 5 | $2 | $10 |
| Gemini 3.1 Pro (preview) | $2 | $12 |
| Claude Opus 5.5 | $4 | $20 |
| GPT-6 Astra | $10 | $50 |
| Claude Fable 5.1 | $10 | $50 |
Standard API prices in US dollars per million tokens, as of September 22, 2026. Gemini 3.8 Flash is scheduled to rise to $1.50 and $7.50 on January 1, 2027. Gemini 3.1 Pro charges more for prompts over 200,000 tokens. For the fuller picture, including cached and batch prices, see our side-by-side API price table.
To route well, collect 20 to 50 real requests for one task, with answers you consider good. Run them through the cheapest plausible model first and grade the results. Move up a tier only for the cases it fails. A cheap model can also sort incoming requests, sending only the hard ones to a larger model.
Rerun the set when new models ship. Our guide to choosing an AI model covers the trade-offs.
Cache the part of the prompt that repeats
Most prompts start the same way every time: instructions, tool definitions, reference documents. Prompt caching stores the processed version of that shared start. Later requests that begin with identical text read it at a steep discount.
| Anthropic | OpenAI | ||
|---|---|---|---|
| Turning it on | One cache_control field, or manual breakpoints | Automatic | Implicit caching, on by default |
| Cached input price | 10% of normal; 5% on Opus 5.5 and 2.5% on Fable 5.1 | 10% of normal on GPT-6 models | 10% of normal on Gemini 3.8 Flash |
| Shortest prompt it caches | 512 to 4,096 tokens, by model | 1,024 tokens | 4,096 tokens on current models |
| How long a cache lives | 5 minutes, or 1 hour at a higher write price | 30 minutes after last use | Managed automatically |
Anthropic charges extra to write the cache: 1.25 times the input price for five minutes, twice for an hour. By its own math, the five-minute cache pays off after one reuse and the hour-long one after two.
Two rules make caching work. First, put stable content first and anything that changes last, as both OpenAI and Google advise. A timestamp at the top of your system prompt breaks the cache on every call. Second, watch the cached token count that each response reports. If it stays at zero, something near the top is changing.
1. System instructions same on every call
2. Tool definitions same on every call
3. Reference documents change rarely
4. Conversation so far grows each turn
5. The new request different every timeBatch what can wait, and skip paid speed
If a job does not need an answer in seconds, do not pay for seconds. Anthropic, OpenAI and Google all run batch APIs: you submit many requests at once and collect the results later, at half price.
Good batch jobs include evaluations, classifying a backlog, embedding a document collection and nightly reports. Discounts stack: Anthropic says its caching discounts apply on top of the batch discount. OpenAI’s Flex processing, in beta on selected models, charges batch prices for ordinary requests in exchange for slower responses and “occasional resource unavailability.”
Premium speed works the other way. Fast modes at Anthropic and OpenAI cost twice the standard rate, and OpenAI renamed its Priority processing to Fast mode on July 30, 2026. US-only processing on Anthropic’s API adds 10%. Pay for these only when a person is waiting or a contract requires it.
Send fewer tokens in and out
Trim the context
Every token in the prompt is billed on every call. Delete instructions that no longer change the output. Turn on only the tools a task needs. Retrieve the relevant passages instead of pasting whole documents: Anthropic estimates a research paper PDF at about 125,000 tokens. Summarize or restart long chats instead of carrying the full history.
Watch for price thresholds too. Gemini 3.1 Pro doubles its input price above 200,000 tokens, while Anthropic’s Claude 4.6 and later models charge the same rate across their full million-token window.
Cap the output
Output is the expensive side. Set a maximum length on every call, and ask for exactly the shape you need: a JSON object, a table, three bullets. For code, ask for a diff or the changed function rather than the whole file.
Answer in at most 5 bullet points, each under 20 words. No introduction, no summary, no restating the question. If you need more room to be accurate, reply "Needs more detail" instead of writing more.
Set reasoning effort per task
Reasoning models think before they answer, and OpenAI’s docs say that hidden reasoning is “billed as output tokens.” OpenAI and Anthropic both let you turn it down. OpenAI’s reasoning effort setting has levels from none to max, depending on the model, and “lower effort favors speed and lower token usage.” On Anthropic’s models, “higher effort elicits more thinking.”
Use low effort for extraction, formatting and simple questions, and save high effort for planning, debugging and hard analysis. Do not add “think step by step” to a reasoning model: a 2025 Wharton study found it gave marginal gains at best while adding time and tokens. See when reasoning models are worth it.
Stop paying twice, and pick the right meter
Reuse results
Provider caching discounts repeated input. Your own cache can skip the call entirely. Store answers to repeated questions, classifications and lookups. Re-embed only the documents that changed, and remove duplicates before a batch job.
Be careful with caches that match by meaning: “cancel my order” and “cancel my subscription” sound alike but need different answers.
Subscription or API
A plan gives one person a usage allowance for a flat fee. The API bills every token, with no allowance and no ceiling.
| Subscription plan | API | |
|---|---|---|
| You pay | A flat monthly fee | Per token, on every call |
| Examples | Claude Pro $20 a month, Max from $100; ChatGPT Plus $20, Pro from $100 | The prices in the table above |
| Limits | Usage windows that reset, such as Claude’s five-hour sessions plus weekly caps | Rate limits by account tier |
| Best for | One person chatting, writing or coding | Apps, automations and anything serving other people |
If one person uses AI heavily every day, estimate what a typical week would cost at API prices and compare it with the plan. Some plans also bend at the limit: Claude’s paid plans let you keep working with usage credits billed at standard API rates.
A monthly cost review
FAQ
What is the quickest way to reduce LLM costs?
Test a cheaper model on real examples of your most common task, turn on prompt caching, and move non-urgent work to a batch API. All three take little code, and none lowers quality on the tasks that pass your tests.
Does prompt caching change the answers?
No. It reuses the processing of identical input text, and Anthropic’s docs state the response is identical to what you would get without it. It only applies when the start of the prompt matches exactly.
Are cheaper models worse?
At hard, open-ended work, often. At classification, extraction, short rewrites and routing, small models are frequently good enough. Your own test set is the only reliable judge.
- Send most work to small models, and escalate only the failures.
- Put stable content first so caching can take 90% or more off it.
- Batch what can wait, cap output and set reasoning effort per task.
Next, see whether running models on your own machine makes sense for you, or compare open-weight and closed models.
- Pricing, Anthropic docs, accessed September 2026
- Prompt caching, Anthropic docs, accessed September 2026
- Prompt engineering overview, Anthropic docs, accessed September 2026
- Prompting best practices, Anthropic docs, accessed September 2026
- Plans and pricing, Anthropic, accessed September 2026
- API pricing, OpenAI, accessed September 2026
- Batch API, OpenAI, accessed September 2026
- Prompt caching, OpenAI, accessed September 2026
- Flex processing, OpenAI, accessed September 2026
- Reasoning models, OpenAI, accessed September 2026
- ChatGPT pricing, OpenAI, accessed September 2026
- Gemini Developer API pricing, Google, accessed September 2026
- Context caching, Google, accessed September 2026
- Batch API, Google, accessed September 2026
- Prompting Science Report 2: the decreasing value of chain of thought in prompting, Meincke, Mollick, Mollick and Shapiro, June 2025




