The per-token price is the sticker. Your bill is the history. A real conversation re-sends its entire transcript on every turn, so you pay input rates on the same text again and again - by turn 20 a single request carries about 17x the tokens turn 1 did. Below: every current GPT price, what a 20-turn chat really costs, and how PromptCrunch cuts that input bill by up to 75% - cache-safe, no quality loss.
All prices are per million tokens. "Cached input" is the discounted rate OpenAI charges when a repeated prompt prefix is served from its cache. But the sticker rate is only half the story - what you actually pay depends on how many tokens a real conversation drags along, and that number climbs fast. The next section makes it concrete.
| 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.
A number in the table won't tell you what a conversation costs. The API has no memory - every request ships the entire history back, and you pay the input rate on all of it, every single turn. Here is what that adds up to.
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 number isn't driven by the headline rate. It's driven by history you re-send on every turn - the model re-reading a transcript it already read. Trim the history and the bill drops with it. That's exactly what PromptCrunch does, and the rest of this page shows the levers.
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%.
Two things keep that from being the whole answer. First, the discount needs the prefix to repeat exactly - edit an earlier message, branch the thread, or change the system prompt and the match breaks from that point on, so check your real hit rate against OpenAI's documentation before you budget on it. Second, even when caching lands perfectly, the history keeps growing every turn, so you're still paying - cached rates now - for an ever-longer prompt. Caching makes each re-sent token cheaper. It doesn't stop you from re-sending them. Shrinking the history itself is a different job, one that stacks on top of caching rather than competing with it.
The bill grows because the history grows. Three levers push back on that, and they stack - so you rarely have to pick just one.
1. Shrink the history before it's sent. The one lever aimed straight at the growing prompt: instead of re-paying for the whole conversation every turn, you ship a fraction of the tokens. On long prose chats that's up to 75% off your input - output untouched, responses identical. That's PromptCrunch's whole job; the proof is just below.
2. Prompt caching. Built in, no write premium on OpenAI's published pricing, and the best-case numbers above are real when your prefix stays put: big system prompts, agent loops with fixed tool definitions, linear threads inside the cache window. It makes re-reads cheap but never shrinks the history. Run both: caching keeps the stable prefix cheap, compression takes on the part that keeps growing.
3. A smaller model. The same 20-turn conversation runs about $0.68 on GPT-5.4, $0.20 on GPT-5.4 mini, and $0.05 on GPT-5.4 nano - real money if the smaller model holds up on your task. It's a quality bet, not a free lunch: test it on live traffic first, and remember it does nothing about the history problem, which follows you down to every model.
PromptCrunch is a proxy that compresses old conversation history before forwarding your calls to OpenAI or Anthropic. On long prose conversations - support, tutoring, coaching, companion chat - past roughly 20 turns, it cuts input tokens by up to 75%. On a 40-prompt benchmark the input bill dropped from $2.56 to $0.64 for word-for-word identical responses. Recent turns, code, JSON, schemas, IDs, and numbers pass through verbatim, so nothing you rely on gets rewritten.
It's cache-safe by design: any request already using provider prompt caching passes through untouched, so PromptCrunch is never worse than sending direct - it just crushes the bill on everything caching can't reach. Flat pricing, too: Pro is $29/mo whether you crunch a thousand conversations or a million.
Two lines of setup on any SDK with a configurable base URL. Run your own traffic through the savings estimator to see the number for your workload, then start free - $5 credit, 100 requests a day, no card.
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.