Enter your tokens and volume — all models appear side by side with per-request, daily and monthly cost. Prices editable.
| {{ __t('model') }} | {{ __t('th_in') }} $/Mtok |
{{ __t('th_out') }} $/Mtok |
{{ __t('th_cache_read') }} $/Mtok |
{{ __t('th_per_request') }} $ |
{{ __t('th_per_day') }} $ |
{{ __t('th_per_month') }} $ |
|---|---|---|---|---|---|---|
| {{ m.name }} {{ m.vendor }} |
{{ calcRequest(m).toFixed(5) }} | {{ calcDay(m).toFixed(2) }} | {{ calcMonth(m).toFixed(2) }} |
Providers bill per million tokens (Mtok) — separately for input (prompt + system + context) and output (model reply). Many add a caching tier: stable context can be cached and read again at a fraction of the input price. With many requests sharing the same system prompt this slashes the bill — typically 50–90% off the input portion.
Classification, summarization, simple extraction: small models (Haiku, GPT-4o mini, Gemini Flash, DeepSeek) are often 20–100× cheaper than top tier and cover 80% of workloads. Reasoning, code and multi-hop tasks benefit from Opus, GPT-4o, Gemini Pro. Tip: build a router that sends easy tasks to cheap models and hard ones to top tier — typical 40–70% savings.
An LLM API bill has more components than most teams expect at first. The obvious ones are input tokens (everything you send: system prompt, history, user message, tool definitions) and output tokens (what the model generates). The not-so-obvious ones are cache-read tokens (5-10x cheaper than input at Anthropic and OpenAI), cache-write tokens (Anthropic: 25% more expensive than input for the first write, then free on each hit for 5 minutes), and for vision models image tokens (e.g. ~765-1100 tokens per 1024x1024 image in GPT-4o depending on detail).
As of mid-2026 the price spread between the largest and smallest models is about 100x. Claude Opus 4.7 costs 15 USD / 75 USD per million tokens (input/output). Claude Haiku 4.5 lands at 1 USD / 5 USD. GPT-4o-mini at 0.15 USD / 0.60 USD. Gemini 2.0 Flash at 0.075 USD / 0.30 USD. DeepSeek V3 at 0.27 USD / 1.10 USD. Translation: a workload that costs 1,000 USD/month on Opus runs for about 67 USD on Haiku 4.5, about 5 USD on Gemini Flash. The right question is not "which model has the lowest token price" but "which model is just barely big enough for the concrete task".
Also note the output asymmetry: at almost every provider an output token costs 3-5x as much as an input token. Shortening responses from "explain in detail" to "answer in 50 words" often saves more than shrinking the prompt. In this tool's default (5,000 input, 1,000 output) input drives latency but often only 40-50% of cost — the rest comes from output, despite being one fifth of the tokens.
The per-request calculation — including cache hit rate — is:
cached_in = input_tokens * (cache_hit_rate / 100)
fresh_in = input_tokens - cached_in
cost_request = (fresh_in * price_in +
cached_in * price_cache +
out_tokens * price_out) / 1_000_000
cost_day = cost_request * requests_per_day
cost_month = cost_day * 30
// Example: Claude Sonnet 4.6 (3.00 / 15.00 / 0.30 USD per Mtok),
// 5000 input, 1000 output, 0% cache, 1000 requests/day
// fresh_in = 5000
// cost_req = (5000 * 3 + 0 * 0.3 + 1000 * 15) / 1_000_000 = 0.030 USD
// cost_day = 30 USD
// cost_month = 900 USD
// Same load with 80% cache:
// fresh_in = 1000
// cost_req = (1000 * 3 + 4000 * 0.3 + 1000 * 15) / 1_000_000 = 0.0192 USD
// cost_month = 576 USD --> 36% savingsFive concrete workloads and their monthly cost — based on the tool's default prices. The numbers help build intuition for what an idea actually costs:
The calculation is a linear model and ignores several real-world effects. (1) Prices change. The defaults are mid-2026 — Anthropic, OpenAI and Google cut prices every 6-12 months (sometimes 50%+), while new flagship models arrive at higher tiers. Always check the official pricing pages before production. (2) Cache-write cost is not modeled here. Anthropic charges 1.25x input price for the first cache write (standard) or 2x (1h TTL). At very low cache hit rates caching can briefly be more expensive. (3) Image, audio, video tokens are billed separately. GPT-4o: ~765-1100 tokens per 1024x1024 image, Claude Sonnet: ~1,500 tokens. (4) Tool-use overhead: each tool definition consumes between 50 and several hundred tokens per request. (5) Latency cost (=slower responses with larger models) is not included — but can be UX-relevant and indirectly cost conversion. Treat this calculator as an order-of-magnitude estimator, not a billing tool.
max_tokens=200 instead of max_tokens=1000 can halve the bill.