If you are running any volume of traffic through OpenAI's API, the OpenAI token cost and token price you are quoted per million tokens only tell part of the story. This guide covers what OpenAI actually charges across its current model line-up, how that cost compounds once you move from a prototype to production volume, and why the number on your OpenAI invoice is smaller than your true AI spend.
How OpenAI token pricing works
OpenAI, like every major model provider, bills per token rather than per request. A token is roughly 0.75 words of English text, so "the quick brown fox" is about five tokens. Every API call is billed on two separate meters: input tokens, which cover the system prompt, any conversation history, and the user message you send, and output tokens, which cover the text the model generates in response. Output is always priced higher than input, typically by a factor of four, because generating new tokens is more computationally expensive than processing tokens that already exist.
OpenAI's pricing varies substantially by model tier. Representative rates across the models most teams are choosing between:
| Model | Input (per million tokens) | Output (per million tokens) |
|---|---|---|
| GPT-4o | $2.50 | $10.00 |
| GPT-4o mini | $0.15 | $0.60 |
| o3 | $2.00 | $8.00 |
| o1 | $15.00 | $60.00 |
The spread is the point worth sitting with. GPT-4o mini is roughly 16 times cheaper than GPT-4o on both input and output for the same token volume. o1, OpenAI's original reasoning model, is six times the price of GPT-4o on both meters. o3, despite also being a reasoning model, is priced below GPT-4o on both input and output, reflecting the price reduction OpenAI made to the o3 line during 2025. Model choice is the single biggest lever on your OpenAI token price, and it is a lever most teams pull once, at build time, and then never revisit as usage scales.
How OpenAI token cost compounds at scale
The per-million rate looks small in isolation. It stops looking small once you multiply it by request volume. Take a workflow with an average of 1,000 input tokens and 300 output tokens per call, a realistic profile for a moderately complex prompt with a short response, and run it across GPT-4o at increasing volume:
| Monthly API calls | GPT-4o cost per month | GPT-4o mini cost per month |
|---|---|---|
| 10,000 | $55 | $3.30 |
| 100,000 | $550 | $33 |
| 1,000,000 | $5,500 | $330 |
At a million calls a month, the same workload costs $66,000 a year on GPT-4o and roughly $3,960 a year on GPT-4o mini. Neither figure is wrong: they are the correct arithmetic for the model you chose. The question most teams never ask is whether the task actually needed GPT-4o in the first place, and that question gets more expensive to have skipped as volume grows. A prototype built on GPT-4o that quietly becomes a production workflow at a million calls a month is not a rounding error. It is a six-figure annual decision that nobody consciously made.
Why your OpenAI invoice understates your total AI cost
The OpenAI invoice captures exactly one thing: the metered cost of tokens processed and generated through the API. Analysts at FinOps X in June 2026 identified nine distinct cost buckets in a typical AI deployment. Only one of them appears on any vendor bill.
OpenAI's own usage dashboard at platform.openai.com/usage shows day-level spend by model, which is enough to see the invoice total trending up but not enough to see why. Per-request granularity requires Admin API access, and even then the dashboard shows what you spent, not where the inefficiency sits. The full breakdown of all nine buckets, and why the invoice is structurally incapable of showing the other eight, is covered in the AI token cost guide.
The most common OpenAI-specific cost drivers
System prompt bloat. System prompts accumulate instructions over months as edge cases get patched in and nobody removes what is no longer needed. Every additional instruction is sent, and billed, on every single call. TokenomicsIQ's diagnostic flags any system prompt accounting for more than 30% of total tokens per request as a priority fix. The mechanics of identifying and fixing it are covered in the system prompt bloat guide.
Cache miss rate. OpenAI applies prompt caching automatically to any prompt with a repeated prefix of 1,024 tokens or more, at no setup cost. The problem is not that the feature is hard to use. It is that most prompt structures accidentally defeat it. If the variable part of your prompt (a timestamp, a user ID, a piece of session context) sits near the front rather than the end, the cached prefix breaks on every call and you pay full input price when you did not need to. Reordering a prompt so static content comes first and variable content comes last is often a same-day fix with an immediate reduction in effective input cost.
Model-task mismatch. This is the most common and most expensive pattern: using GPT-4o for tasks that GPT-4o mini handles to an equal standard. Classification, short-form extraction, simple Q&A, and routine summarisation are frequently well within GPT-4o mini's capability, at roughly one sixteenth of the cost.
$2.50 / $10.00 per million. Suited to complex reasoning, nuanced generation, and tasks where output quality has a documented dependency on model capability.
$0.15 / $0.60 per million. Suited to classification, short extraction, simple Q&A, and structured tasks where GPT-4o produces no measurable quality improvement.
The test is not whether GPT-4o produces a better result. On most narrow, well-defined tasks it will, marginally. The test is whether that marginal improvement is worth 16 times the cost at your call volume. For a workflow running a few hundred calls a month, the answer may not matter. For a workflow running a million calls a month, it is the difference between $5,500 and $330 every single month.
How to reduce your OpenAI token cost
Three actions ranked by typical impact
Structure prompts to maximise cache hits. Put static content, system instructions, shared context, reference documents, first in the prompt, and variable, per-request content last. OpenAI's automatic caching then applies to the stable prefix on every call, billing the cached portion at 50% of the standard input rate with no code changes required beyond the reordering itself.
Route tasks to the correct model tier. Map your workflows by task type and identify which ones are running on GPT-4o or o1 unnecessarily. Classification, extraction, and short-form generation are typically well served by GPT-4o mini or a smaller o-series model. This is the single largest lever in the pricing table above, and it is entirely within your control.
Move latency-tolerant jobs to the Batch API. OpenAI's Batch API processes requests asynchronously, typically within 24 hours, at 50% of standard pricing across input and output. Reporting pipelines, bulk content generation, overnight classification runs, and any job where the result does not need to come back in real time are candidates. It halves the token cost with no change to output quality.
These three changes compound. A workflow that is right-sized to GPT-4o mini, structured for cache hits, and routed through batch where latency allows can see its effective OpenAI token cost fall by an order of magnitude from where it started, without any change to what the workflow actually does. The step most teams skip is the audit that tells you which workflows to prioritise first. That process is covered in detail in the guide to auditing your LLM token spend, and the broader spend picture, across providers and cost buckets, is covered in the AI spending overview.
Getting a diagnostic on your OpenAI usage
OpenAI's own dashboard exports are day-level aggregates, which is enough to track the total but not enough to see per-request patterns like cache hit rate, system prompt share, or which specific workflow is driving the o1 spend. For teams routing OpenAI models through OpenRouter, the OpenRouter dashboard produces a clean, per-request CSV export with model, token counts, and cost per call. That export is the input TokenomicsIQ uses to run a full diagnostic across all nine cost buckets on your OpenAI-routed usage: which workflows are on the wrong model tier, what your actual cache hit rate is, and where system prompt bloat is adding cost to every call.