CalcPulse

AI cost

What your LLM feature actually costs per month

A token bill is three multiplications and one habit. The habit is estimating from a demo instead of from production traffic. This guide sets out the multiplication, then hands you the calculator to run your own numbers through.

Reviewed 2026-11-17 · 7 min read · calculator runs in your browser

The number that matters is cost per resolved request

API spend on its own is not a useful figure. A $400 monthly bill is cheap if it replaces four thousand support tickets and expensive if it powers a novelty chat box nobody returns to. What you want to know is what one finished request costs, and then how many finished requests a month buys.

So the calculator below returns the monthly bill, the cost of a single request, and the cost per thousand requests. If the per-request figure looks fine and the monthly one does not, your problem is volume or retries. If the per-request figure is already high, your problem is the prompt.

Five inputs, in the order they move the answer

  1. Output tokens. Output is usually priced several times higher than input. A verbose answer costs more than a long document you paste in.
  2. Input tokens per request. This is where a system prompt, retrieved documents and chat history pile up, and it grows quietly as history accumulates.
  3. Requests per day. Straight-line volume, and the one number a marketing push changes overnight.
  4. Retry and failure rate. Every timeout you re-send is billed twice.
  5. Cache hit rate. The only input that reliably lowers the bill without changing behaviour.

LLM API cost calculator

Enter the rates from your provider’s current price page. Defaults are placeholders, not a price list.

Cache fields are ignored when the hit rate is 0, so you can leave them alone.

Monthly bill

$0.00

$0.00 per year

Per request

$0.0000

0 billed calls

Per 1,000 requests

$0.00

at 2× volume: $0.00

Cost breakdown by line item
LineMonthShare
Input, fresh$0.00—
Input, cached$0.00—
Output$0.00—
Retries$0.00—

Rounded to the cent. The calculator does not store or transmit anything; reload the page and it resets.

A worked example, so you can sanity-check the output

Suppose a support assistant receives the traffic below. Nothing here is unusual for an internal tool in its second month.

  • Input tokens per request: 1,200
  • Output tokens per request: 400
  • Requests per day: 2,000
  • Retry overhead: 5%
  • Cache hit on input: 60%
  • Days per month: 30

Put those into the calculator with a fresh input rate of $0.15 per million tokens, a cached rate of $0.015 and an output rate of $0.60. The bill lands at $20.34 a month — $0.0003 per request — and about 71% of it is the output line even though output is only a quarter of the tokens. That ratio is the single most common surprise in the first invoice.

Multiply the per-request figure by the number of requests you expect after the tool is rolled out to every team, not the number you see in the pilot. A pilot with twelve users is not a sample of a company of six hundred; it is a sample of the twelve people who will complain loudest if it breaks.

Where estimates go wrong, in practice

1. Chat history grows the input line silently

A conversation that resends the last twenty turns pays for those turns again on every call. Token per request is not a constant; it is a function of how long the session runs. If your product has long sessions, estimate input tokens from the tenth turn, not the first.

2. Agent loops multiply the request count

A single user action that triggers a planning call, three tool calls and a summary is five billed requests, not one. Count model calls per user action before you multiply by users.

3. Structured output invites retries

If you parse JSON out of a free-form answer, some percentage of answers will not parse, and the retry is billed. Either constrain the output format at the API level or accept the retry cost knowingly; do not discover it on the invoice.

4. The tokens are the cheap part

At the rates above, a thousand requests cost less than a coffee. The expensive parts are the engineering time to build the thing, the evaluation set to trust it, and the human who handles what it gets wrong. Budget those separately or the API bill will look like a rounding error next to the payroll you added.

Three changes that lower the bill without lowering quality

  1. Cut the system prompt. Prompts accreted during development are usually 30–50% longer than they need to be, and every token of them is paid on every call.
  2. Cache what repeats. Policies, manuals and style guides are identical across requests. If your provider bills cached input at a discount, moving those blocks into the cached prefix is the highest-return change available.
  3. Route by difficulty. Most requests do not need the largest model. Send the easy half to a smaller one and measure whether anyone notices; the exceptions are usually detectable by length or by a confidence signal.

What this estimate leaves out

Embeddings and vector storage, image and audio pricing (billed per unit, not per token), egress from object storage, observability tooling, and the cost of a human reading the failures. If any of those are large for you, add them on top of the total rather than assuming the calculator covered them.

Questions this guide gets

Do I need the provider’s price list to use the calculator?
Yes, and that is deliberate. Token prices change and differ per model, region and contract, so the calculator takes the numbers you paste in rather than carrying a table that silently goes stale. The default values are only there to show the shape of the answer.
Why does the calculator ask for a retry rate?
Production traffic is not clean traffic. Timeouts, rate limits and malformed JSON all produce a second call that is billed like the first. A 5% retry rate on a small bill looks irrelevant; at scale it is a line item you can reduce by fixing validation instead of buying more quota.
How does prompt caching change the estimate?
A cached prefix is billed at a lower rate than fresh input tokens, and only on the cached portion. Enter the share of your input that repeats (a system prompt, a document, a policy file) and the cached rate your provider charges; the calculator splits the input line into fresh and cached before multiplying.
Should I budget on tokens per request or on total tokens per month?
Both, in that order. Token counts per request are what you control in the prompt; monthly totals are the consequence. Estimating from monthly totals hides whether the bill is driven by volume or by a bloated prompt, which are fixed in completely different ways.
What does the estimate leave out?
Non-token charges: per-image or per-minute audio pricing, storage and retrieval for embeddings, vector database hosting, egress, and the cost of the humans who review failures. The last one is usually larger than the API bill in the first six months.