LLM API Cost Calculator

Instructions

1. Set your token counts — enter the input tokens, output tokens, and requests per month for the workload you're pricing. The table above re-sorts every model by cost as you type.
2. Count tokens from real text — paste a prompt, document, or system message into the token counter, then push the result into the calculator with "Use as input tokens" or "Use as output tokens".
3. Add cached input tokens — if you reuse a long system prompt on every call, enter how many of your input tokens are cache reads.

Everything runs in your browser. Nothing you paste is uploaded or stored.

How the cost math works

Cost per call is the sum of three lines, each priced per 1M tokens:

• uncached input tokens × the model's input rate
• cached input tokens × the model's cache-read rate
• output tokens × the model's output rate

Monthly cost is simply cost per call × requests per month.

Cached input tokens are treated as a subset of your input tokens, not an addition to them — enter 10,000 input and 8,000 cached, and you are billed for 2,000 tokens at the full input rate and 8,000 at the cache-read rate. If you enter more cached tokens than input tokens, the excess is ignored rather than double-counted.

The table sorts cheapest-first and tags the winner. The "× best price" column tells you what each model costs as a multiple of that cheapest option, which is usually the number that actually settles an argument — a model being "expensive" matters less than it being 40× the alternative that would have done the job.

Token counter

Paste text to count its tokens, then push the count into the calculator. Counts are exact for OpenAI models: the tool loads OpenAI's o200k_base tokenizer — the same BPE used by the GPT-4o/4.1/5 family — and runs it locally in your browser.

The tokenizer is a sizable download, so it loads only when you click into the text box. Until it finishes, the counter shows a rough character-based approximation labeled "quick estimate". Once loaded, the badge reads "exact" for OpenAI models and "estimate" for everyone else.

Per-provider calculators

Each provider has its own page with the same calculator scoped to just that provider's models:

• OpenAI
• Anthropic Claude
• Google Gemini
• xAI Grok
• DeepSeek
• Mistral AI
• Groq

Frequently asked questions

How accurate are the token counts?

Token counts are exact for OpenAI models — the o200k_base tokenizer runs locally in your browser. Other providers don't publish browser-ready tokenizers, so their counts are close estimates. The gap is not always small: newer Claude and Gemini models tokenize the same text into roughly 30% more tokens, which means a cost estimate for those models is optimistic by about the same margin. If you are choosing between a Claude model and an OpenAI model on price alone, weight that in.

Is my text sent anywhere?

No. Tokenizing and cost math run entirely in your browser. Nothing you paste is uploaded or stored.

How current is the pricing?

The rates the calculator uses were verified against each provider's official pricing page on the date shown above the table, and each provider's pricing page is linked there so you can check the current figure yourself. LLM API prices change often — confirm with the provider before committing a budget.

What about cached input and batch discounts?

The calculator applies a discounted cache-read rate for the providers that publish prompt-cache pricing. For providers that don't, cached tokens fall back to that model's normal input rate — so entering cached tokens for those models changes nothing, which is the honest answer rather than a phantom discount.

Batch APIs aren't applied automatically. Where a provider offers one, it is typically around 50% off, so halve the result if your workload runs through batch.

Which price should I actually plan against?

The per-call number is a poor guide on its own; the monthly column is where model choice shows up as real money. Two things routinely blow past the estimate: output tokens run longer than people expect, and retries are real requests. Price your workload with a realistic output length rather than a hoped-for one, and add headroom for the calls that fail and get retried.