llm-prices.com

Open llm-prices.com and use the Model prices (per million tokens) table to compare models side by side. Each row shows three cost columns — input, cached input, and output — so you can rank models on the dimension that matches your workload. Use the selection controls to narrow the table to the models you actually care about, then read the Compare Prices view, which also shows a last updated timestamp so you know how fresh the numbers are.

What the comparison table gives you

The table is the core of the site. Its columns are:

Prices are expressed per million tokens, which is the standard unit for normalizing API costs across providers.

Step-by-step: comparing models

1. Open the calculator at llm-prices.com. The page loads with the model price table and the cost calculator fields.
2. Narrow the table. Use the selection controls to pick the models you want to compare. The page offers Show just selected to display only your chosen models, and Clear selection to reset.
3. Read across the three cost columns. For each model, note input, cached input, and output prices. These are the numbers you compare — not a single blended figure.
4. Rank by your dominant cost driver. If your workload is prompt-heavy (long documents, RAG context), input and cached input dominate. If it generates long answers, output dominates.
5. Check the last updated time. The Compare Prices table shows when prices were last refreshed. If it looks stale, verify against the provider's own pricing page before committing.

Estimating your own cost, not just the per-token price

Per-million-token prices are unit prices, not your bill. To get an estimate:

1. In the calculator, enter number of input tokens, number of cached input tokens, and number of output tokens for a representative request.
2. Enter the cost per million figures for input, cached input, and output.
3. Read the Total cost output.

Multiply that per-request total by your expected request volume to project monthly spend.

The catch: token-based comparisons aren't exact

The site itself notes that different models use different tokenizers, so direct token-based price comparisons may not be entirely accurate. The same text can produce different token counts across models, which means a cheaper per-million price doesn't always mean a cheaper real-world bill. Treat the table as a strong first filter, then sanity-check with token counts from the actual tokenizer of each model you're considering.

Practical comparison checklist

• Compare all three columns, not just output price.
• Weight the columns by your real input/output ratio.
• Use the Show just selected filter to keep the comparison readable.
• Confirm the last updated date before relying on a number.
• Re-check tokenizer differences if two models are close in price.

LLM pricing splits a single request into three separately billed token categories: input tokens (the prompt you send), cached input tokens (prompt content the provider reuses instead of reprocessing), and output tokens (the completion the model generates). Each category carries its own price per million tokens, and output is almost always the most expensive. The LLM pricing calculator on llm-prices.com exposes exactly these three fields, so you can price a request by entering a token count for each and reading the total.

The three token categories

Input tokens (prompt tokens)

These are the tokens in everything you send to the model — system instructions, conversation history, retrieved documents, and the user's message. You pay for them once per request, at the model's input rate. In the calculator this is the "Number of input tokens (aka prompt tokens)" field, priced by "Cost per million input tokens ($)".

Cached input tokens

When part of your prompt repeats across requests (a long system prompt, a fixed document, a shared prefix), providers can store that processed content and reuse it. Those reused tokens are billed at a lower rate than fresh input. The calculator gives them their own field — "Number of cached input tokens" — and their own rate, "Cost per million cached input tokens ($)". Caching only helps if the same prefix actually recurs; a one-off prompt has nothing to cache.

Output tokens (completion tokens)

These are the tokens the model generates in response. They are typically priced higher than input, because generation is the more expensive operation. In the calculator they map to "Number of output tokens (aka completion tokens)" and "Cost per million output tokens ($)".

Why the split matters

A request's total cost is the sum of three separate multiplications, not one flat rate:

total = (input_tokens      / 1,000,000 × input_price)
      + (cached_tokens     / 1,000,000 × cached_price)
      + (output_tokens     / 1,000,000 × output_price)

Two consequences follow:

• A long prompt and a long answer are not priced the same. If output costs several times input, trimming the completion saves more than trimming the prompt.
• Caching changes the math on repeated prompts. The same system prompt sent a thousand times costs less per call once it is cached, because the cached portion is billed at the reduced rate.

A concrete example

Suppose a model charges $3 per million input tokens, $0.30 per million cached input tokens, and $15 per million output tokens. A request with 2,000 input tokens, 1,500 of them cached, and 500 output tokens costs:

• Input: 500 fresh tokens × $3/M = $0.0015
• Cached: 1,500 tokens × $0.30/M = $0.00045
• Output: 500 tokens × $15/M = $0.0075
• Total ≈ $0.00945

Note that the 500 output tokens cost more than all 2,000 input tokens combined — the typical pattern when output is priced highest.

One caveat the calculator itself flags

