Why Is My OpenAI API Bill So High?

Last updated: October 2026

Almost every developer hits the same moment: the first real OpenAI invoice. You expected tens of dollars. You got hundreds. And your first instinct — that something must be broken — is usually wrong. Nothing is broken. Your bill is high for predictable, fixable reasons, and they're the same reasons for nearly everyone.

This is a diagnostic checklist. Work through it in order, and you'll find where your money is going.

The Usual Culprits

1. Every call goes to the flagship model

This is the number one cause of bill shock, by a wide margin. Somewhere in your code there's a model name, and it's the biggest one — because that's the default, that's what the quickstart used, and nobody revisited it.

The problem: not every task needs the flagship. Classification, extraction, formatting, simple Q and A, summarization — these run fine on smaller, cheaper models. On OpenAI's current lineup, GPT-6.1 Sol is priced at $2.00 input / $10.00 output per 1M tokens versus GPT-5.6 Sol's promo $4.00 / $20.00. Same provider, same API shape, half the price. On our reference workload (1,100 tasks/month, 12K fresh + 48K cached input + 6K output per task), that's $97.68/month versus $205.92 — less than half, for tasks the smaller model handles fine.

The fix isn't "downgrade everything." It's routing: flagship for the hard stuff, smaller model for the routine stuff. Most teams find 60–80% of their calls don't need the flagship once they actually measure.

2. Uncapped output length

Output tokens are the most expensive tokens you buy — typically ~5x the input rate. On GPT-5.6 Sol's promo pricing, that's $20.00 per 1M output versus $4.00 per 1M input. Every token the model generates costs five times what it cost to feed it the prompt.

Now check: did you set max_tokens? If you didn't, the model decides how long its answer is. And models are verbose by default. Chain-of-thought reasoning, restated context, polite filler, long explanations nobody asked for — all billed at the 5x rate.

This is the easiest money to recover. Set explicit output caps per task type. A classification task doesn't need 2,000 output tokens. Neither does most extraction. Cap aggressively, then raise the cap only where quality actually demands it.

3. No prompt caching — or caching that never hits

If your workload repeats context — and agentic loops almost always do — prompt caching is the single biggest lever on your bill. On GPT-5.6 Sol, cached input reads cost $0.40 per 1M tokens versus $4.00 fresh. That's a 90% discount on every repeated token.

But there are two failure modes. The first is not having caching set up at all. The second, sneakier one: caching is "enabled" but your hit rate is near zero. Cache hits require the stable prefix of your prompt to be byte-identical across calls. If you're prepending timestamps, request IDs, or reshuffling prompt sections on every call, nothing matches the cache and you're paying full price while thinking you're optimized.

Check your actual cached-token ratio in the usage dashboard. If it's under 50% on a repetitive workload, your caching isn't working — the setup is the problem, not the concept.

4. Crossing the 272K threshold

This one is specific to GPT-5.6 Sol, and it bites hard. If a single request contains more than 272K input tokens, the entire request is repriced: 2x on input, 1.5x on output. Not just the tokens above the threshold — the whole call.

On promo rates, that turns $4.00/$20.00 into $8.00/$30.00 for the full request. A coding agent with a loaded repo plus a long conversation history can cross 272K without anyone noticing, and suddenly every one of those calls costs double on input.

If your bill has unexplained spikes, check your per-request token counts. A handful of threshold-crossing requests can dominate a monthly invoice.

5. Verbose outputs billed at 5x

Worth stating separately from the max_tokens point, because it's about design, not configuration. Every "explain your reasoning step by step" instruction, every request for the model to "be thorough," every agent loop that lets the model narrate its actions — that's output tokens at 5x input rates.

There's a second-order cost too: verbose outputs from one call often become input to the next call in an agent loop. You're paying 5x to generate tokens, then paying again to re-read them. Concise outputs compound their savings across the whole loop.

6. Reasoning tokens you never see

On reasoning models, there's a line item most developers don't know exists: the model's internal "thinking" tokens are billed as output tokens even though you never see them in the response. A request that returns 500 visible tokens may have burned 3,000 reasoning tokens behind the scenes — all at the 5x output rate.

This is by design and documented by providers, not a bug. But it means the true output cost of a reasoning-heavy task can be several multiples of what the visible response suggests. If your bill is high on an agentic workload and the visible outputs look modest, invisible reasoning tokens are a prime suspect. The mitigation is the same discipline as visible verbosity: match the reasoning effort to the task.

