LLM Pricing Calculator — Compare GPT-5, Claude, Gemini & 160+ Models

How LLM Pricing Works

LLM API pricing is calculated per token, where one token corresponds to roughly 4 characters of English text or about three-quarters of a word. Every major provider (OpenAI, Anthropic, Google, Meta via hosted endpoints, Mistral, DeepSeek, xAI, Cohere, and Alibaba) charges separately for input tokens (the prompt you send) and output tokens (the response you receive). Output tokens are almost always priced higher than input tokens, typically three to five times higher, because generating text is computationally more expensive than ingesting it. According to OpenAI's pricing page, GPT-4o charges $2.50 per million input tokens and $10 per million output tokens. Anthropic's Claude Sonnet 4.6 is priced at $3 per million input and $15 per million output.

Beyond the base rate, three major discount mechanisms can dramatically change the real cost: prompt caching, batch API mode, and model tier selection. Prompt caching reuses a static prefix (such as a system prompt or RAG context) across requests at up to 90 percent off, and is supported by Anthropic, OpenAI, and Google Gemini. Batch API mode processes non-urgent workloads asynchronously within 24 hours at a flat 50 percent discount. Choosing a smaller "mini" or "haiku" tier model can cut costs by 90 to 95 percent while retaining most capabilities for many tasks. Combining all three optimizations can reduce total spend by 80 to 95 percent versus naively using the flagship model at standard rates.

Understanding Tokens and Tokenization

A token is a unit of text used by the language model, generally corresponding to a common word, sub-word, or punctuation mark. Different models use different tokenizers, so the same sentence can produce slightly different token counts across providers. OpenAI's GPT-4o and newer models use the tiktoken library with the o200k_base encoding. Anthropic uses a proprietary tokenizer optimized for multilingual text. Google Gemini and Meta Llama models use SentencePiece-based tokenizers. On English text, all major tokenizers produce counts within 10 to 15 percent of each other, so the character-based approximation used in this calculator (one token ≈ 4 characters) is accurate enough for cost estimation.

Common token counts to remember: 1 token is about 4 English characters or 0.75 words. 100 tokens is roughly 75 words or one short paragraph. 1,000 tokens is about 750 words, or 1.5 single-spaced pages. 10,000 tokens is 7,500 words, roughly equivalent to a short magazine article. 100,000 tokens is around 75,000 words, or the length of a 200-page novel. Most modern frontier models support context windows of 128,000 to 1,000,000 tokens, which is enough to fit entire books or large codebases in a single prompt.

Provider Pricing Snapshot — April 2026

The table below shows base pricing for the flagship models of each major provider as of April 2026. Prices are per million tokens and reflect standard (non-batch, non-cached) API rates. Always verify current rates directly with the provider before committing to a workload at scale, since pricing changes periodically.

Real-World Cost Examples

Example 1 — Customer support chatbot: A typical support chatbot processes 1,000 conversations per day with an average of 500 input tokens and 400 output tokens per turn. Running this on GPT-4o costs approximately $0.005 per conversation ($5 per day, $150 per month). Running the same workload on GPT-4o-mini costs $0.00039 per conversation ($0.39 per day, $11.70 per month), an 92 percent cost reduction. Running it on Claude Haiku 4.5 costs $0.0003 per conversation ($0.30 per day, $9 per month).

Example 2 — RAG system with large documents: A retrieval-augmented system sends 8,000 tokens of context plus a 200-token question on every request and receives 500 tokens of output. At 500 requests per day on Claude Sonnet 4.6, daily cost is approximately $16.35 ($490/month). Enabling Anthropic prompt caching on the 8,000-token context reduces the input cost by approximately 90 percent after the first request, dropping total cost to about $3.75/day ($112/month), a 77 percent savings.

Example 3 — Bulk document processing: Summarizing 10,000 research papers, each ~30,000 input tokens with ~1,000 output tokens per summary, costs $3,750 on GPT-4o via the standard API. Using the batch API drops this to $1,875. Switching to Gemini 2.5 Flash drops it further to $75 via standard API. For non-urgent bulk workloads, the cheaper model plus batch discount can turn a $3,750 job into a $37.50 job — a 99 percent reduction.

How to Reduce LLM Token Costs — 15 Proven Strategies

Most production LLM workloads overspend by 3 to 10 times what is actually necessary. The savings are in the engineering, not the vendor. Here are the specific techniques that deliver real cost reductions, ordered roughly from highest impact to lowest. Every number in this section comes from our own testing, provider documentation, and published benchmarks.

1. Switch to a Smaller Model Tier (80-95% savings)