The tool notes that different models use different tokenizers, so direct token-based price comparisons across models "may not be entirely accurate." The same text can produce different token counts on different models, which shifts the real cost even when the per-million rates look comparable. Treat the calculator's output as a consistent estimate for one model, not a precise cross-model ranking.

How to use this in the calculator

1. Enter the number of input tokens for your prompt.
2. Enter how many of those are cached (0 if nothing repeats).
3. Enter the expected number of output tokens.
4. Fill in the three per-million prices for your model.
5. Read the Total cost.

The "Model prices (per million tokens)" table below the calculator lists input, cached, and output rates per model, and you can filter it with "Show just selected" or reset it with "Clear selection" to compare candidates on the same three dimensions.

To estimate the cost of one LLM API call on llm-prices.com, enter four numbers: input (prompt) tokens, cached input tokens, output (completion) tokens, and the per-million-token prices for each of those three categories. The calculator multiplies each token count by its matching price and shows a single total cost. This works for any model as long as you have its per-million-token rates; you do not need an account to use the page.

What the calculator asks for

The page is built around one section, Model prices (per million tokens), plus an input area with these fields:

• Number of input tokens (also called prompt tokens)
• Number of cached input tokens
• Number of output tokens (also called completion tokens)
• Cost per million input tokens ($)
• Cost per million cached input tokens ($)
• Cost per million output tokens ($)
• Total cost (the result)

The three token fields describe one call. The three price fields describe the model's rates. The total cost is what you read at the end.

Step-by-step: estimating one call

1. Get your token counts. For a single request, count the tokens in your prompt (input), the tokens in the model's reply (output), and any prompt tokens served from cache (cached input). If you don't have exact counts, use your provider's tokenizer or a rough estimate, then treat the result as approximate.
2. Enter the input token count in the Number of input tokens field. This is the full prompt size, including any cached portion if your provider counts it that way — check how your provider splits cached vs. uncached input.
3. Enter the cached input tokens in the Number of cached input tokens field. Leave it at zero if nothing was cached.
4. Enter the output token count in the Number of output tokens field.
5. Fill in the three prices from the model's pricing page: cost per million input tokens, cost per million cached input tokens, and cost per million output tokens. Enter them as dollars per million tokens, matching the label on each field.
6. Read the Total cost. That figure is the estimated cost of the call at those rates.

The page also lists Model prices (per million tokens) with columns for input cost, cached cost, and output cost, and a Compare Prices view, so you can look up rates instead of typing them from memory. A Show just selected / Clear selection control lets you narrow the model list, and a View source on GitHub link is provided.

A worked example

Suppose one call uses 2,000 input tokens, 1,500 of which are cached, and 500 output tokens. The model's rates are $3 per million input, $0.30 per million cached input, and $15 per million output.

• Uncached input: 2,000 − 1,500 = 500 tokens → 500 × $3 / 1,000,000 = $0.0015
• Cached input: 1,500 × $0.30 / 1,000,000 = $0.00045
• Output: 500 × $15 / 1,000,000 = $0.0075
• Total ≈ $0.00945

Entering the same numbers into the calculator should return that total. If your provider bills cached tokens differently (for example, charging the full input rate and applying a discount separately), adjust the split so the fields match how the bill is actually computed.

Common snags

• Tokenizer differences. The page itself notes that different models use different tokenizers, so direct token-based price comparisons may not be entirely accurate. A token count from one model won't map exactly onto another.
• Cached vs. uncached input. Decide up front whether your input field already includes the cached tokens. Double-counting or omitting them is the most common source of a wrong total.
• Per-million units. All three price fields are dollars per million tokens. Entering a per-thousand rate will inflate the result by 1,000×.
• One call vs. many. The total reflects a single call's token counts. For a workload, multiply by the number of calls, or sum token counts across calls and enter the total.
• Rates change. The model price list shows a last updated timestamp; confirm current rates before relying on a comparison.

llm-prices.com is a free web-based calculator for estimating the cost of an LLM API call. You enter token counts and per-million-token prices, and it returns a total cost. It also includes a comparison table of model prices per million tokens. It is a third-party tool with source code on GitHub, not an official pricing page from any model provider — so treat its numbers as a starting estimate and confirm against the provider's own pricing before you commit to a budget.

How the calculator works

The tool is built around one simple cost model: tokens × price per million tokens. You provide three inputs and three matching prices.

Inputs (token counts):

• Number of input tokens (also called prompt tokens)
• Number of cached input tokens
• Number of output tokens (also called completion tokens)

Prices (per million tokens, in dollars):

• Cost per million input tokens
• Cost per million cached input tokens
• Cost per million output tokens