How to Audit Your Bill

Before changing anything, measure. The OpenAI usage dashboard gives you what you need:

Split spend by model. This takes thirty seconds and answers the biggest question: what share of your bill is the flagship? If it's over 80%, culprit #1 is your main problem.

Split by endpoint or API key. If you use separate keys per service or environment, you can see which part of your system is expensive. Often it's one endpoint doing most of the damage.

Measure your token mix. For your top endpoints, pull a sample of requests and compute: average fresh input tokens, cached input tokens, output tokens per call. The gap between "what we assumed" and "what's actually happening" is where the money is hiding.

Check for threshold crossings. Look at the distribution of input tokens per request, not just the average. Averages hide the ten 300K-token requests that each cost double.

Do this audit before optimizing. Otherwise you're guessing, and guessing at API costs is how you got the surprising invoice in the first place.

The 3 Fastest Fixes

If you want the biggest savings this week, in order:

1. Cap your outputs. Set max_tokens per task type today. This is a config change, not a project. Same-day savings on every call.

2. Route simple tasks to GPT-6.1 Sol. Pick your highest-volume, lowest-complexity endpoint, run a quality sample against the smaller model, and switch it if it clears your bar. On the reference workload this cuts the monthly cost from $205.92 to $97.68.

3. Fix your cache hit rate. Structure prompts with the stable content first and the variable content last, keep the prefix byte-identical across calls, and verify the hit rate in the dashboard. Going from 0% to 80% cached on a repetitive workload cuts the input portion of your bill by roughly 70%.

The Bottom Line

High OpenAI bills are rarely a mystery and never a bug. They're the predictable result of flagship-by-default, uncapped outputs, and unmeasured usage. The audit takes an hour. The three fixes take a day. And the developers who do this work stop being surprised by invoices — because they finally know what each request actually costs.

Popular posts from this blog

Argon vs Wonder: Which AI Should Developers Build On?

Image
Last updated: October 2026 Two flagship models, two very different price tags — and one of the prices is about to double. If you're choosing a foundation model to build on right now, the decision isn't just about capability. It's about timing. Here's the honest comparison: what each model costs, what the benchmarks actually say, and which one to pick depending on what you're optimizing for. The Pricing: Read the Dates Gemini 4 Argon is on introductory pricing: $2.00 per 1M input tokens / $10.00 per 1M output tokens . That intro rate runs through November 30, 2026 . From December 1 , the price doubles to $4.00 / $20.00 . Muse Wonder is priced at $4.00 / $20.00 per 1M tokens — no intro period, no scheduled change. So today, Argon costs half what Wonder does. On December 1, they cost exactly the same. That convergence matters more than it looks. Every cost comparison you run today has a 6-week expiry date. If you're doing the math — and you should be — do...
Read more

GPT-5.6 API Pricing: The November 21 Deadline

Image
Last updated: October 2026 If you're running GPT-5.6 through the API right now, you're on a promotional price. And that promotion has an expiry date: November 21, 2026 . OpenAI's pricing page states the current rate is "available at least through November 21, 2026." Read that carefully. "At least through" — not "until." The promo could extend. It could also end exactly on that date. OpenAI has published no pricing for what comes after. This post lays out exactly what the pricing is today, what it costs on a realistic workload, and how to budget for the unknown that follows November 21. The Current Pricing, Exactly GPT-5.6 is available in several variants. The one most developers are using — the flagship reasoning model, referred to here as GPT-5.6 Sol — is currently priced at: Input: $4.00 per 1M tokens Cached input: $0.40 per 1M tokens Output: $20.00 per 1M tokens That is promotional pricing. Before the promo, announced August 21, ...
Read more

Prompt Caching: The 90% Discount You're Missing

Last updated: October 2026 There is a 90% discount sitting in your API bill, and most developers are either not using it or using it in a way that doesn't work. Prompt caching — paying a tenth of the input price for tokens the provider has already seen — is the highest-leverage cost optimization available on modern LLM APIs. Here's how it actually works and how to get the savings. How Prompt Caching Actually Works The idea is simple. When you send a request, the provider processes your input tokens through the model — that's the expensive computation you're paying for. But if your next request starts with the exact same tokens — the same system prompt, the same repo context, the same few-shot examples — the provider doesn't need to recompute all of that. It kept the intermediate results cached. So it charges you a fraction of the price for those repeated tokens. The key phrase is stable prefix . Caching works from the start of your prompt forward: the provider ...
Read more