The single biggest lever. Most production workloads default to GPT-4o or Claude Sonnet when GPT-4o-mini or Claude Haiku 4.5 would do the job. Mini and haiku tier models are roughly 10-20% of the cost with 85-95% of the quality on most general-purpose tasks. Rule of thumb: always start with the cheapest capable tier and only escalate when you have a specific quality failure to point to. For example, switching a customer-support chatbot from GPT-4o ($2.50/$10 per million) to GPT-4o-mini ($0.15/$0.60) drops monthly cost by 94% — for most chat use cases this is quality-neutral.

2. Enable Prompt Caching (50-90% savings)

Identify the static portion of your prompt — system instructions, persona, document context, few-shot examples, tool definitions — and mark it as cacheable. Anthropic offers up to 90% off cached input, OpenAI 50-75%, and Google Gemini has context caching with similar savings. Real example: a RAG chatbot with an 8,000-token document context and a 200-token user query, running 500 times per day on Claude Sonnet 4.6, costs ~$12/day uncached. With caching on the 8,000-token prefix, the discount drops that to ~$3.60/day — a 70% reduction. Caching is a configuration change, not a refactor — it can usually be enabled in one afternoon.

3. Use the Batch API for Non-Urgent Work (50% flat)

Both OpenAI and Anthropic batch APIs give a flat 50% discount on both input and output tokens, with 24-hour turnaround. Ideal for bulk workloads that do not need real-time responses: summarization of large document sets, classification/labeling jobs, data extraction pipelines, bulk translation, embedding generation, quality scoring, and offline agent research tasks. Processing 10 million input tokens with GPT-4o costs $25 on the standard API and $12.50 via batch. For any workload where "within 24 hours" is acceptable, batch is the single cheapest optimization you can make.

4. Limit Output Length Explicitly (20-50% savings)

Output tokens cost 3 to 5 times more than input tokens on every major provider. A small reduction in output length produces an outsized reduction in total cost. Always set max_tokens in your API calls to cap runaway responses. Explicitly prompt the model to be concise: "Answer in one sentence", "Respond in under 50 words", "Return only the JSON object, no preamble". For chatbot workloads, reducing average output length from 600 to 400 tokens drops total cost by approximately 25%. For summarization tasks, prompting for bullet points instead of paragraphs typically saves 30-40% on output.

5. Compress Your Prompts (20-40% savings)

Most prompts in production systems are bloated with filler words ("please", "kindly", "if you could"), redundant instructions, verbose examples, and boilerplate. Rewrite them in tight imperative style. Replace prose instructions with numbered bullet points. Remove politeness tokens — the model is not offended. Use abbreviations where the meaning is unambiguous. Real example: a 1,200-token system prompt compressed to 720 tokens reduces input cost by 40% per request at zero quality loss. Over a million requests per month, that is a 40% reduction in the entire input line item. Tools like Anthropic's prompt improver or GPT-4 itself can suggest compressions.

6. Truncate or Summarize Chat History (30-70% savings)

The naive way to build a chatbot is to send the full conversation history on every turn. After 20 turns, your input prompt is 20 times longer than the user's latest message, and you are paying for every re-send. Better: use a sliding window — keep only the last 5-6 turns verbatim. Even better: summarize older turns with a cheap model (Haiku / GPT-4o-mini / Gemini Flash) and inject the summary as context. This reduces chat history cost by 60-80% on long conversations while preserving continuity. Libraries like LangChain and LlamaIndex have built-in "ConversationSummaryMemory" primitives for this.

7. Use Structured Outputs / JSON Mode (15-30% savings)

When you need structured data, ask for JSON directly instead of parsing prose. JSON is more token-dense than natural language for structured content, produces predictable output lengths you can budget around, and eliminates the "parsing preamble" ("Sure, here is the data you requested: ...") that flagship models love to add. OpenAI's JSON mode, Anthropic's tool use, and Gemini's structured outputs all enforce strict JSON schemas. Real example: extracting 8 fields from user messages via prose output averages ~180 tokens per response; the same extraction via JSON mode averages ~110 tokens — a 39% output reduction.

8. Two-Stage Pipelines — Cheap Model Then Flagship (60-80% savings)

Instead of using a flagship model for everything, use a cheap model (GPT-4o-mini, Haiku, Flash) for the bulk work and only escalate to a flagship model when the cheap model's output requires review or extension. Examples: use Haiku to classify incoming support tickets by category, only route "complex" ones to Sonnet for the actual response. Use GPT-4o-mini to draft the initial response, only use GPT-4o to polish before sending. Use Flash to pre-filter 1,000 candidate documents down to 10, then use Pro to synthesize. Two-stage pipelines typically cut total cost 60-80% versus single-model approaches for the same output quality.

9. Better RAG Chunking and Reranking (40-70% savings)

