AI Token Cost Calculator
Estimate your GPT, Claude, and Gemini API costs before you spend a single dollar — paste your prompt, pick a model, and see the real price.
$5/1M input tokens · $30/1M output tokens · Context: 1,048,576 tokens
Used to project your monthly cost (assumes 30 days).
Input Cost
$0.0050
Output Cost
$0.0150
Total Cost / Request
$0.0200
Projected Monthly Cost
Based on your requests/day input
$60.00
Compare All Models
Cost for the same 1,000 input / 500 output tokens, cheapest first.
| Model | Provider | Input Cost | Output Cost | Total Cost | Context Window |
|---|---|---|---|---|---|
| Gemini 2.5 Flash-Lite (legacy)Cheapest | $0.0001 | $0.0002 | $0.0003 | 1,000,000 | |
| GPT-4o mini | OpenAI | $0.0002 | $0.0003 | $0.0005 | 128,000 |
| GPT-5.6 Luna | OpenAI | $0.0002 | $0.0006 | $0.0008 | 1,048,576 |
| Gemini 3.5 Flash-Lite | $0.0003 | $0.0013 | $0.0016 | 1,048,576 | |
| Claude Haiku (legacy) | Anthropic | $0.0008 | $0.0020 | $0.0028 | 200,000 |
| Claude Haiku 4.5 | Anthropic | $0.0010 | $0.0025 | $0.0035 | 200,000 |
| GPT-5.2 | OpenAI | $0.0009 | $0.0035 | $0.0044 | 400,000 |
| Gemini 3.6 Flash | $0.0015 | $0.0038 | $0.0052 | 1,048,576 | |
| Claude Sonnet 5 | Anthropic | $0.0020 | $0.0050 | $0.0070 | 1,000,000 |
| GPT-4o | OpenAI | $0.0025 | $0.0050 | $0.0075 | 128,000 |
| GPT-5.6 Terra | OpenAI | $0.0020 | $0.0060 | $0.0080 | 1,048,576 |
| Gemini 3.1 Pro | $0.0020 | $0.0060 | $0.0080 | 1,048,576 | |
| Claude Sonnet (legacy 4.6) | Anthropic | $0.0030 | $0.0075 | $0.0105 | 200,000 |
| Claude Opus 5 | Anthropic | $0.0050 | $0.0125 | $0.0175 | 1,000,000 |
| GPT-5.6 Sol | OpenAI | $0.0050 | $0.0150 | $0.0200 | 1,048,576 |
| Claude Fable 5 | Anthropic | $0.0100 | $0.0250 | $0.0350 | 1,000,000 |
| Claude Opus (legacy) | Anthropic | $0.0150 | $0.0375 | $0.0525 | 200,000 |
AI APIs are billed by token, not by request or by word, which makes real costs easy to underestimate — especially once output length, system prompts, and daily request volume are factored in. This AI token cost calculator estimates what a given prompt will actually cost across the major providers, so you can compare GPT, Claude, and Gemini pricing side by side and catch an expensive model choice before it shows up on your bill.
How the estimate is calculated
We count tokens the way providers bill them
Your text is split using each model's own tokenizer, not a word-count guess. That's the same unit OpenAI, Anthropic, and Google use to generate your invoice, so the number you see here is the number that shows up on your bill.
Input and output are priced separately
Every major provider charges more for what the model generates than for what you send it — often 3 to 5 times more. We apply each model's current published input and output rate to your exact token counts, not a blended average.
You get a real monthly number
Add your expected requests per day and the calculator projects a monthly spend, so you can catch an expensive model choice before it's baked into your product — not after the first invoice.
What actually moves your AI API bill
The headline per-token rate is only half the story. These two factors explain most of the gap between what people expect to pay and what they actually get billed.
Output length is usually the bigger lever
A short prompt with a long, detailed response often costs more than a long prompt with a one-line answer. If your bill is higher than expected, check output length before you blame input size.
Cached and repeated context costs less
If your app resends the same system prompt or reference document on every call, prompt caching can cut that portion of the input cost by 80–90% on providers that support it. This calculator estimates standard rates; check your provider's caching pricing separately.
AI API pricing changes frequently as providers release new models and adjust rates. We update this page as new pricing is announced, but for production budgeting, always cross-check against the provider's official pricing page linked from the model selector above.
Frequently Asked Questions
How accurate is this AI token calculator?
Token counts come from each provider's own tokenizer logic, so they closely match what you'd see on your actual API bill. Pricing reflects each provider's publicly listed rates at the time of writing — always confirm against the provider's official pricing page before a large-scale deployment, since rates change and providers sometimes offer volume, cached-input, or batch discounts this calculator doesn't model.
Why do GPT, Claude, and Gemini charge different prices for input vs. output tokens?
Generating text costs more compute than reading it, so every major provider prices output tokens higher than input tokens — commonly 3 to 5 times more. A short prompt that triggers a long, detailed answer can end up costing more than the input token count alone would suggest.
What's a token, in plain terms?
A token is a chunk of text — often a word or part of a word — that a model processes as one billing unit. English text averages roughly 4 characters per token, but this varies by language and content type, which is why an exact tokenizer count is more reliable than a rough word-count estimate.
Which AI model is cheapest for high-volume use?
It depends on your workload, but as a rule of thumb: lighter, faster models built for high-volume tasks (classification, extraction, routing, simple chat) are priced far below flagship reasoning models. Route the bulk of your traffic to a cheaper model and reserve the expensive flagship for tasks that genuinely need it — this single change is usually the biggest lever on your bill.
Does this calculator send my text anywhere?
No. Tokenization and cost calculation run entirely in your browser — your text isn't uploaded, logged, or stored.
Why do costs here look different from what I'm seeing in my provider dashboard?
Differences usually come from cached-input pricing, batch API discounts, system prompts or tool-call overhead not included in your test input, or a rate change on the provider's end since this page was last updated. Use this calculator for quick estimates and planning, and your provider's billing dashboard for exact spend.
Token Cost Calculator
AI API bills rarely surprise you when you plan for them — they surprise you when you don't. Before you ship a feature that calls an LLM on every user request, it pays to know what that request actually costs, and what it adds up to at 1,000 or 100,000 users a month. Growfiy's Token Cost Calculator turns your prompt into a real cost estimate across OpenAI, Claude, Gemini, DeepSeek, Llama, and Mistral, so you can budget with numbers instead of guesswork.
It's built for founders sizing up a monthly AI budget, developers comparing models before an integration, and teams trying to figure out where their spend is actually going.
How Your Cost Is Calculated
Most LLM providers bill input and output tokens at different rates, so a single "cost per token" number is misleading. The calculator applies the correct rate to each side of the request:
For a chat feature, output tokens usually cost more per unit than input tokens — which is why a short prompt with a long response can cost more than a long prompt with a short answer. Comparing this ratio across providers is often more useful than comparing sticker price alone.
Who Uses This — and Why
- Founders budgeting a new AI feature: estimate cost-per-user before deciding whether a feature is financially viable at scale, not after the first invoice.
- Developers choosing between models: compare a flagship model against a smaller one for the same task to see if the accuracy gain is worth the cost gap.
- Teams auditing existing AI spend: reverse-check whether current usage patterns — long system prompts, verbose outputs, redundant context — are quietly inflating monthly bills.
- Students and researchers: understand how pricing structures differ across providers before running large-scale experiments or fine-tuning workflows.
Practical Ways to Lower Your Token Cost
- Cache and reuse system prompts instead of resending them with every request.
- Set a max_tokens/output cap so responses don't run longer than necessary.
- Route simple, low-stakes queries to a smaller or cheaper model and reserve flagship models for complex tasks.
- Strip unused context, boilerplate, or repeated instructions from prompts before sending them.
- Batch similar requests where the provider supports it, rather than sending many small calls.
Frequently Asked Questions
How do I calculate the cost of my AI API usage in advance?
Multiply your estimated token count by the provider's per-token rate for both input and output separately, since most models charge differently for prompt tokens versus completion tokens. Growfiy's calculator automates this so you get an instant per-request cost estimate.
Why does the same prompt cost differently across providers?
Each provider prices input and output tokens separately, and rates vary by model tier. A cheaper model may also use a different tokenizer, so the same sentence can produce a different token count and, therefore, a different cost across OpenAI, Claude, Gemini, DeepSeek, Llama, and Mistral.
How do I estimate monthly AI costs for a live product?
Take your average cost per request, multiply it by expected daily requests, then by 30. Add a buffer of 20-30% for usage spikes, retries, and longer-than-average responses before setting your monthly budget.
What's the easiest way to reduce token costs?
Trim unnecessary context from prompts, cache repeated system instructions, cap max output tokens where possible, and route simpler queries to smaller, cheaper models instead of sending every request to a flagship model.
Does this tool account for both input and output token pricing?
Yes. Since input (prompt) and output (completion) tokens are billed at different rates on most platforms, the calculator lets you estimate both separately for a realistic total cost per request.
Is this calculator suitable for estimating a startup's AI budget?
Yes, it's built for exactly that — founders and teams can model cost-per-user or cost-per-feature before committing to a provider, which is especially useful when deciding between a cheaper model and a premium one at scale.