We use cookies for analytics and personalized ads. We use cookies for basic analytics and, where we show ads, to personalize them. Privacy PolicyRead our Privacy Policy.
Enter one request size, then see every major model priced side by side — sorted from cheapest to most expensive, with a monthly forecast built in.
Count Tokens LocallyA token is the small chunk of text a model actually reads and generates — roughly 4 characters, or about 0.75 of an English word, though the exact split depends on the provider's own tokenizer. That rule of thumb means 1,000 words of plain English usually comes out to somewhere around 1,300-1,500 tokens, a bit more for technical writing, and noticeably more for code, JSON, or non-English text, since those tokenize less efficiently.
On its own, a single token costs a tiny fraction of a cent — providers price per million tokens, not per token, so the real question is what a request, or a month of requests, adds up to. A short message like "Hello, how are you?" is usually 6-7 tokens. A typical email runs 200-400 tokens. An article like this one runs 1,000-3,000 tokens. None of that is expensive on its own; it's multiplying by thousands or millions of calls that turns tokens into a real line item, which is exactly what the calculator below does for you.
Every provider counts slightly differently, so the same text can come out to a different token count on OpenAI's tokenizer versus Anthropic's or Google's. Treat any token count as a close estimate for planning, not an exact figure to bill against.
Enter a request pattern, or start from an example workload below.
Prices convert live in your chosen currency (approximate FX). Share copies a link that reopens this exact estimate for anyone you send it to.
Reasoning tokens (used by thinking models before the visible answer) are billed at each model's output rate. Token counts are estimates — every provider's tokenizer counts slightly differently, so treat these as close, not exact.
"Best value pick" compares capable, general-purpose models rather than the absolute cheapest lite tier — useful when quality matters as much as price.
Sorted lowest to highest for this request size. Cache writes, storage, Batch, Flex, Priority, tools, media charges, and Perplexity's per-request search fee aren't included.
| Model | Provider | Context | Input | Cache read | Output | Total | Per 1M requests |
|---|---|---|---|---|---|---|---|
| Gemini 2.5 Flash-Lite | 1,048K / 65K | $0.10 | $0.010 | $0.40 | $0.0003 | $0.0344 | |
| DeepSeek V4 Flash | DeepSeek | 1M / 384K | $0.22 | $0.007 | $0.66 | $0.0005 | $0.0664 |
| DeepSeek V4 Flash Vision (exp) | DeepSeek | 1M / 384K | $0.22 | $0.007 | $0.66 | $0.0005 | $0.0664 |
| GPT-5.6 Luna | OpenAI | 1,050K / 128K | $0.20 | $0.020 | $1.20 | $0.0007 | $0.0838 |
| GPT-5.4 Nano | OpenAI | 400K / 128K | $0.20 | $0.020 | $1.25 | $0.0007 | $0.0856 |
| Gemini 3.1 Flash-Lite | 1,048K / 65K | $0.25 | $0.025 | $1.50 | $0.0008 | $0.1047 | |
| Gemini 2.5 Flash | 1,048K / 65K | $0.30 | $0.030 | $2.50 | $0.0012 | $0.1519 | |
| Gemini 3.5 Flash-Lite | 1,048K / 65K | $0.30 | $0.030 | $2.50 | $0.0012 | $0.1519 | |
| DeepSeek V4 Pro | DeepSeek | 1M / 384K | $0.66 | $0.022 | $1.98 | $0.0016 | $0.1994 |
| Sonar | Perplexity | 127K | $1.00 | n/a | $1.00 | $0.0018 | $0.2250 |
| Grok Build 0.1 | xAI | 256K | $1.00 | $0.200 | $2.00 | $0.0022 | $0.2750 |
| Gemini 3.8 Flash | 1,048K / 65K | $0.75 | $0.075 | $3.75 | $0.0023 | $0.2859 | |
| Gemini 3.7 Flash | 1,048K / 65K | $0.75 | $0.075 | $3.75 | $0.0023 | $0.2859 | |
| Gemini 3.6 Flash | 1,048K / 65K | $0.75 | $0.075 | $3.75 | $0.0023 | $0.2859 | |
| GPT-5.4 Mini | OpenAI | 400K / 128K | $0.75 | $0.075 | $4.50 | $0.0025 | $0.3141 |
| Grok 4.3 | xAI | 1M | $1.25 | $0.200 | $2.50 | $0.0027 | $0.3406 |
| Claude Haiku 4.5 | Anthropic | 200K / 64K | $1.00 | $0.100 | $5.00 | $0.0031 | $0.3812 |
| Gemini 2.5 Pro | 1,048K / 65K | $1.25 | $0.125 | $10.00 | $0.0049 | $0.6172 | |
| Gemini 3.5 Flash | 1,048K / 65K | $1.50 | $0.150 | $9.00 | $0.0050 | $0.6281 | |
| Grok 4.7 | xAI | 500K | $2.00 | $0.500 | $6.00 | $0.0050 | $0.6312 |
| Sonar Reasoning Pro | Perplexity | 128K | $2.00 | n/a | $8.00 | $0.0054 | $0.6750 |
| Claude Sonnet 5 | Anthropic | 1M / 128K | $2.00 | $0.200 | $10.00 | $0.0061 | $0.7625 |
| GPT-5.6 Terra | OpenAI | 1,050K / 128K | $2.00 | $0.200 | $12.00 | $0.0067 | $0.8375 |
| Gemini 3.1 Pro Preview | 1,048K / 65K | $2.00 | $0.200 | $12.00 | $0.0067 | $0.8375 | |
| GPT-5.4 | OpenAI | 1,050K / 128K | $2.50 | $0.250 | $15.00 | $0.0084 | $1.05 |
| Sonar Pro | Perplexity | 200K | $3.00 | n/a | $15.00 | $0.0090 | $1.12 |
| Claude Sonnet 4.6 | Anthropic | 1M / 128K | $3.00 | $0.300 | $15.00 | $0.0092 | $1.14 |
| GPT-5.6 Sol | OpenAI | 1,050K / 128K | $4.00 | $0.400 | $20.00 | $0.0122 | $1.52 |
| Claude Opus 5 | Anthropic | 1M / 128K | $5.00 | $0.500 | $25.00 | $0.0152 | $1.91 |
| Claude Opus 4.8 | Anthropic | 1M / 128K | $5.00 | $0.500 | $25.00 | $0.0152 | $1.91 |
| GPT-5.5 | OpenAI | 1,050K / 128K | $5.00 | $0.500 | $30.00 | $0.0168 | $2.09 |
| Claude Fable 5.1 | Anthropic | 1M / 128K | $10.00 | $0.250 | $50.00 | $0.0301 | $3.77 |
| Claude Mythos 5.1 | Anthropic | 1M / 128K | $10.00 | $0.250 | $50.00 | $0.0301 | $3.77 |
| GPT-6 Astra | OpenAI | 1,050K / 128K | $10.00 | $1.000 | $50.00 | $0.0305 | $3.81 |
| Claude Fable 5 | Anthropic | 1M / 128K | $10.00 | $1.000 | $50.00 | $0.0305 | $3.81 |
| Claude Mythos 5 | Anthropic | 1M / 128K | $10.00 | $1.000 | $50.00 | $0.0305 | $3.81 |
| GPT-5.5 Pro | OpenAI | 1,050K / 128K | $30.00 | n/a | $180.00 | $0.0990 | $12.38 |
All providers — input, cache read, and output cost for this request size.
Three common shapes of request. Click the matching preset above the calculator to load these exact numbers and see live, current-rate pricing across every model.
A short user message plus conversation history as input, with a longer generated reply. Output tokens usually dominate this shape, and at high call volume the per-request price matters more than raw model capability.
A large input — existing files, a spec, a system prompt — with a comparatively short generated diff or function. Input-heavy workloads like this benefit the most from prompt caching if the surrounding code or instructions stay the same across calls.
A long document, transcript, or codebase as input with a short summary or extraction as output. This is where context-window size and long-context pricing tiers matter most — see the section below.
Every provider on this page publishes rates per million tokens, which is convenient for their invoicing but awkward when you're sizing a single request. The math underneath is the same everywhere: price each token type separately, then add the pieces together.
OpenAI publishes API prices per million tokens, which works fine for a monthly invoice but takes a small conversion to size one request. Take the listed rate, divide by 1,000,000, then multiply by your input and output counts separately — output is priced several times higher than input across the whole GPT-5.x lineup, so a short prompt with a long, unconstrained answer can end up costing more than a long prompt with a tight response.
If you're building a ChatGPT-style feature on the API rather than using the consumer app, remember that cost isn't just the visible user message. System instructions, few-shot examples, retrieved context, and the model's expected answer length all get counted — a chatbot that looks lightweight to the end user can still carry a large system prompt behind the scenes.
Claude workflows tend to involve long documents, long chat histories, or large reference material, which means the input side of the bill often dominates even when the generated answer is short. Prompt caching matters more here than on a short-prompt workload — a stable system prompt or document prefix reused across many calls can meaningfully cut the input portion of the bill.
Gemini estimates are easiest to reason about when you keep text input and expected output separate, exactly as this calculator does. The catch is multimodal input — images, audio, video, and long PDFs convert to tokens at their own rate, separate from plain text, so a text-only estimate like this one is a floor, not the full picture, once attachments are involved.
DeepSeek's rate card includes an off-peak discount — the numbers on this page use the lower off-peak rate, with peak-hour pricing running roughly double. For workloads that run around the clock rather than in a predictable window, budget closer to the peak rate so an unexpected traffic spike during peak hours doesn't blow past your estimate.
xAI's Grok models double their input, cache, and output rates once a single request passes 200K input tokens — a hard cliff rather than a gradual ramp, and it applies to the entire request, not just the tokens over the line. This calculator uses the standard (under 200K) rate; if you're routinely sending very long prompts, double-check your real cost against xAI's long-context tier.
Sonar's token rates above are only part of the bill — Perplexity also charges a per-1,000-request search fee that scales with how much web context a query retrieves (roughly $5-$14 per 1,000 requests depending on the model and search depth). That fee isn't included in this calculator's total, so treat the Sonar numbers here as a floor for low-volume use and check Perplexity's pricing page before estimating a production budget.
Several providers charge a higher rate once a single request crosses a size threshold — commonly somewhere past 128K-272K input tokens, depending on the model. This calculator uses each model's standard rate; if your real request is unusually large, check that model's official pricing page for whether a long-context tier applies before you commit to a number.
Thinking or reasoning models generate internal reasoning tokens before their visible answer, and most providers bill those at the output rate even though you never see them. A short visible reply from a reasoning model can still be expensive if it "thought" for a while first — the output field above is the number to increase if you want to model that.
Prompt caching has two sides: reading a cache hit is cheap — that's the "cache read" rate used above — but writing new content into the cache the first time is often billed at its own rate, sometimes split into a short-lived (around 5 minutes) and a longer-lived (around 1 hour) tier. This calculator doesn't include cache-write cost, since it depends on how often your cache expires and gets rewritten. Budget a small write cost on top of this estimate if your traffic pattern refreshes the cache frequently.
A single request is easy to price — an agent loop is not, because most agent frameworks re-send the growing conversation or tool-call history as input on every step. If each step adds roughly the same amount of new context, total input tokens across an N-step task grow faster than N itself, closer to N² than to a straight line.
In practice: a 10-step agent doesn't cost 10x a single call — it can easily cost 30-50x, because steps 8, 9, and 10 are each re-reading everything steps 1 through 7 already produced. Prompt caching helps a lot here, since the growing prefix is usually identical between consecutive steps, but only if your agent framework actually reuses the cache instead of rebuilding the prompt from scratch each time. If you're estimating an agent's monthly cost, model it step by step rather than multiplying one request's price by the number of steps.
Methodology: rates on this page are entered by hand from each provider's official, public pricing page (linked below) and refreshed on a regular pass — prices were last checked 2026-09-29. Model prices move over time, so use this page for planning, then confirm anything affecting production billing directly with the provider.