Output:

• Total cost for the call, combining all three components

The formula the tool implies is:

total = (input_tokens        / 1,000,000) * input_price
      + (cached_input_tokens / 1,000,000) * cached_price
      + (output_tokens       / 1,000,000) * output_price

Cached input is billed separately because providers typically charge less for tokens that hit a prompt cache. If your workload doesn't use caching, set the cached token count to zero.

The model price table

Below the calculator, the page shows a Model prices (per million tokens) table with columns for:

• Model
• Input cost
• Cached cost
• Output cost
• A Compare Prices action

You can filter the table with Show just selected or reset it with Clear selection, so you can line up only the models you actually care about. The table carries a "last updated" timestamp, which tells you how fresh the listed prices are.

When to use it

Use llm-prices.com when you want a quick, provider-agnostic estimate:

• Sizing a feature before you build it. Plug in your expected prompt and completion lengths to see whether a task is cheap or expensive at scale.
• Comparing two or three models. Select them in the table and compare input/output costs side by side.
• Checking the effect of caching. Run the same token counts with and without cached input to see how much caching could save.

Skip it when you need a binding number. It is a calculator, not a quote.

Limitations to keep in mind

• Tokenizer differences. The page itself notes that different models use different tokenizers, so direct token-based price comparisons may not be entirely accurate. The same text can produce different token counts across models.
• Prices change. The table has a "last updated" timestamp; if it's stale, the per-million-token figures may no longer match what providers charge.
• It's third-party. The source is on GitHub, and the page links to it. That's useful for verifying the math, but it also means the tool is maintained independently of any provider.
• No account or billing features. It estimates cost; it doesn't connect to your API account or track real usage.

Practical workflow

1. Estimate your token counts — from a tokenizer, your logs, or a rough words-to-tokens rule of thumb.
2. Enter the three token counts and the three per-million prices for your target model.
3. Read the total cost.
4. Repeat with a second model's prices to compare.
5. Confirm the final numbers against the provider's official pricing page before budgeting.

Token-based price comparisons are a useful starting point, but they are not a reliable way to rank models by real cost. The LLM pricing calculator at llm-prices.com states this directly: "Different models use different tokenizers, so direct token-based price comparisons may not be entirely accurate." The core reason is that a per-million-token price only tells you the rate — it does not tell you how many tokens your specific text will consume under each model's tokenizer.

The tokenizer problem

A tokenizer splits text into tokens, and different models use different tokenizers. The same sentence can produce different token counts depending on which model processes it.

For example, a block of English prose, code, or non-Latin script may tokenize more efficiently in one model than another. If Model A charges less per million tokens but needs more tokens to represent your input, the cheaper-looking rate can produce a higher actual bill.

This means a price table sorted by cost per million tokens is comparing rates, not outcomes. The calculator's own note flags this limitation rather than hiding it.

Why per-token prices miss the real cost of a task

Even setting tokenizers aside, per-token pricing does not capture what a task actually costs:

• Input vs. cached input vs. output are priced differently. A workload heavy on output tokens behaves very differently from one heavy on cached input.
• Token counts vary with the content. The same instruction in different languages, formats, or lengths will not consume the same number of tokens.
• Retries and multi-step calls add up. A task that takes several calls costs more than a single-call estimate suggests.
• Caching changes the math. Cached input tokens are typically cheaper, so how much of your prompt is cacheable matters as much as the base rate.

What the calculator is actually good for

The llm-prices.com calculator is built around three inputs — input tokens, cached input tokens, and output tokens — plus the per-million rates for each. It returns a total cost. That makes it a solid tool for:

• Estimating the cost of a specific, known workload once you have token counts.
• Comparing models on the same token assumptions, which isolates the rate difference.
• Checking how caching shifts the total for a given prompt pattern.

It is not a tool for declaring one model "cheaper" in general, because the token counts themselves are model-dependent.

How to compare more reliably

1. Measure tokens per model, not per text. Run your actual prompt through each model's tokenizer (or its token-counting endpoint) to get real counts.
2. Feed those counts into the calculator separately. Use each model's own input, cached input, and output token numbers rather than one shared estimate.
3. Model the full task. Include expected output length, retries, and how much input can be cached.
4. Compare totals, not rates. The number that matters is the total cost for your workload, not the headline price per million tokens.

The takeaway

Per-token prices are a rate, and rates only become costs once you know the token counts. Because tokenizers differ across models, the same text can cost different amounts even at identical per-token prices. Use the calculator to turn token counts into totals for a defined workload, and treat any ranking based purely on price-per-million-tokens as an approximation rather than a verdict.