Free browser-based tool to count tokens and compare API costs across GPT-4o, Claude, Gemini, Grok, Llama 4, and DeepSeek — then compare gateways and local runners (OpenRouter, Together AI, Groq, Fireworks AI, LLM Gateway, Hugging Face, and Ollama) to decide where to run them. Paste any prompt and see results instantly. Runs entirely in your browser — nothing is uploaded or stored.
The table below shows current per-token pricing for the 13 most widely used AI models. Prices are per million tokens (MTok). Input tokens are what you send to the model; output tokens are what it sends back. Use the interactive calculator above to price your specific prompt.
| Model | Provider | Input / MTok | Output / MTok | Context window |
|---|---|---|---|---|
| GPT-4o | OpenAI | $2.50 | $10.00 | 128k tokens |
| GPT-4.1 | OpenAI | $2.00 | $8.00 | 1M tokens |
| GPT-4o mini | OpenAI | $0.15 | $0.60 | 128k tokens |
| o3 | OpenAI | $2.00 | $8.00 ⚠ | 200k tokens |
| o4-mini | OpenAI | $1.10 | $4.40 ⚠ | 200k tokens |
| Claude Sonnet 4.6 | Anthropic | $3.00 | $15.00 | 200k tokens |
| Claude Opus 4.8 | Anthropic | $5.00 | $25.00 | 200k tokens |
| Claude Haiku 4.5 | Anthropic | $1.00 | $5.00 | 200k tokens |
| Gemini 2.5 Pro | $1.25 | $10.00 | 1M tokens | |
| Gemini 2.5 Flash | $0.30 | $2.50 | 1M tokens | |
| Grok 4.3 | xAI | $1.25 | $2.50 | 1M tokens |
| Llama 4 Scout | Meta | $0.10 | $0.30 | 10M tokens |
| DeepSeek V3 | DeepSeek | $0.14 | $0.28 | 128k tokens |
⚠ o3 and o4-mini are reasoning models — internal chain-of-thought tokens are billed as output but not shown in the response. Actual cost is typically 2–5× higher than displayed.
Rather than calling OpenAI or Anthropic directly, many developers use a gateway — a single API that routes to multiple providers — or run models locally. The table below compares the main options.
| Platform | Type | Models | Pricing | Free tier | Best for |
|---|---|---|---|---|---|
| OpenRouter | Cloud gateway | 400+ | Base price + ~5% markup | Yes | Widest model catalogue; switch providers without code changes |
| Together AI | Cloud inference | 100+ | Own competitive pricing | Yes ($25 credit) | Open-source models (Llama, Mistral, Qwen) at scale |
| Groq | Cloud inference | 20+ | Low cost, own pricing | Yes | Lowest latency — real-time and voice applications |
| Fireworks AI | Cloud inference | 100+ | Own competitive pricing | Yes | Production agentic apps; strong structured output & function calling |
| LLM Gateway | Cloud gateway | 200+ | Base + 5% (BYOK = free) | No | BYOK savings, self-hosting, SOC 2 compliance |
| Hugging Face | Model hub | 1M+ | Serverless (pay-per-call) or dedicated endpoints | Yes | Fine-tuned or niche models not on commercial APIs |
| Ollama | Local & cloud | 200+ | Local: free; cloud: Free / $20 / $100 per month | Yes | Local privacy, offline work, or cloud access to large models |
Gateway pricing is indicative. Always confirm current rates on the provider's own site before making infrastructure decisions.
A token is the unit every major provider actually bills by — roughly 3-4 characters of English text, or about three-quarters of a word. Pricing is split into input tokens (what you send) and output tokens (what the model generates back), and output is almost always priced several times higher than input.
GPT-4o, GPT-4.1 and GPT-4o mini use OpenAI's real o200k_base tokenizer, loaded directly in your browser, so those counts are exact. Claude, Gemini, Grok, Llama and DeepSeek don't publish a free client-side tokenizer, so their counts are estimated from a characters-per-token ratio tuned per provider, typically within a few percent of the real count.
Each provider trains its own tokenizer on its own data, so identical text splits into a different number of tokens depending on the model. That's also why a prompt that comfortably fits one model's context window can fail in another's.
Generating text is more computationally expensive than reading it, so every provider prices output tokens higher than input, typically 3-5x.
The context window is the maximum number of tokens a model can hold in a single request — your prompt plus its reply. Go over it and the request fails outright or gets truncated, rather than just costing more.
Real chatbots resend the entire conversation history on every turn, so cost compounds as a conversation gets longer — a single per-run number badly understates this. Modeling this turn-by-turn and summing it gives a true cost-per-conversation figure, optionally accounting for prompt caching.
No. Tokenizing and cost calculation both run entirely in your browser using JavaScript — nothing you paste is uploaded, stored, or transmitted anywhere, including to us.
Direct providers (OpenAI, Anthropic, Google, etc.) host their own models and bill per token. Gateways like OpenRouter and LLM Gateway sit in front of multiple providers and give you one API key for all of them, adding a small markup (~5%). Inference providers like Groq and Together AI host open-source models on their own hardware at competitive prices. Local runners like Ollama let you run models on your own machine for free.
Pricing is entered manually from each provider's published rate card and reviewed periodically. Providers change prices without much notice, so confirm current rates on the provider's own site before relying on this for budgeting a production workload.
The calculator gives you a figure. These guides explain how LLM billing actually works — which assumptions are load-bearing, and what to change when the answer is too expensive.
Input tokens, output tokens, cached reads, reasoning tokens and batch discounts — every line item on an LLM API bill, and which ones actually move the total.
Byte-pair encoding, vocabulary size, and why the same paragraph is a different number of tokens on GPT-4o and Claude. What drives token count up, and how to write prompts that tokenize efficiently.
The prefill/decode split explained: why reading your prompt is cheap and parallel while generating a reply is expensive and sequential.
Chatbots resend the whole conversation on every turn, so cost scales with the square of the turn count. The maths, a worked example, and five ways to flatten the curve.
What gets cached, the discounts and expiry times at each provider, why cache writes can cost more than a normal call, and how to structure prompts so caches actually hit.
What happens when you exceed the limit, why retrieval accuracy degrades long before you reach it, and how to decide how much context to actually send.
Reasoning models generate hidden chain-of-thought tokens that you pay for as output but never see. How to estimate and control the invisible half of the bill.
OpenRouter, Together AI, Groq, Fireworks and LLM Gateway compared against going direct — on price, latency, reliability and operational overhead.
GPU rental rates, VRAM requirements, quantisation trade-offs and utilisation maths — a framework for deciding whether self-hosting is actually cheaper.