Does the OpenAI or Claude API resend the whole chat history every message?

Yes. Both APIs are stateless: they keep no memory between requests, so your client resends the system prompt plus the entire prior transcript plus the new user message on every turn. OpenAI's conversation-state guide and Anthropic's Messages API docs both make this explicit — the full messages array is sent each request.

Why does a long ChatGPT API conversation get more expensive each turn?

Because the input grows every turn. Turn 1 sends the system prompt and one user message; turn 20 sends the system prompt plus 19 prior user/assistant pairs plus the new message. Since you pay per input token, each later turn is billed for a longer transcript than the one before it.

How do I calculate the total token cost of a chatbot conversation?

Total input tokens = T·(S+U) + (U+A)·T·(T−1)/2, where T is turns, S the system prompt tokens, U the average user tokens, and A the average reply tokens. Total output = T·A. Multiply each by the model's per-million input/output price and add them. This tool does it for you and shows the per-turn breakdown.

Does conversation cost grow linearly or quadratically with the number of turns?

The input-token cost grows quadratically. The history term (U+A)·T·(T−1)/2 is proportional to T², so doubling the number of turns roughly quadruples the input cost of the history. Output cost stays linear (T·A). That quadratic input term is why long threads surprise people on the invoice.

How much can prompt caching save on a long chat?

A lot on long threads, little on short ones. Providers bill the repeated transcript prefix at a reduced read rate (Anthropic ≈ 10% of the input price, OpenAI ≈ 50%) with a one-time write surcharge. The longer the conversation, the more the cheap reads dominate. Toggle caching on in the calculator to see an estimate for your inputs.

Do these prices include Sri Lankan taxes or LKR conversion?

No. API prices are billed in USD by OpenAI, Anthropic, and Google, so this tool shows USD only. For a rupee figure and card/remittance fees, take the USD total to the freelancer USD–LKR calculator. Import VAT/SSCL on digital services is a separate question handled by the SSCL and VAT tools.

Are the model prices on this page current?

Prices are a hand-verified snapshot last checked on 2026-07-11 against each provider's official pricing page. Vendors reprice often, so always confirm before quoting a client — and if a rate has changed, use the "Custom rates" option to enter the exact input/output prices you pay.

Why is my real bill even higher than this estimate?

Common reasons: real messages vary in length (this tool uses averages), tool/function-call definitions and retrieved documents add hidden input tokens, retries and streaming re-requests happen, and multimodal turns (images, audio) cost far more per item. Treat the figure here as a clean text-only baseline, not a ceiling.

Developers · AI cost

AI Conversation Cost Calculator

Estimate what a multi-turn LLM chat really costs. Because the API resends the whole conversation history on every turn, a long thread costs far more than reply-tokens × turns — this tool shows the actual figure, the per-turn climb, and how badly the naive guess undershoots.

By Induwara Ashinsana— Executive Director, Ryzera TechnologiesUpdated Jul 11, 2026

Conversation cost

Full-history model · verified

Model

OpenAI · $2.5 in / $10 out per 1M tokens.

Number of turns

turns

One user message + one assistant reply per turn.

System prompt tokens

Resent on every turn.

Avg. user tokens / turn

Average length of each user message.

Avg. reply tokens / turn

Average length of each assistant reply.

Think in words? Multiply words by ~1.33 to estimate tokens — or use the tokens ↔ words converter.

Turns

Total cost

$0.0825

Total input tokens

21,000

Grows quadratically with turns

Total output tokens

3,000

Linear: turns × reply size

vs naive estimate

2.2×

Actual ÷ first-guess cost

The gotcha

Naive guess

$0.0375

No history resent

Actual cost

$0.0825

Full history resent

Multiplier

2.20×

your first guess

At this rate, a 100-turn thread would cost $5.325 with these same per-turn sizes.

Cumulative cost curve

Running total across 10 turns — note how the slope steepens: each turn resends a longer transcript than the last.

Turn 1Turn 10 · $0.0825

Per-turn breakdown

Turn	Input tokens	Output tokens	Turn cost	Running total
1	300	300	$0.0037	$0.0037
2	700	300	$0.0048	$0.0085
3	1,100	300	$0.0058	$0.0142
4	1,500	300	$0.0067	$0.021
5	1,900	300	$0.0078	$0.0287
6	2,300	300	$0.0087	$0.0375
7	2,700	300	$0.0098	$0.0473
8	3,100	300	$0.0108	$0.058
9	3,500	300	$0.0118	$0.0697
10	3,900	300	$0.0128	$0.0825

Sources: pricing from OpenAI, Anthropic and Google. The stateless full-history mechanism is documented in the OpenAI conversation-state guide. Rates are a snapshot — override any model with custom rates above.

How it works