Most RAG systems retrieve 10-20 large chunks and dump them all into the prompt. This is wasteful. Two fixes: shrink chunk size (smaller chunks mean less irrelevant content in the injected context), and rerank retrieved chunks with a cheap cross-encoder before sending them to the generation model. Cohere's rerank model is $2 per 1,000 searches and reduces the chunks you need to send by 50-70%. Net effect: smaller RAG prompts, faster responses, and dramatically lower per-query costs. For a RAG system doing 10,000 queries/day at ~10k tokens context each, better chunking + reranking typically cuts cost from ~$300/day to ~$80-120/day.

10. Use Embeddings Before the LLM (90%+ savings)

For semantic search, similarity matching, deduplication, clustering, and classification of items against a fixed taxonomy, embeddings are roughly 100 times cheaper than sending the same task to an LLM. OpenAI's text-embedding-3-small is $0.02 per million tokens — essentially free at scale. Build your retrieval layer on embeddings, let the LLM handle only final synthesis. A search-over-10,000-documents system that sends each document to GPT-4o for matching costs ~$500 per query; the same system built on embeddings costs ~$0.05 per query. When your task is "find the right thing" rather than "generate the thing", embeddings win every time.

11. Remove Stale Few-Shot Examples (20-50% savings)

Many production systems ship with 5-10 few-shot examples in the prompt and never revisit them. As models improve, those examples become dead weight: the newer model no longer needs them to produce quality output. Test removing or shrinking your few-shot examples periodically — often you can cut 3-5 examples without any quality loss, reducing prompt size by 30-50%. This is especially true with frontier models (Claude Sonnet 4.6, GPT-4.1, Gemini 2.5 Pro) which have strong zero-shot performance on most tasks.

12. Test Open-Source Models via Groq, DeepSeek, Together (80-95% savings)

For commodity tasks — classification, extraction, simple generation, summarization, translation, data cleanup — open-source models hosted by Groq, Together, Fireworks, DeepInfra, Replicate, and OpenRouter are 10 to 50 times cheaper than GPT-4o with acceptable quality. Llama 3.3 70B via Groq is $0.59 input and $0.79 output per million tokens, versus $2.50/$10 for GPT-4o. DeepSeek V3 direct is $0.27/$1.10. For a task where "GPT-4o quality" is not required, switching to one of these options routinely saves 85-95% of spend.

13. Set Hard Token Budgets and Alerts

The single easiest way to lose $10,000 on LLM bills is to ship a bug that sends requests in a tight loop, or lets a user abuse your system with 100k-token prompts. Every production system should have: per-user daily token budgets with automatic blocking, per-endpoint rate limits, and billing alerts at multiple thresholds (50%, 80%, 120% of budget). OpenAI and Anthropic both offer usage limits in their dashboards. Set them. This does not reduce your cost per request but it prevents catastrophic overages — which is often the biggest "savings" you can get.

14. Stop Runaway Agent Loops

Agentic workflows (multi-step tool-using agents) are the #1 cause of unexpected LLM bills. An agent that gets stuck in a loop can easily burn 1 million tokens in an hour. Always enforce a hard maximum on tool-call iterations (typically 10-20), total tokens per agent run (typically 100k-500k), and wall-clock time per run (typically 5-10 minutes). Log every step. Kill runs that exceed the budget. For production agents, also implement circuit breakers that disable the agent entirely if error rate spikes above a threshold.

15. Stream and Terminate Early (10-30% savings)

Streaming responses allows your application to stop consumption as soon as enough output has been generated. For interactive use cases (chatbots, autocomplete, code suggestion), this is a free optimization: users see the first tokens faster and you can abort the stream if the user cancels, clicks away, or if the output already satisfies the use case. Also useful for parsing-early scenarios: if you are extracting a JSON field, you can stop streaming once the field arrives instead of waiting for the full response. Savings are smaller than the other strategies here (10-30%) but the latency improvements alone usually justify it.

Best LLM by Use Case (2026 Recommendations)

The right model depends on the task, your quality requirements, and your budget. Below are my current recommendations by use case, updated for April 2026. Every recommendation is based on published benchmarks and the real-world cost math this calculator can verify.

Best LLM for a Customer Support Chatbot

Primary pick: GPT-5 Mini ($0.25/$2.00) or Claude Haiku 4.5 ($1/$5). For a chatbot handling 1,000 conversations a day with 500-token messages, GPT-5 Mini costs approximately $1.13/day ($34/month) and Claude Haiku 4.5 costs approximately $3.00/day ($90/month). Both deliver near-frontier conversational quality at a small fraction of flagship prices. Only escalate to Claude Sonnet 4.6 or GPT-5 if your users are repeatedly hitting edge cases the mini tier cannot handle. Alternative: DeepSeek V3 at $0.014/$0.028 per million is 18x cheaper than GPT-5 Mini if quality-per-dollar is your only constraint.

Best LLM for Coding and Developer Tools

