LLM API Pricing Comparison: Every Major Provider in One Table
On this page
I spent a full day last week pulling together accurate LLM API pricing data from every major provider. Not because I wanted to — because every comparison I found was either three months stale, missing output token costs, or glossing over the details that actually matter. Pricing complexity is a real problem in this space: different input and output token rates, separate charges for extended thinking, minimum commitments buried in the docs, batch discount terms that require a support ticket to even confirm.
The competitive gap between providers has narrowed dramatically — AI API prices have dropped roughly 90% since 2023 on a capability-adjusted basis. But that compression makes the remaining differences harder to parse, not easier. The wrong choice can still cost you thousands monthly. API costs represent 30–70% of total infrastructure budget for AI-heavy applications. That’s not rounding error.
Here’s what most comparison tables won’t tell you: the cheapest path usually isn’t picking one provider and going all-in. I’ll get to that in a moment. First, the table you actually came here for.
What You’re Actually Paying For
Every provider prices on tokens — fragments of text roughly 0.75 words each. Prices are published per million tokens, shown as ‘/1M’ or ‘/M tokens’ in rate cards. Every API call is billed in two directions: input tokens (your prompt, system instructions, conversation history) and output tokens (the text the model generates back).
Output tokens cost more. Consistently and significantly more. Across the industry, the ratio runs 2x to 5x. OpenAI’s GPT-4.1 charges $2.00 per million input tokens and $8.00 per million output — a 4x multiplier. This pattern holds everywhere. It matters more than most people realize when you’re estimating workloads, because output token counts are hard to predict in advance.
LLM API Pricing Comparison: Every Major Provider (2026)
This table covers the models you’re most likely to evaluate for production workloads. Prices are per million tokens as of February 2026. Context window sizes reflect published maximums.
OpenAI
- GPT-4.1 — $2.00 input / $8.00 output | 1M ctx | Strong general-purpose, 4x output multiplier
- GPT-4.1 Nano — $0.10 input / $0.40 output | 1M ctx | 10x cheaper than Claude Haiku at same tier
- GPT-5 — $10.00+ input / ~$30.00+ output | Large ctx | Flagship, costs $1,050+/month at scale
Anthropic
- Claude Opus 4.5 / 4.6 — $5.00 input / $25.00 output | 200K ctx | Most capable Claude, 5x output multiplier
- Claude Sonnet 4.5 — $3.00 input / $15.00 output | 200K ctx | Mid-tier workhorse
- Claude Haiku 4.5 — ~$1.00 input / ~$4.00 output | 200K ctx | Fastest and cheapest Claude tier
- Gemini 2.5 Pro — Mid-high pricing | 1M ctx | Reasoning-capable flagship
- Gemini 2.5 Flash — ~$0.15 input / ~$0.60 output | 1M ctx | Roughly 10x cheaper input than GPT-4o and Claude Sonnet, with reasoning capabilities
- Gemini 2.0 Flash — $0.10 input / $0.40 output | 1M ctx | Among the cheapest capable models available
- Gemini 2.5 Flash Lite — $0.10 input / $0.40 output | 1M ctx | Identical pricing to GPT-4.1 Nano
DeepSeek
- DeepSeek V3 / V3.2 — $0.27 input / $1.10 output | 64K ctx | Cheapest frontier-class option, open weights
- DeepSeek R1 — Higher reasoning-tier pricing | 64K ctx | Reasoning model, competitive with Western alternatives
Mistral
- Mistral Large — Competitive mid-tier pricing | 128K ctx | European provider, strong for EU data residency needs
- Mistral Small / 7B (self-hosted) — ~$0.05/1M tokens GPU-only via vLLM | Full data control, requires GPU infrastructure
Thinking Tokens and the Costs Most Tables Skip
Several frontier models now offer ‘extended thinking’ or ‘reasoning’ modes — where the model works through a problem step-by-step before responding. This produces better outputs for complex tasks. It also generates a lot of intermediate tokens that you pay for.
Claude Opus 4.5 and 4.6 with extended thinking, DeepSeek R1, and Gemini 2.5 Pro with reasoning enabled all add meaningful token overhead on top of standard input/output pricing. The exact multiplier depends on problem complexity and isn’t predictable from a rate card. If you’re evaluating reasoning models for cost, benchmark with your actual use case — synthetic tests will lie to you.
Other costs providers don’t lead with: fine-tuning charges (training your own version of a model), cached input discounts (some providers reduce costs for repeated context that matches a previous request), and rate limits that may push you to a higher tier before you hit a cost ceiling.
Why Picking One Provider Is the Wrong Strategy
Here’s the thing I teased at the top. Practitioners who’ve managed real AI infrastructure budgets report that smart API selection and usage patterns can reduce LLM costs by 60–80% without meaningful quality loss. The mechanism isn’t finding the cheapest single provider — it’s routing.
The insight is straightforward once you see it: roughly 70% of typical AI API traffic is simple, high-volume tasks — classification, summarization, short Q&A, entity extraction — where a $0.10/1M model produces results equivalent to a $10.00/1M model. You’re paying 100x more for the same output. Route those tasks to Gemini Flash or GPT-4.1 Nano. Reserve Claude Opus or GPT-5 for the 30% of requests that genuinely need them.
The practical implementation of this for AI agent workloads is exactly what platforms like BrainRoad handle — you define which tasks need which capability tier, and the routing happens automatically. If you’re evaluating best AI agents for real workloads, this is the architecture decision that matters more than which provider you sign up with.
Real-World LLM Cost Comparison: What 1,000 Daily Conversations Actually Costs
Beacon’s shining a light on the fine print — because with so many providers, the real cost is often hiding in plain sight.
Abstract pricing per million tokens is hard to reason about. Here’s the same workload across providers: a chatbot running 1,000 conversations per day, averaging 2,000 tokens each.
- Gemini 2.0 Flash — approximately $12/month
- GPT-4.1 Nano / Gemini 2.5 Flash Lite — approximately $12–15/month
- DeepSeek V3 — approximately $25–40/month
- Claude Haiku 4.5 — approximately $120–150/month (roughly 10x more than the cheapest options)
- Claude Sonnet 4.5 / GPT-4o — approximately $270–400/month
- Claude Opus 4.5 — approximately $600–800/month
- GPT-5 — approximately $1,050/month
That’s roughly an 87x cost difference between the cheapest and most expensive options for identical throughput. The quality difference for a simple chatbot use case: minimal. The quality difference for a complex reasoning task: real. Which is exactly why the routing strategy above matters.
Batch Discounts, Free Tiers, and Starter Credits
Both OpenAI and Google offer 50% batch API discounts on standard pricing for non-latency-sensitive workloads. If you’re running overnight data processing, document analysis, or any job where the result doesn’t need to arrive in seconds, batch mode is an easy cost cut.
Gemini provides a more generous free tier for development and low-volume testing. OpenAI offers $5 in starter credits that expire in three months. Anthropic’s free tier is minimal — mostly useful for confirming your integration works before committing spend.
DeepSeek’s pricing advantage partially comes from its open-weights status — you can run it yourself, host it via third-party providers, or use their direct API. For EU compliance requirements, Mistral’s managed API offers data residency options that neither US-based provider can match without significant procurement effort.
Where the AI API Cost Math Falls Apart
Self-hosting looks compelling on paper. Mistral-7B via vLLM at roughly $0.05 per million tokens is a 60x raw cost advantage over AWS Bedrock Claude Sonnet at $3.00/$15.00 per million tokens. The number is real. The total cost of ownership isn’t.
- GPU infrastructure is not set-and-forget. Driver updates, CUDA version mismatches, out-of-memory failures at 2 AM — this is ops work that shows up in your on-call rotation, not your rate card.
- Reasoning token blowout. Enabling extended thinking on complex tasks can multiply your token spend 3–5x for a single request. Budget accordingly or add hard limits.
- Context window traps. A 64K context window (DeepSeek) and a 1M context window (Gemini Flash) are functionally different products for document-heavy workloads. The cheaper model may not fit your use case.
- Rate limit ceilings. Free tiers and starter accounts have rate limits that will cap your throughput before you hit a budget ceiling. Factor in the cost and timeline to upgrade access tiers.
- Hidden fine-tuning costs. Fine-tuning a model on your own data (training it on your specific examples) carries separate per-token training charges that aren’t reflected in inference pricing tables.
- Pricing changes without warning. Providers adjust rates. The table above will drift. Budget 10–15% variance into any annual estimate.
How to Know Your LLM API Costs Are Actually Under Control
- You have a per-request token logging system in place — you can answer ‘what did that call cost?’ for any API request
- Your output token estimates were validated against real outputs, not assumed from documentation
- You’ve set hard spending limits in your provider dashboard — not soft alerts, actual hard stops
- Batch processing is enabled for any workload with >1 hour acceptable latency
- You’ve benchmarked at least two providers for your highest-volume task category
- Your cost-per-task metric is tracked weekly, not just monthly billing surprises
If you’re running agents that call APIs autonomously, the stakes are higher. An agent that loops or generates unexpectedly long outputs can run up costs fast without a human in the loop to catch it. I covered the security and access angle in Your New AI Hire Has More Access Than Your IT Department — the cost exposure is the same problem from a different angle.
Your Monday Morning LLM Cost Audit
- Pull your last 30 days of API spend broken down by model. If you can’t do this, that’s step zero — enable cost breakdown logging in your provider dashboard today.
- Identify your top 3 task categories by token volume. For each one, answer: does this task require a frontier model, or would a $0.10/1M model produce equivalent results?
- If more than 50% of your volume is going to a model priced above $1.00/1M input, run a routing experiment — send 10% of that traffic to Gemini 2.0 Flash or GPT-4.1 Nano and compare output quality against your acceptance criteria.
- Check whether batch mode is enabled for any workload that doesn’t require sub-5-second response times. Both OpenAI and Google give you 50% back just for flagging the request as non-urgent.
- Set a hard monthly spend cap at 120% of your current average — not an alert, a hard stop — so a runaway agent or infinite loop doesn’t land as a billing surprise.
- If you’re evaluating a new provider, test with your actual production prompt lengths and expected output sizes. Synthetic benchmarks will underestimate output token costs by 30–50% for most real workloads.
- For any workload over $200/month, get a written quote for a committed-use discount. Most providers offer them at the $500–1,000/month threshold — just not prominently.
What This LLM API Pricing Comparison Actually Means for Your Budget
- Output tokens cost 2–5x more than input tokens across every major provider — this ratio matters more than the headline input price when estimating real workload costs.
- For identical throughput (1,000 conversations/day), costs range from ~$12/month (Gemini Flash) to ~$1,050/month (GPT-5) — an 87x spread for work where quality differences are often minimal.
- Both OpenAI and Google offer 50% batch discounts for non-latency-sensitive workloads. This is the easiest cost cut most teams haven’t taken.
- Smart model routing across tiers — cheap models for simple tasks, frontier models for complex ones — can reduce total AI API costs by 60–80% without quality loss.
- AI API prices have dropped roughly 90% since 2023 on a capability-adjusted basis, but API spend still represents 30–70% of infrastructure budget for AI-heavy applications. The routing decision is still high-leverage.
- Self-hosting looks 60x cheaper than managed APIs on raw compute cost. It’s rarely 60x cheaper in practice once ops overhead is accounted for.
Frequently Asked Questions
Which LLM API is cheapest for high-volume production workloads?
For raw throughput at lowest cost, Gemini 2.0 Flash ($0.10/$0.40 per million tokens) and GPT-4.1 Nano ($0.10/$0.40) are the cheapest capable options from major providers. DeepSeek V3 ($0.27/$1.10) is slightly more expensive but offers open-weights flexibility and frontier-class quality. For a chatbot running 1,000 conversations a day, Gemini Flash runs approximately $12/month.
Why do output tokens cost more than input tokens?
Generating text requires more compute than reading it. The model processes your input in parallel but generates output tokens sequentially, one at a time. This sequential generation is computationally heavier, so providers charge a higher rate. The industry standard ratio is 2x to 5x — OpenAI’s GPT-4.1 charges 4x more for output than input.
What is the batch API discount and how do I use it?
Both OpenAI and Google offer 50% discounts when you submit requests via their batch APIs. Batch requests are processed asynchronously — typically within a few hours — rather than in real time. Any workload that doesn’t require immediate responses qualifies: document analysis, data enrichment, overnight summarization, bulk classification. You flag the request as a batch job at submission time and pay half the standard rate.
Is DeepSeek's pricing real or is there a catch?
The pricing is real — DeepSeek V3 at $0.27/$1.10 per million tokens is significantly cheaper than comparable Western frontier models. The context window is 64K tokens, which is smaller than Gemini’s 1M or Anthropic’s 200K. For document-heavy workloads that need long context, this is a genuine constraint. DeepSeek is a Chinese company, which raises data residency and compliance questions for some enterprise deployments. Evaluate against your own requirements.
How do I compare LLM API costs for my specific use case?
Don’t rely on per-million-token rates alone. Run a pilot with your actual prompts and measure: (1) average input token count per request, (2) average output token count per response — this is the number people underestimate most. Multiply by your daily request volume and the provider’s per-token rate. Compare at least two providers before committing. For AI agent workloads, also test latency and rate limits under realistic load — a cheaper model that hits rate caps costs more in practice.
What's the difference between AI API pricing and LLM API pricing?
They refer to the same thing. ‘LLM API pricing’ (where LLM stands for large language model — the technology behind tools like ChatGPT and Claude) is the more specific term used by developers. ‘AI API pricing’ is the broader search term people use when they’re comparing providers. Both describe per-token charges for accessing AI language models via API.
Sources
- computeprices.com — LLM API Pricing Comparison
- apicostcompare.com — AI API Pricing in 2026
- tldl.io — LLM API Pricing 2026
- zenvanriel.com — LLM API Cost Comparison 2026
- burnwise.io — AI API Pricing Comparison 2026
- llmgateway.io — OpenAI vs Anthropic vs Google Cost Comparison
- aifreeapi.com — Gemini API vs OpenAI API Pricing Comparison
- calmops.com — Complete Guide to LLM API Providers
- openclawradar.com — 2026 LLM API Cost Comparison: Self-Hosting vs. Cloud Providers
- aitoolvs.com — Claude API vs OpenAI API 2026