To reduce OpenAI API costs, first find out which token type is spending the money. Then work through eight levers in order: keep the prompt prefix stable so the automatic cache hits, move anything that can wait to Batch or Flex, pick the model per request, set reasoning_effort per request, cap and shrink the output, trim the input and stay under the 272K long-context line, keep Fast mode and Ultrafast for requests a person is waiting on, and add a router last. Caching and service tiers change the price of tokens you already send. The other levers change how many tokens you send, or which model reads them.
This is a checklist, not a benchmark. It contains no savings percentage, because the result depends on your traffic. Prices and multipliers come from OpenAI's model pages and API docs as of November 2026. Check them on [OpenAI's pricing page](https://developers.openai.com/api/docs/pricing) before you plan around them.
Where an OpenAI API bill comes from.
Each request bills three token types:
| Token type | What it is | Rate on the GPT-6 family |
|---|---|---|
| Cached input | A prompt prefix OpenAI has seen recently | 5% to 10% of base input, depending on model |
| Uncached input | Everything else in the prompt | Base input rate |
| Output | The answer, tool calls and reasoning tokens | 5x input on every GPT-6 model |
The model sets the base rate. The GPT-6 family runs from GPT-6 Luna at $0.10 input and $0.50 output per million tokens to GPT-6 Astra at $10 and $50, a 100x spread (price card). Two more settings multiply the rate. The service tier moves it from half price (Batch, Flex) to 2x (Fast mode) and higher (Ultrafast). And on every GPT-6 and GPT-6.1 model, a prompt over 272K input tokens bills at 2x input and 1.5x output for the whole request.
Step 0: measure before you change anything.
- The `usage` object on every response reports
prompt_tokens(input_tokenson the Responses API), the cached share underprompt_tokens_details.cached_tokens, andcompletion_tokenswith the reasoning share undercompletion_tokens_details.reasoning_tokens. Log it per request together with the feature that sent it. - The usage dashboard and Usage API break spend down by model, project and API key. Give each service its own project or key, and the breakdown becomes per service.
If uncached input is the largest share, start with levers 1 and 6. If output is, and most of it is reasoning tokens, start with lever 4. If one model is most of the bill, start with lever 3.
The eight levers.
1. Keep the prefix stable so the automatic cache hits
OpenAI caches prompt prefixes automatically, from 1,024 tokens, with no write premium and no flag to set. A cache hit bills at a tenth of base input or less on the GPT-6 family. You still decide whether it hits. Put everything that does not change between requests first: system prompt, tool definitions, reference documents, few-shot examples. Put the user's input last. A timestamp, a request ID or a reordered tool list near the top breaks the match for everything after it. If cached_tokens stays at zero on requests that share a long prefix, the prefix is not stable. More on why caching is the cheapest lever in The Closest Thing to Free Money.
2. Move anything that can wait to Batch or Flex
The Batch API bills about half the Standard rate and returns results within 24 hours. Flex processing gives Batch prices on ordinary Responses and Chat Completions calls, in exchange for slower responses and occasional 429s when capacity is tight. Requests that get a 429 are not billed. Evaluations, backfills, enrichment, classification and nightly reports belong on one of the two. On Flex, catch the 429 and retry with service_tier: "auto". GPT-6.2 Astra and Sol have no Flex. On those two, use Batch or the new background windows on the Responses API, 30% off for a 2-hour window and 40% off for an 8-hour one, covered in GPT-6.2 Quietly Dropped Flex. The full tier ladder is in Four Prices, One Model, and the batch discounts across providers are in Half Price, One Day Late.
3. Pick the model per request
This is the biggest lever on the list. Luna and Astra are 100x apart per token, with Terra and Sol in between. Classification, extraction, short rewrites and routing decisions rarely need Sol, let alone Astra. Choose the model in code for each request type, instead of one model for the whole service. Compare cost per task, not per token: a cheaper model that needs a retry, or reasons for longer, can cost more per finished answer. In a multi-turn conversation, choose at the start. The cache is per model, so switching models mid-conversation re-sends the whole prefix at full price. The break-even math is in Your Router Is Fighting Your Prompt Cache.
4. Set reasoning effort per request
Reasoning tokens bill as output, the most expensive token type, and nobody reads them. Set reasoning_effort per request type, not once for the whole service. GPT-6 Sol and Luna still accept "none", which is the right setting for lookups and formatting. GPT-6 Astra no longer does, so every Astra call pays for reasoning. That alone is a reason to keep Astra off simple traffic. Cross-provider settings are in The Overthinking Tax.
5. Cap and shrink the output
Output costs 5x input on every GPT-6 model. Set max_output_tokens (max_completion_tokens on Chat Completions) to what the feature needs. Ask for the format you will parse: a label, or a JSON object with only the fields you read. No preamble, and no restating the question. Use Structured Outputs when you parse the result, so a malformed answer does not cost a retry. More patterns are in The Expensive Half.
6. Trim the input and stay under 272K
Send the relevant chunk, not the whole document. Drop tool definitions the request cannot use. In long conversations, clear old tool results instead of carrying them forward, because every turn re-sends the history. Watch the 272K line in particular. A prompt one token over it pays 2x input and 1.5x output on the entire request, not only on the tokens past the line. The cliff is worked through in The 272K Cliff. Trimming inside the cached prefix changes the prefix, so trim when you deploy, not on each request.
7. Keep Fast mode and Ultrafast for requests a person is waiting on
Fast mode, formerly Priority Processing, bills 2x Standard. Ultrafast on GPT-6.1 Sol costs more per token than GPT-6 Astra at Standard. Both buy latency, which pays off only when a person is waiting on the answer: a chat reply, an in-editor completion, a voice turn. Background jobs and agents running unattended should never set them. The Price of a Second shows how to price a second of waiting.
8. Add a router last
Choosing the model in code (lever 3) works until the request types blur and nobody can say which ones need the big model. A router makes that choice per request. It helps when your traffic is a real mix of easy and hard requests and you would otherwise send all of it to Sol or Astra. It does not help when the cheap model already passes nearly everything, when the candidate models are close in price, or when a switch would throw away a warm cache. We published our own negative results in When LLM Routing Does Not Help, and compared the products in How to Choose an LLM Router.
ChatGPT plans are a different bill.
ChatGPT Plus, Pro and Business are flat subscriptions with usage limits, and nothing on this list changes them. This checklist applies to the OpenAI API, which bills per token: your own apps, agents, and Codex when it runs on an API key. If your team uses both, measure them separately. A subscription seat can cost less than the same work at API prices, or much more, depending on how heavily the seat is used.
A team is a different problem.
For one service, the levers above are code changes. For a team, they become policy: a model allowlist, a budget per project, and spend broken out by owner. OpenAI projects and a gateway such as LiteLLM, Bifrost or Portkey enforce the budget and the allowlist. A router decides the model inside those limits. These are separate layers, compared in AI gateway vs model router.
Where Nadir fits.
Nadir covers lever 8 and part of lever 4.
- Model and effort per request. Nadir is a decision layer for the model and reasoning effort of each request. It is OpenAI-compatible: point the OpenAI SDK's base URL at
https://api.getnadir.com/v1and sendmodel="auto". It also runs beside an existing gateway, including LiteLLM as the nativenadir/autoprovider. It starts in shadow mode and returns a receipt for each decision, covering model, effort, cache, policy and cost. The decision API returns the plan without calling your model provider. It costs $0.002 per request, with the first 50 a month free, and takes no markup on model spend. - Measuring Codex usage.
npx nadir-receiptprices your local Codex and Claude Code history at API list prices. It runs locally and makes no network calls. Details are on the receipt page.
Nadir does not do levers 1, 2, 5, 6 or 7 for you. Cache structure, service tier, output size, input size and Fast mode are yours to change, and on many workloads they are the larger share of the bill. Nadir publishes no universal savings rate. Measure first, then decide whether a router is worth adding.
If you use Claude as well, the Anthropic version of this checklist is How to Reduce Claude API Costs.
Conclusion.
First find out which token type is spending the money. Before anything else, keep the prefix stable and move work that can wait onto Batch or Flex. Choose the model and reasoning effort per request, cap the output, stay under 272K, and pay for speed only where someone is waiting. Add a router once the choice needs to happen without anyone maintaining it by hand.