# Why Is My OpenAI Bill So High? A Diagnostic Checklist

Eight causes explain almost every oversized OpenAI bill: reasoning tokens, context bloat, agent loops, retries, wrong model, no caching, uncapped output, forgotten keys.

*Published 2026-06-12 · https://proxyllm.ai/blog/why-is-my-openai-bill-so-high*

An oversized OpenAI bill almost always traces to one of eight causes, and your usage data can confirm which one in minutes. Ranked by how often we see them in request logs: reasoning tokens, context bloat, agent loops, retry storms, an overqualified model, missing cache hits, uncapped output, and forgotten keys. Work down the list; each entry says exactly where to look.

## Start with the data

Three places hold the evidence. OpenAI's usage dashboard breaks spend by day, model, and API key. The API response itself carries per-request truth in the `usage` object, including reasoning and cached token counts. A request log (our free tier includes one) keeps the per-call history the dashboard aggregates away.

If the bill jumped overnight rather than crept up, start with [the 10-minute spike diagnosis](/blog/openai-api-costs-suddenly-high) instead; this checklist is for bills that are consistently higher than they should be.

## The eight causes, ranked

### 1. Reasoning tokens

Reasoning models think before they answer, and the thinking bills at the output rate. A 150-token visible reply can bill 1,500 output tokens. **Confirm:** `usage.completion_tokens_details.reasoning_tokens` in responses, or output counts far above visible answer lengths. The full math is in [reasoning tokens, the hidden multiplier](/blog/openai-reasoning-tokens-cost).

### 2. Context bloat

The API is stateless, so every turn resends the system prompt plus the entire history. Cost compounds as conversations run long. **Confirm:** input tokens per request climbing steadily through a session. Worked example below.

### 3. Agent loops

An agent that takes 12 steps bills 12 model calls per user action, each carrying cumulative context. One "request" in your product can be fifty on your invoice. **Confirm:** model calls per user action far above one; bursts of related requests in the log.

### 4. Retry storms

Timeout-and-retry code without backoff multiplies traffic exactly when the API is slow. **Confirm:** clusters of near-identical requests seconds apart; 429 or timeout errors followed by repeats.

### 5. An overqualified model

GPT-5.5 at $5/$30 per million tokens classifying support tickets that GPT-5 Mini handles fine at $0.25/$2. **Confirm:** the usage dashboard by model. If the flagship dominates request count rather than just the hard tasks, you are overpaying per call.

### 6. Missing cache hits

OpenAI discounts repeated prompt prefixes 90 percent, but only when the prefix is byte-identical and at least 1,024 tokens. A timestamp at the top of the system prompt silently forfeits the discount. **Confirm:** `usage.prompt_tokens_details.cached_tokens` stuck at zero on traffic that repeats a prefix. Structure rules: [prompt caching explained](/blog/openai-prompt-caching-explained).

### 7. Uncapped output

No `max_output_tokens`, prompts that invite essays. Output costs eight times input on GPT-5, so verbosity is expensive on the wrong side of the price sheet. **Confirm:** average output tokens per route; anything chatty on an internal endpoint is waste.

### 8. Forgotten keys and zombie jobs

A staging cron, an old demo, a teammate's experiment. **Confirm:** per-key spend you cannot attribute, or steady usage at hours your product is idle.

## Worked example: what context bloat costs

A support chat on GPT-5 ($1.25 per million input tokens as of June 2026; live rates at [OpenAI's pricing page](https://openai.com/api/pricing)). Each turn sends an 800-token system prompt and a 100-token user message, and every completed turn adds about 350 tokens of history. Turn n input ≈ 900 + 350 × (n − 1) tokens.

Over a 20-turn conversation:

- Resend everything: 20 × 900 + 350 × 190 = 84,500 input tokens
- Keep only the last 6 turns: 52,650 input tokens

| Strategy          | Input tokens per conversation | Cost per conversation        | Monthly at 1,000 conversations/day |
| ----------------- | ----------------------------- | ---------------------------- | ---------------------------------- |
| Resend everything | 84,500                        | 84,500 × $1.25 ÷ 1M = $0.106 | $3,169                             |
| Last 6 turns only | 52,650                        | 52,650 × $1.25 ÷ 1M = $0.066 | $1,974                             |

Trimming history to the last six turns cuts this input bill 38 percent, about $1,194 a month, with zero model changes. Output spend is untouched either way.

## Fix in order of impact

Once the cause is confirmed, fix in this order: route to the right model and cap output (config changes), then restructure prompts for caching, then batch what can wait. Every lever with its numbers is in [how to reduce OpenAI API costs](/blog/reduce-openai-api-costs). To make the next anomaly stop itself instead of running for a week, put hard budgets on each app: [spending limits](/blog/openai-api-spending-limits).

Most surprise OpenAI bills come from tokens you never see: reasoning, resent history, and retries. Once the per-request evidence is in front of you, the fix is usually one afternoon. If you would rather not build that logging, our free tier records every call with its cost, and the [calculator](/calculator) shows what the corrected bill should look like.