💬 AI Conversation Cost Calculator
A chat has no memory of its own. Every time you send a message the entire conversation so far is sent again, so the cost of turn twenty is twenty times the cost of turn one. This works out what a whole conversation actually costs, and what caching would save.
Why turn twenty costs twenty times turn one
A language model has no memory between calls. It does not remember your last message, your name or what you asked three minutes ago. The illusion of a conversation is created by resending the entire exchange with every new message — so by turn twenty you are paying to process nineteen previous turns all over again.
Input tokens on turn n = system prompt + all previous turns + this message
That makes the cost of a conversation grow with the square of its length, not in proportion to it. Doubling the number of turns roughly quadruples the bill. It is the single most common surprise on a first AI invoice, and it is invisible in any per-prompt calculator.
What that looks like in practice
| Turn | Input tokens that turn | Running total in |
|---|---|---|
| 1 | 650 | 650 |
| 5 | 2,850 | 8,750 |
| 10 | 5,600 | 31,250 |
| 20 | 11,100 | 117,500 |
| 40 | 22,100 | 455,000 |
Forty turns of a perfectly ordinary chat sends 455,000 input tokens — about the length of a long novel — for an exchange where the human typed roughly 6,000 tokens. On Sonnet 5.5 that is $0.91 of input against $0.03 for the words the user actually wrote.
Caching changes the arithmetic
Most providers now let you mark part of the prompt as cacheable. The first call pays a small premium to write the cache, typically 1.25 times the input rate; every subsequent call reads it at a fraction of the normal price — on some models as little as 2.5% of it. Since the resent history is exactly the part that repeats, this is where the saving lives.
The rule of thumb is that caching pays for itself from the second or third reuse, and from then on it is close to free. If you have a long system prompt and any repeated interaction at all, not caching is simply leaving money on the table. The pricing comparison lists the cache read rate for every model that publishes one.
Caching is not the only fix and often not the best one. Summarising old turns into a short running note, rather than resending them verbatim, cuts the tokens themselves rather than discounting them — and a shorter context usually produces better answers too, because the model is not sifting forty turns of irrelevance.
When to start a new conversation
Every message in the history is being paid for on every turn, so stale context is a recurring charge. If the subject has changed, starting fresh resets the cost to zero and usually improves the answer. The habit of keeping one enormous thread running for weeks is expensive in a way the interface never shows you.
The same applies to attachments. A 50,000-token document attached at turn one is resent at turns two through forty unless the tool is doing something cleverer, which is why document-heavy assistants are so much more expensive than their prompt length suggests.
A worked example
A coding assistant with a 2,000-token system prompt, 300-token questions and 800-token answers, run for 30 turns on Sonnet 5.5. Input across the conversation comes to 547,500 tokens and output to 24,000, so $1.10 plus $0.24 — $1.34 for one session. A hundred such sessions a month is $134. Cache the system prompt and history at the 0.05x rate and the input falls to around $0.06 a session, taking the monthly bill under $30. The work done is identical.
The natural follow-ups are the ai token calculator, for what this figure feeds into, and the llm pricing comparison, for the closely related case.
Frequently Asked Questions (FAQs)
Why does a chat get more expensive as it goes on?
Because the model has no memory, so the whole conversation is resent with every new message. Turn twenty pays to process nineteen earlier turns again, which makes the total cost grow with the square of the number of turns.
Does the model really re-read everything each time?
Yes. Each API call is independent and stateless. What looks like memory is the client resending the transcript, and you are billed for those input tokens every single time.
How much does caching save?
On a long, stable system prompt, most of the input bill. Cache reads cost between 2.5% and 10% of the normal input rate depending on the provider and model, and the cache write premium is recovered after two or three reuses.
Is it cheaper to start a new conversation?
Almost always, once the subject has changed. A fresh thread drops the accumulated history, which you are otherwise paying for on every remaining turn. It usually improves answer quality too.
What about attached documents?
They are part of the prompt and are resent every turn unless the tool manages context deliberately. A 50,000-token attachment in a twenty-turn chat can be a million input tokens on its own.
Does this apply to ChatGPT or Claude subscriptions?
The mechanism is identical, but with a flat monthly subscription you do not see the cost. It matters when you pay per token through an API, which is what this calculator models.
How do I reduce conversation cost without losing quality?
Cache the stable part, summarise old turns instead of resending them in full, trim attachments to the relevant sections, and start a new thread when the topic changes. Shorter context often improves answers as well as cost.