The per-token rates are the easy part. The part that surprises people is that a multi-turn conversation re-sends its entire history on every call, so the bill grows quadratically with length. Here are the current prices, what a real conversation costs, and the honest ways to bring it down.
All prices are per million tokens. "Cached input" is what repeated prompt prefixes cost when served from OpenAI's cache. Your total OpenAI API cost is the sum of input, cached input, and output, multiplied by however many tokens a real conversation sends.
| Model | Input ($/1M) | Cached input ($/1M) | Output ($/1M) |
|---|---|---|---|
| GPT-5.6 Sol | $5.00 | $0.50 | $30.00 |
| GPT-5.6 Terra | $2.50 | $0.25 | $15.00 |
| GPT-5.6 Luna | $1.00 | $0.10 | $6.00 |
| GPT-5.5 | $5.00 | $0.50 | $30.00 |
| GPT-5.5 Pro | $30.00 | Not offered | $180.00 |
| GPT-5.4 | $2.50 | $0.25 | $15.00 |
| GPT-5.4 mini | $0.75 | $0.075 | $4.50 |
| GPT-5.4 nano | $0.20 | $0.02 | $1.25 |
| GPT-5.3 Codex | $1.75 | $0.175 | $14.00 |
Prices checked July 2026 against the official OpenAI pricing page and the individual model pages. OpenAI also documents batch processing at roughly half the standard rates (for example, GPT-5.6 Sol batch input at $2.50 versus $5.00). Prices change; always confirm on the provider page before budgeting.
The per-token price tells you almost nothing about your bill. The API is stateless, so every request re-sends the full history, and you pay input rates on all of it, every time.
Take a realistic support conversation on GPT-5.4 ($2.50 input / $15.00 output per million tokens). Assume an 800-token system prompt, 250-token user messages, and 650-token assistant replies. Each turn adds about 900 tokens of history that every later request re-sends.
| Turn | Input tokens sent | Input cost this call | Cumulative input cost |
|---|---|---|---|
| 1 | 1,050 | $0.003 | $0.003 |
| 5 | 4,650 | $0.012 | $0.036 |
| 10 | 9,150 | $0.023 | $0.128 |
| 15 | 13,650 | $0.034 | $0.276 |
| 20 | 18,150 | $0.045 | $0.480 |
Totals for the 20-turn conversation:
Input: ~192,000 tokens sent cumulatively, $0.48
Output: ~13,000 tokens generated, $0.20
Total: about $0.68 per conversation
Only ~5,800 of those 192,000 input tokens were new content. About 97% of the input spend was re-sent history.
By turn 20 you are sending an ~18,000-token history to ask a 250-token question. Scale that: at 1,000 such conversations per day, you are looking at roughly $680/day, or about $20,000/month, most of it spent re-processing text the model has already seen.
That quadratic growth, not the headline per-token rate, is what determines your bill for any conversational product. The rest of this page is about attacking it.
OpenAI's answer to the re-sent-history problem is prompt caching, billed through the "cached input" rate in the table above.
When a prompt prefix repeats and is served from OpenAI's cache, those tokens bill at the cached input rate: 0.1x the standard input price across the current lineup (GPT-5.5 Pro is the exception; it offers no cached discount). OpenAI's pricing pages list no separate cache write charge, which makes the economics simpler than Anthropic's explicit write-premium model.
Best case, applied to the conversation above: if the entire repeated history is served from cache on every turn, only the ~5,800 tokens of genuinely new content bill at $2.50, and the ~186,000 re-sent tokens bill at $0.25. The input side drops from about $0.48 to roughly $0.06, a cut of nearly 90%.
That is a best case. The discount depends on the prefix repeating exactly: editing an earlier message, branching the conversation, or changing the system prompt breaks the match from that point on, and cache retention has its own rules. See OpenAI's documentation for the exact trigger conditions, and measure your real cache hit rate before budgeting on the discounted number. Either way, note what caching does not do: the history still grows every turn, so you pay (cached rates) for an ever-longer prompt. We wrote up the general trade-off in compression vs caching.
Three levers, in the order we would honestly recommend trying them.
1. Prompt caching. It is built in, has no write premium on OpenAI's published pricing, and the best-case math above is real. It works best when your prompt prefix is stable: big system prompts, agent loops with fixed tool definitions, linear conversations. Its limits: exact prefix matching, cache retention rules, and the fact that the history still grows.
2. A smaller model. The same 20-turn conversation costs about $0.68 on GPT-5.4, $0.20 on GPT-5.4 mini, and $0.05 on GPT-5.4 nano. That is a 10x range for a one-line model change, if the smaller model's quality holds for your task. Test on real traffic before assuming it will not. Batch processing (roughly half price, asynchronous) stacks on top of this for non-interactive workloads.
3. Compress the history before sending it. This is what PromptCrunch does, so read this part with that in mind.
PromptCrunch is a proxy that shrinks old conversation history before forwarding to OpenAI or Anthropic. On long prose conversations (support, tutoring, coaching, companion chat) past roughly 20 turns, our own benchmarks show 60-75% fewer input tokens. Recent turns and structured content pass through verbatim.
The caveats matter. Coding-agent traffic saves almost nothing (0-7% measured), because code and tool output are preserved verbatim. And requests that already use provider caching pass through untouched: we never break a cache to force savings, which also means we cannot add savings on top of a well-cached workload. If caching already covers you, skip us.
If your workload is long prose conversations, run your own numbers in the savings estimator, or read how compression compares to caching before deciding.
OpenAI API cost is usage-based: you pay per token, billed separately for input and output, at the rates in the pricing table above. There's no flat GPT API cost or monthly minimum. What a real conversation costs you depends less on the sticker price than on how much history gets re-sent on every call, which is what the conversation math below walks through.
No permanent free tier. API usage is pay per token. OpenAI has at times issued small trial credits to new accounts, but do not budget around that; check the platform signup flow for current offers. ChatGPT's free plan is a separate consumer product and does not include API access.
Yes. The API is stateless: every request re-sends the full message history, and you pay the input rate on all of it every time. In the worked example above, turn 20 sends about 17x the tokens turn 1 does. This is the single most important thing to understand about conversational API costs.
Each model has a published cached input rate, 0.1x the standard input price across the current lineup (GPT-5.5 Pro offers no cached discount). Repeated prompt prefixes served from cache bill at that rate; OpenAI's pricing pages list no separate write charge. The discount depends on the prefix repeating exactly.
With an 800-token system prompt, 250-token user messages, and 650-token replies, about $0.68: $0.48 of input and $0.20 of output. About 97% of the input spend is re-sent history. Your numbers will differ with message sizes; the shape of the math will not.
On most current GPT models the output rate is about 6x input ($5.00/$30.00, $2.50/$15.00, $0.75/$4.50), and 8x on GPT-5.3 Codex. Generating tokens one at a time is more compute-intensive per token than ingesting a prompt. In practice, multi-turn bills are usually still dominated by input, because the growing history is re-billed as input on every call while each output token is only paid for once.
Prices checked July 2026; always confirm on the provider's official pricing page:
developers.openai.com/api/docs/pricing.
Comparing providers? See LLM API pricing across providers or
Claude API pricing.