Chat APIs from OpenAI, Anthropic, and Google are stateless: the server keeps no memory of your conversation between requests. To give the model context, your client resends the system prompt, every prior user and assistant message, and the new user message on everyturn. You are billed for all of those input tokens each time. (See OpenAI's “Managing conversation state” guide and Anthropic's Messages API reference, both linked below.)

Let S be the system prompt tokens, U the average user-message tokens, A the average assistant-reply tokens, and T the number of turns. On turn i (counting from 1) the billed input is:

input(i) = S + U + (i − 1)·(U + A)

The (i − 1)·(U + A) term is the growing transcript — every earlier user/assistant pair, re-sent. Summing over all turns gives the totals:

Total input = T·(S + U) + (U + A)·T·(T − 1)/2
Total output = T · A
Cost (USD) = Total-input/1e6 · P_in + Total-output/1e6 · P_out

The input total has a quadratic term in T, which is why cost accelerates as a chat gets longer. To keep the math honest the tool computes this closed form and cross-checks it against a direct turn-by-turn summation — both must agree to the token before any result is shown.

The naive estimate most developers make ignores history: every turn is assumed to send only S + U input and A output, giving a cost that is only linear in T. The calculator prints the ratio of actual to naive so you can see the gap — often 2× on a short chat and 10×+ on a long one. Prices come from each provider's official pricing page and are a dated snapshot; the core math is rate-independent, so a custom rate override keeps the tool accurate even after a vendor reprices.

Worked examples

GPT-4o · short support chat (10 turns)

P_in $2.50/1M · P_out $10/1M · S=200, U=100, A=300

Total input = 10·(200+100) + (100+300)·10·9/2
= 3,000 + 400·45 = 3,000 + 18,000 = 21,000 tokens
Total output = 10·300 = 3,000 tokens
Cost = 21,000/1e6·2.50 + 3,000/1e6·10 = $0.0525 + $0.0300 = $0.0825
Naive = 10·300/1e6·2.50 + 3,000/1e6·10 = $0.0075 + $0.03 = $0.0375
→ Actual is 2.2× the naive guess.

Claude Sonnet 4 · long agent thread (30 turns)

P_in $3/1M · P_out $15/1M · S=500, U=150, A=400

Total input = 30·(500+150) + (150+400)·30·29/2
= 19,500 + 550·435 = 19,500 + 239,250 = 258,750 tokens
Total output = 30·400 = 12,000 tokens
Cost = 258,750/1e6·3 + 12,000/1e6·15 = $0.77625 + $0.18000 = $0.9563
Naive = 30·650/1e6·3 + 12,000/1e6·15 = $0.0585 + $0.18 = $0.2385
→ Actual is 4.0× the naive guess — the longer the thread, the wider the gap.

GPT-4o · runaway thread (edge case, 500 turns)

P_in $2.50/1M · P_out $10/1M · S=200, U=100, A=300

Total input = 500·300 + 400·500·499/2
= 150,000 + 49,900,000 = 50,050,000 tokens
Total output = 500·300 = 150,000 tokens
Cost = 50.05M/1e6·2.50 + 0.15M/1e6·10 = $125.125 + $1.50 = $126.625
Naive = 500·300/1e6·2.50 + 150,000/1e6·10 = $0.375 + $1.50 = $1.875
→ Actual is 67.5× the naive guess. This is why unbounded chat memory bankrupts a flat quote.

Frequently asked questions

Sources & references

Model prices were last cross-checked against these pages on 2026-07-11. The conversation math (quadratic input growth) is rate-independent and does not change when vendors reprice. If you spot a stale rate, use the custom-rate override in the calculator and email me so I can update the snapshot.

Related tools

LiveAI

AI Chatbot Cost Calculator

Estimate the monthly API cost of a multi-turn AI chatbot across Claude, GPT, and Gemini. Models the quadratic context re-sending that single-call calculators miss, with and without prompt caching, in USD and LKR.

Open tool

LiveAI

Sinhala/Tamil AI Cost

Measure the token tax: Sinhala and Tamil fragment into far more tokens than English, so LLM API calls cost more. Tokenize real text with the exact GPT-4o/GPT-5 tokenizer in your browser, see the per-word tax ratio versus English, and project a monthly OpenAI, Claude, Gemini or Llama bill in USD and LKR for an app serving Sri Lankan users — with a cheapest-model comparison. No signup, no upload, sources cited.

Open tool

LiveAI

AI API Cost Calculator

Estimate the monthly and per-request USD and LKR bill for any major LLM API. Pick a model, enter input/output tokens and requests per month, and compare every model cheapest-first — with optional 50% batch and cached-input discounts.

Open tool

Rate this tool

Be the first to rate

Comments & feedback

Spotted a bug or want an improvement? Tell us — our team reviews every comment, and good ideas get built. Comments are public and anonymous.

Found a bug, edge case, or want to suggest an improvement?

Email me at [email protected] — most fixes ship within 24 hours.