Primary pick: Claude Sonnet 4.6 ($3/$15) or GPT-5 Codex ($1.25/$10). Claude Sonnet 4.6 is still widely considered the best coding model as of April 2026, with strong performance on SWE-bench, real-world bug fixing, and multi-file refactoring. GPT-5 Codex is a strong secondary for OpenAI-stack teams. For budget-conscious coding workloads, Mistral Codestral 2508 ($0.30/$0.90) and Devstral Small 1.1 ($0.07/$0.28) offer ~80% of Sonnet's quality at a tiny fraction of the cost. DeepSeek Coder V2 is another strong budget option. For heavyweight agentic coding (Claude Code, Cursor Composer, Cline), Claude Sonnet 4.6 or GPT-5.1 Codex are the standards.

Best LLM for RAG and Document Q&A

Primary pick: Gemini 2.5 Flash ($0.30/$2.50) or Claude Sonnet 4.6 with caching ($3/$15 before cache). For RAG, the biggest cost factor is the context you inject. Use Gemini 2.5 Flash for its combination of 1M context window, fast speed, and low price. If you need higher-quality synthesis and have Anthropic in your stack, use Claude Sonnet 4.6 with prompt caching enabled — the 90% cache discount on the static document context dramatically reduces per-query cost. Always pair with an embedding + rerank step (use OpenAI text-embedding-3-small at $0.02/1M or Cohere Embed v3 at $0.10/1M) rather than dumping all retrieved chunks into the prompt.

Best LLM for Reasoning and Complex Problem Solving

Primary pick: OpenAI o3 ($2/$8) or DeepSeek R1 ($0.55/$2.00). For hard reasoning tasks — math, logic puzzles, complex multi-step problems, scientific reasoning — the reasoning-tuned models decisively beat base models. o3 is the most accurate and now priced reasonably at $2/$8. DeepSeek R1 is the budget alternative at roughly 25% of the cost with 80-90% of the quality. Claude Opus 4.6 Thinking ($5/$25) is the top option if you value Anthropic's reasoning style. Reserve o1 Pro ($150/$600) for the most demanding problems where every percentage point of accuracy matters — at its price point, you should be using it sparingly.

Best LLM for Bulk Processing and Data Extraction

Primary pick: GPT-5 Nano ($0.05/$0.40) or DeepSeek V3 ($0.014/$0.028), both with batch API. For classification, entity extraction, labeling, or bulk summarization of millions of documents, go with the cheapest capable model and use the batch API for an additional 50% discount. GPT-5 Nano in batch mode costs effectively $0.025/$0.20 per million. DeepSeek V3 without batch is already cheaper than any batch-mode competitor at $0.014/$0.028 per million. Processing 10 million documents averaging 2,000 tokens each costs approximately $560 on GPT-4o ($2.80 per 10k docs) versus $11.20 on GPT-5 Nano batch, or about $4 on DeepSeek V3.

Best LLM for Agent Workflows

Primary pick: Claude Sonnet 4.6 ($3/$15) or GPT-5 ($0.625/$5). Agentic workflows with tool use are the fastest-growing cost category — a single poorly-designed agent can burn millions of tokens per session. Claude Sonnet 4.6 has the strongest tool-use and multi-step planning performance in production agents. GPT-5 is a very close second and noticeably cheaper per request. Both support function calling, JSON mode, and structured outputs. Avoid flagship Opus and o1 Pro tier models for agent loops unless you are paying attention to wall-clock budgets — their per-token cost multiplies quickly across many tool calls. Always enforce a hard max-iterations limit and per-run token budget in production.

Best LLM for Creative Writing and Long-Form Content

Primary pick: Claude Opus 4.6 ($5/$25) or GPT-5 ($0.625/$5). Claude's voice consistency, narrative flow, and nuance on creative prompts remains the gold standard in 2026. Opus 4.6 at the new $5/$25 price is dramatically more accessible than the old $15/$75 Opus 4 pricing. For budget creative work, GPT-5 Chat ($1.25/$10) and Gemini 3.1 Pro ($2/$12) are solid choices. Mistral Small Creative ($0.10/$0.30) is specifically tuned for creative writing at a tiny fraction of the cost — worth testing for story generation, marketing copy, and ideation.

Best LLM for Multilingual Tasks

Primary pick: Gemini 3.1 Pro ($2/$12) or GPT-5 ($0.625/$5). Google's Gemini models have historically been the strongest on non-English tasks, and Gemini 3.1 Pro maintains that lead. GPT-5 and Claude Sonnet 4.6 are close seconds. For budget multilingual work at scale, Gemini 2.5 Flash Lite ($0.10/$0.40) is competitive. DeepSeek V3 handles Chinese and many Asian languages well. Mistral Saba is specifically trained for Arabic and Middle Eastern languages if that is your target.

Model Family Quick Reference (2026)

Here is the at-a-glance price ladder for the most-used model families as of April 2026. Use this to quickly identify the cheapest frontier option in each ecosystem before opening the full calculator below.