LLM API Pricing Comparison: Every Major Model Compared by Cost

If you are building an application on top of large language models in 2026, you are facing an unprecedented landscape. A single API call can cost anywhere from a fraction of a cent to over a dollar, and the gap between the cheapest and most expensive flagship models now exceeds 100x. Choosing the wrong model for your workload is not a minor optimization problem; it is the difference between a profitable product and an unsustainable burn rate.

This guide compares API pricing across every major model provider, including OpenAI, Anthropic, Google, DeepSeek, Kimi, MiMo, MiniMax, and others, with real prices, not just headline rates. We cover prompt caching mechanics in detail, explain why tokens-per-second matters as much as cost-per-token, and highlight the hidden costs that most pricing pages ignore. For a broader look at how AI subscription costs compare, see our analysis of why AI subscriptions are so expensive and how to find value.

How LLM API Pricing Works

Every major LLM provider charges by the token, a fragment of a word that the model processes. You pay separately for two directions:

• Input tokens: everything you send to the model: your prompt, conversation history, system instructions, and any documents or images you include.
• Output tokens: everything the model generates in response, including reasoning tokens that chain-of-thought models produce internally before giving you an answer.

Output tokens are almost always more expensive than input tokens, typically 3x to 12x, because each one requires a full forward pass through the model. Input tokens, by contrast, can be processed in parallel and are computationally cheaper.

Prices are quoted per million tokens (MTok). To put that in perspective: one million tokens is roughly 750,000 words, or about three copies of The Great Gatsby. A short, single-turn question-and-answer exchange might use 200 to 500 tokens. But real-world conversations are rarely that simple, and here is the catch that surprises most developers: because every previous message in a conversation must be sent back to the model as context for each new turn, the token cost of an ongoing conversation grows exponentially, not linearly. Turn 1 might cost 500 tokens. By turn 10, with the full history appended, a single exchange could cost 5,000. By turn 50, you could be sending 25,000 tokens just to ask a follow-up question and paying for all of them as input every single time. This is why conversation length is the single biggest hidden cost driver in production chatbots and why prompt caching and context management are not optional for anything that scales.

Context windows, the maximum number of tokens a model can process in one request, also affect your bill. Larger contexts let you send more data per request, but every token you send counts toward your input cost. A 1-million-token context window is powerful, but filling it at $5 per million input tokens costs $5 per request before the model generates a single word.

Providers also differ in their billing models. Most, including OpenAI, Anthropic, and Google, operate on a post-pay basis: you use the API and are billed at the end of the month. Others, like OpenRouter and several Chinese providers, use a pre-pay model where you purchase credits upfront and consume them as you go. Muse operates on a pure pay-as-you-go model with no upfront commitment. Understanding your provider’s billing model matters for cash flow planning and avoiding unexpected service interruptions when credits run dry.

Master Pricing Table: Every Major Model Compared

The table below covers current-generation flagship and notable models from every major provider.

All prices are per million tokens and were verified as of September 2026. Where a provider offers prompt caching, the cached input price is listed alongside the standard rate. The Ratio column shows output price as a multiple of input price; a wider spread means you should optimize your prompts more aggressively.

Anthropic cache prices shown are read prices, which vary by model: 0.1x the base input rate for most models, 0.05x on Claude Opus 5.5, and 0.025x on Claude Fable 5.1. Cache writes cost 1.25x (5-minute) or 2x (1-hour) the base input rate. GPT-6 and Claude prices reflect standard short-context tiers; OpenAI long-context rates roughly double. MiniMax M3 uses tiered pricing by input length. HS = highspeed; MiniMax also offers a Priority tier at 1.5x standard pricing. Nemotron 3 Ultra pricing shown is via OpenRouter; see the provider section for alternatives. DeepSeek rates shown are off-peak; peak hours (weekday mornings UTC) cost double. Muse Spark 1.3 Contributor tier pricing requires permission for Meta to train on your prompts and completions. All prices verified as of September 2026.

Several things jump out immediately. The price spread between the most expensive flagship (GPT-6 Astra at $50/MTok output) and the cheapest capable model (Agnes 3.0 Flash at $0.15/MTok output, currently free) is over 300x. Chinese providers consistently offer the narrowest input-to-output price ratios; MiMo charges only about 2x more for output than input, compared to 5x to 6x for Western providers. And prompt caching, which we cover in detail later, can slash input costs by 75% to 99% depending on the provider.

OpenAI API Pricing: The GPT-6 Family

OpenAI’s current-generation lineup is the GPT-6 series, launched in September 2026: Astra (flagship), Sol (balanced), and Luna (cost-optimized), joined later that month by GPT-6.1 Sol as a mid-generation upgrade. Pricing is available on OpenAI’s official API pricing page. It follows the three-tier structure OpenAI has standardized across recent generations, but the price ladder is dramatic: Astra is 5x Sol and 100x Luna, so routing the right request to the right tier matters more than ever. OpenAI says GPT-6.1 Sol nearly matches Astra’s intelligence on agentic coding, computer use, and professional work at one fifth of Astra’s standard token prices.

GPT-6 Astra

Astra is the frontier model, the one you reach for when accuracy matters more than budget. At $10 per million input tokens and $50 per million output tokens — doubling to $20/$75 for long-context requests — it sits at the premium end of the market, comparable to Claude Fable 5.1. It supports six reasoning levels, a 1-million-token context window, and up to 128,000 output tokens per request. Tools include function calling, web search, file search, and computer use. Astra also offers a Fast Mode at 2x pricing for up to 2.5x speed.

Cached input tokens cost $1 per million, a 90% discount from the standard rate, and cache writes cost $12.50 per million. Like all GPT-6 models, caching is automatic: any prompt prefix that has been processed recently is reused without you writing any code. OpenAI operates on a post-pay billing model: you are invoiced at the end of each billing period for what you used.

GPT-6.1 Sol

GPT-6.1 Sol, released in late September 2026 as an upgrade to GPT-6 Sol, is the balanced tier and the default workhorse. Its standard API prices are unchanged — $2 per million input and $10 per million output — but cached input now costs just $0.10 per million, half of GPT-6 Sol’s cached rate and 95% below standard input. It matches Astra’s 1-million-token context window, 128K max output, and full reasoning and tool support at one fifth the price, and OpenAI says it approaches Astra’s intelligence on agentic coding, computer use, and professional work. An Ultrafast variant with up to 8x faster token generation is rolling out in Codex.

GPT-6 Luna

Luna is the cost-sensitive tier at $0.10 per million input and $0.50 per million output, with cached input at $0.01 and cache writes at $0.125. It shares the same context window, output limits, and tool support as its siblings. For high-volume applications like classification, data extraction, and straightforward chatbots, Luna delivers GPT-6-level tool compatibility at a fraction of the price — it costs exactly one hundredth of Astra on every rate.

Key takeaway: The GPT-6 family caches automatically. Astra and Luna cache at 10% of standard input, while GPT-6.1 Sol goes further at just 5% ($0.10 per million). If your application sends the same system prompt or context prefix repeatedly, you can expect roughly a 90% reduction on input costs for those cached portions, but only if the model and conversation prefix remain unchanged. Switching models, even within the same family, resets the cache.

Anthropic API Pricing: Claude Opus, Sonnet, Haiku and Fable

Anthropic’s current lineup spans four tiers: Claude Fable 5.1 (maximum reasoning), Claude Opus 5.5 (long-running agentic work), Claude Sonnet 5.5 (best speed-to-intelligence balance), and Claude Haiku 4.5 (fastest and cheapest). Each targets a different point on the quality-speed-cost curve. Full pricing details are on Anthropic’s official pricing page. Anthropic uses post-pay billing like OpenAI but also offers a pre-pay credit option for teams that prefer budget caps.

Claude Opus 5.5

Opus 5.5 is Anthropic’s flagship agentic model, priced at $4 per million input and $20 per million output tokens, with cache reads at $0.20 (a 95% discount) and cache writes at $5 (5-minute) or $8 (1-hour). It features adaptive thinking and a 1-million-token context window, and generates output more than 30% faster than its predecessor. A Fast Mode is available at $8 input and $40 output per million tokens, offering up to 2.5x speed for latency-sensitive workloads. For teams that need US-only inference, pricing is 1.1x standard for input and output tokens.

Claude Fable 5.1

Fable 5.1 is Anthropic’s maximum-reasoning model, priced at $10 per million input and $50 per million output tokens. Cache reads cost $0.25 per million (a 97.5% discount), with writes at $12.50 (5-minute) or $20 (1-hour). It supports a 1-million-token context window. Anthropic also offers the limited-availability Claude Mythos 5.1 at the same pricing tier. Fable 5.1 is the pick when you need absolute maximum reasoning depth on the hardest problems, at a premium price and relatively slow output speed. On the Artificial Analysis Intelligence Index (v4.3.2), Fable 5.1 scores 53, behind Claude Opus 5.5 at 58, which now leads the index.

Claude Sonnet 5.5

Sonnet 5.5 is Anthropic’s current mid-tier model, priced at $2 per million input and $10 per million output, with cache reads at $0.20 (90% off) and cache writes at $2.50 (5-minute) or $4 (1-hour). Its predecessor, Sonnet 5, carries the same $2/$10 rate: Anthropic originally framed that as introductory pricing through August 31, 2026, with a planned increase to $3/$15, but in August 2026 the company made it permanent and cancelled the increase. Sonnet 5.5 is notably fast (139 t/s) and is a strong default for coding and analysis, representing Anthropic’s best balance of cost and capability. One caveat: Sonnet 5’s tokenizer produces roughly 30% more tokens for the same text than its predecessor, so validate token counts against your actual workloads. Both are available through the API, Claude Code, and the Claude Platform. Claude Code can also be accessed through a monthly subscription plan rather than per-token billing, which is worth evaluating for individual developers who code heavily.

Claude Haiku 4.5

Haiku 4.5 is Anthropic’s fastest and cheapest model at $1 per million input and $5 per million output. It is designed for high-throughput, cost-sensitive applications where speed is paramount. Anthropic has since replaced it with Claude Haiku 5.5, which costs about 75% less on average and roughly doubles Haiku 4.5’s scores on several benchmarks.

Anthropic Prompt Caching: How It Works

Anthropic’s caching model is fundamentally different from OpenAI’s. It is manual, not automatic. You explicitly mark which parts of your prompt should be cached, and you pay for the duration you want the cache to persist, typically 5 minutes, refreshed each time the cache is accessed. Cache writes are priced at a multiple of the base input rate: a 5-minute TTL costs 1.25x, and a 1-hour TTL costs 2x. The cache refreshes for free each time it is used. Cache-read discounts now vary by model: the standard rate is 0.1x the base input price, but Claude Opus 5.5 reads cost just 0.05x ($0.20 per million), and Claude Fable 5.1 and Mythos 5.1 reads cost 0.025x ($0.25 per million).

This means Anthropic caching rewards thoughtful architecture: if you design your prompts to front-load a large, reusable system context and keep read patterns consistent, your effective input cost for a Sonnet 5.5 request can drop from $2 per million to $0.20. But if your cache misses frequently, because you change system prompts, modify the cached prefix, or let the TTL expire, you pay the write surcharge repeatedly and lose the discount.

Batch Processing

All Anthropic models support batch API processing with a 50% discount on both input and output tokens. Results are returned asynchronously within 24 hours. For non-real-time workloads like evaluation runs, data extraction pipelines, and content generation at scale, batching is the single largest cost lever available.

Google Gemini API Pricing: Pro, Flash, and Flash-Lite

Google offers Gemini models through a free tier (rate-limited, with Google’s standard data usage policy) and a paid tier with per-token pricing. Current rates are listed on Google’s Gemini API pricing page. The current-generation lineup spans three tiers. Google bills on a post-pay model with a monthly invoicing cycle.

Gemini 3.1 Pro

Gemini 3.1 Pro costs $2 per million input tokens and $12 per million output tokens for prompts up to 200,000 tokens. Beyond 200K tokens, input doubles to $4 per million and output rises to $18 per million. This tiered structure means you pay a premium for long-context reasoning, which matters if you routinely send entire codebases or document sets. Context caching costs $0.20 per million tokens for storage, with cached reads at a 90% discount.

Gemini 3.8 Flash

Gemini 3.8 Flash is Google’s most intelligent Flash model, built for long-horizon software engineering, autonomous agents, and complex enterprise workflows. It launched at an introductory price of $0.75 per million input and $3.75 per million output, with cached input at $0.075, holding until January 1, 2027, after which standard pricing of $1.50/$7.50 applies. It supports a 1-million-token context window, 64K max output tokens, tunable thinking levels, and Google’s full suite of built-in tools. At the introductory rate it is roughly half the price of the Gemini 3.5 Flash it replaces, while scoring higher on most benchmarks.

Gemini 3.5 Flash-Lite

Gemini 3.5 Flash-Lite is Google’s budget option at $0.30 per million input and $2.50 per million output, with cached input at $0.03. It replaces the earlier 3.1 Flash-Lite and is available through the free tier with rate limits, making it ideal for high-volume, simple tasks.

Google Caching: Automatic and Manual Options

Google supports both automatic and manual caching. For most users, automatic context caching kicks in when prompts exceed 32,768 tokens, with a 75% discount on cached reads. Google also offers a manual caching API where you can configure the TTL and pay a storage rate of $1 per million tokens per hour. Manual caches refresh on access, and unused caches expire according to the TTL you set.

Google also integrates API access with its subscription products. Google Antigravity, available through a Gemini subscription, provides a pathway to use Gemini models without direct per-token billing, though with usage limits.

Grounding and Search

If you use Google Search grounding with Gemini models, the first 5,000 search queries per month are free across the Gemini 3 family. Beyond that, it costs $14 per 1,000 search queries. Google Maps grounding follows the same structure.

DeepSeek, Kimi, MiMo and MiniMax: Chinese AI API Costs

Chinese AI labs have reshaped the global API pricing landscape. Their models consistently undercut Western providers by 10x to 100x on output tokens, largely due to differences in electricity costs, caching technology, and infrastructure efficiency. Most Chinese providers use a pre-pay credits model: you top up your account and consume credits as you go, which avoids surprises but requires monitoring your balance.

DeepSeek

DeepSeek V4.1 Flash is the current workhorse, priced at $0.15 per million input and $0.60 per million output off-peak, with cache-hit input at just $0.003 per million, a 98% discount. DeepSeek V4 Pro costs $0.66 input and $1.98 output off-peak, with cache hits at $0.022. Both are billed on a peak/off-peak structure: peak hours (01:00–04:00 and 06:00–10:00 UTC, Monday to Friday) cost exactly double, so scheduling flexible workloads off-peak can halve your bill. Since September 14, 2026, all deepseek-v4-pro requests have been routed to V4.1 Flash and billed at Flash rates until V4.1-Pro launches. Both models support a 1-million-token context window and use automatic prefix caching.

DeepSeek’s models are particularly strong at coding and mathematics. V4.1 Flash also uses a dramatically compressed KV cache — a quarter of the HBM and an eighth of the SSD storage of the previous generation — which is what allows DeepSeek to pass on lower prices.

Kimi (Moonshot AI)

Kimi K3 is Moonshot’s premium flagship, priced at $3 per million input (cache miss) and $15 per million output, with cache-hit input at $0.30 and a 1.05-million-token context window priced flat with no length tiering. Below it sit the open-weight workhorses: Kimi K2.6 costs $0.95 per million input and $4 per million output, with cached input at $0.16, and K2.5 is cheaper still at $0.60 input and $3 output, with cached input at $0.10. Their 262K context windows are narrower than Western flagships, but automatic caching discounts of 83% or more make them competitive for workloads with high cache-hit rates.

Kimi K2.7 Code is a dedicated coding variant. It costs $0.95 per million input (cache miss) and $0.19 for cache hits, with $4 per million output. A highspeed variant (K2.7 Code-highspeed) doubles those prices to $1.90 cache-miss input, $0.38 cache-hit, and $8 output for reduced latency. All Kimi models use automatic caching. Kimi also charges $0.004 per invocation for web search, billed independently of token consumption, and offers a membership plan that bundles API access with coding-focused features.

MiMo (Xiaomi)

MiMo V2.6 Pro and MiMo V2.6 Flash are Xiaomi’s current-generation models, and they keep the same aggressive pricing as the V2.5 series they replace. MiMo V2.6 Pro costs $0.435 per million input and $0.87 per million output, with an extraordinary cached input price of $0.0036 per million, a 99.2% discount. MiMo V2.6 Flash is cheaper still at $0.14 input and $0.28 output, with cached input at $0.0028 (98% discount). Cache writes are free for a limited time. Xiaomi also offers MiMo V2.6 Pro in an UltraSpeed mode at up to 20x the output speed, priced at $4.35 input and $8.70 output per million tokens. Both models feature a 1-million-token context window, use automatic caching, and are available through the MiMo API Platform and OpenRouter. The older V2.5 models are being deprecated.

MiniMax

MiniMax offers two model generations. The newer MiniMax M3 costs $0.30 per million input and $1.20 per million output for prompts up to 512,000 tokens, doubling to $0.60 input and $2.40 output beyond that threshold. Cached reads are $0.06 per million, an 80% discount. MiniMax M3 also offers a Priority tier at 1.5x standard pricing, which provides faster response times and improved request reliability through priority admission scheduling. The previous-generation MiniMax M2.7 costs $0.30 per million input and $1.20 per million output with a 205K context window. Its highspeed variant (M2.7-highspeed) doubles the price to $0.60 input and $2.40 output for reduced latency. MiniMax M2.7 supports both automatic and manual caching. Automatic caching activates for repeated context prefixes without any configuration changes. Manual caching allows you to explicitly create caches with write costs of $0.375 per million tokens and reads at $0.06. This hybrid approach gives power users finer control while the automatic mode works for everyone else. MiniMax M3, by contrast, uses automatic caching only, with read costs of $0.06 per million and no write surcharge.

Why are Chinese LLMs cheaper? A combination of factors: lower electricity costs in China, aggressive cache-hit technology, and an open-weight ecosystem that enables third-party providers like DeepInfra, Fireworks, and Parasail to host the same models at competing prices. For a deeper analysis, read our breakdown of why Chinese AI models are cheaper than OpenAI and other Western providers.

Mid-Tier Contenders: Grok, Muse, GLM, Qwen, StepFun, Agnes and Nemotron

Beyond the big three Western providers and the Chinese price leaders, a group of mid-tier models offers competitive pricing with distinct strengths. These models sit in the $1 to $2 per million input range, making them viable alternatives to GPT-6 Luna or Claude Haiku 4.5 for specific workloads.

Grok (xAI)

xAI’s current flagship is Grok 4.7, priced at $2 per million input and $6 per million output with a 500K context window and cached input at $0.50. A fast variant, Grok 4.7 Fast, is served on faster infrastructure at twice the token rates but is available only inside Cursor and Grok Build. Requests of 200K prompt tokens or more are billed at double the standard rates. Grok uses automatic caching.

Muse Spark 1.3

Muse Spark 1.3 costs $1.25 per million input tokens and $4.25 per million output, with cached input at $0.15. Muse also offers a Contributor tier at a fraction of that price — $0.10 input, $0.002 cached, and $0.20 output — in exchange for permission to use your prompts and completions to train future Meta models. It supports a 1-million-token context window with up to 256,000 output tokens per request. Web search grounding costs $2.50 per 1,000 search queries, and Muse operates on a pure pay-as-you-go model with no upfront commitment. The newer Muse Wonder models move sharply upmarket, launching at $4 and $20 per million tokens, level with Claude Opus 5.5.

GLM-5.3 (Zhipu AI)

GLM-5.3 from Zhipu AI is the flagship, at $1.40 per million input tokens and $4.40 per million output with cached input at $0.26 — the same rate card as GLM-5.2. Its cheap sibling, GLM-5.3 Flash, costs just $0.15 input and $0.50 output with cache hits at $0.03, and unlike the flagship it accepts image inputs. A mid-tier GLM-5.3 FlashX sits between them at $0.37 input and $1.25 output. Cache storage is free for a limited time on all three, and they support up to 131,072 output tokens per request with a 1-million-token context window.

Qwen (Alibaba)

Qwen 3.8 Max is Alibaba’s flagship, priced at $2.00 per million input and $6.00 per million output, with implicit cache reads at $0.25 and a 1-million-token context window. Its cheap sibling, Qwen 3.8 Flash, costs just $0.14 input and $0.42 output, flat across its full 1-million-token context, making it one of the most affordable capable models available. Alibaba also offers Qwen 3.8 Max Prime, a fast mode at $3.30/$9.90, and retains Qwen 3.7 Flash for very short requests. The Qwen family is available through Alibaba’s QwenCloud and Model Studio APIs, and through OpenRouter and other third-party providers.

Step 5 Preview (StepFun)

Step 5 Preview is StepFun’s flagship agentic and reasoning model, built on a sparse mixture-of-experts architecture with 600B total parameters and 27B active per token. It costs $1.00 per million input (cache hits $0.05) and $2.70 per million output, with a 1-million-token context window, up to 64K output tokens per request, and native text, image, and video input. Output pricing covers both the reasoning trace and the final answer, so the reasoning effort setting acts as a direct cost dial.

Agnes 3.0 Flash (Agnes AI)

Agnes 3.0 Flash is a text model from Singapore-based Agnes AI. Its list price is $0.05 per million input tokens and $0.15 per million output, with cached input at $0.005 — and it is currently free through the Agnes AI API while a promotional period runs. It carries a 512K-token context window, generates output at roughly 235 tokens per second, and scores 36 on the Artificial Analysis Intelligence Index v4.3, level with DeepSeek V4 Pro at a fraction of the price. For the full breakdown, see our article on how Agnes 3.0 Flash matches DeepSeek V4 Pro for free.

Nemotron 3 Ultra (NVIDIA)

NVIDIA’s Nemotron 3 Ultra (550B parameters, 55B active) does not have a direct per-token API plan from NVIDIA itself but is widely available through third-party inference providers. OpenRouter offers it at $0.50 per million input, $0.10 cached input, and $2.20 per million output. NVIDIA NIM provides it at $0.50 input, $0.15 cached, and $2.50 output, with a free developer plan available. Together AI charges $0.60 for input, $0.20 for cache, and $3.60 for output. All three providers include free cache storage. For self-hosted deployments, NVIDIA charges approximately $4,500 per GPU per year. On the speed front, Blackbox AI hosts Nemotron 3 Ultra at 460 t/s, Nebius at 319 t/s, and CoreWeave at 229 t/s, making it one of the fastest-served open-weight models when hosted on optimized infrastructure.

OpenRouter and Third-Party Inference Providers

Not all API access goes through the model developer’s own servers. A growing ecosystem of third-party providers hosts the same open-weight models (and sometimes proprietary ones) with different speed, pricing, and reliability characteristics.

OpenRouter

OpenRouter is a unified API gateway that gives you access to over 300 models from dozens of providers through a single endpoint. Instead of managing separate API keys, billing accounts, and rate limits for each provider, you add credits to OpenRouter and route requests to whichever model you choose.

As of mid-2026, OpenRouter’s catalog rates match provider-published pricing for most major closed-source models. Claude Fable 5.1, Opus 5.5, Sonnet 5.5, Haiku 4.5, GPT-6 models, and Gemini models all pass through at cost with no markup. For open-weight models like DeepSeek, Kimi, Qwen, and GLM, OpenRouter offers access through multiple competing inference hosts, each with its own price and speed profile. This is where OpenRouter’s value proposition is strongest: you can choose between providers like Fireworks, DeepInfra, Together AI, and Parasail for the same model, trading off cost against speed. OpenRouter adds approximately 50ms to 150ms of routing overhead per request compared to calling the underlying provider directly. It uses a prepaid credits model.

When OpenRouter makes sense: if you need access to many different models and the overhead of managing multiple provider accounts outweighs the per-token savings; if you are prototyping and want to switch between models without rewriting integration code; or if you want to compare inference providers for an open-weight model without opening multiple accounts.

Dedicated Inference Providers

For open-weight models, dedicated inference providers consistently outperform first-party APIs on speed. Fireworks AI, Together AI, DeepInfra, Groq, SambaNova, and Cerebras each optimize their infrastructure for specific model architectures, often delivering 3x to 10x higher throughput than the model developer’s own API. The trade-off is that these providers typically only host open-weight models, not proprietary ones like GPT or Claude.

Key third-party hosts and their specialties:

• Fireworks AI: Consistently among the fastest for Kimi K2.5 (330 t/s), DeepSeek V4 Pro (167 t/s), and Llama models. Strong custom kernel optimizations.
• DeepInfra: Competitive pricing with private deployment options. Fastest for MiMo V2.5 Pro at 81 t/s.
• Together AI: Broad model catalog with token-bucket rate limiting. Strong for MiniMax M2.7 (207 t/s) and Kimi K2.7 Code (237 t/s).
• Groq: Fastest overall for Llama models (330+ t/s) with sub-200ms TTFT. Limited to specific architectures due to custom hardware.
• SambaNova: Exceptional speed on MiniMax M2.7 (443 t/s). Uses custom RDU architecture.
• Cerebras: Plans to host frontier-class models at up to 750 t/s. Wafer-scale hardware enables extreme throughput.
• Crusoe: Fastest for Kimi K2.7 Code (432 t/s) using NVFP4 quantization. Specializes in low-precision, high-throughput inference.

When choosing a third-party provider, check the quantization level. Many providers use FP8 or NVFP4 precision, which reduces quality slightly in exchange for much higher speed. If your workload is sensitive to precision loss, stick with FP16 or BF16 providers. If throughput is paramount, FP8 and NVFP4 can deliver dramatic speed gains at minimal quality cost for most tasks.

Prompt Caching: The Hidden Cost Multiplier

Prompt caching is the single most important cost optimization that most developers overlook. When you send the same prompt prefix, a system message, a large document, or a set of few-shot examples, the provider can reuse its internal computation rather than reprocessing those tokens from scratch. The discounts are dramatic, but the mechanics differ significantly across providers.

Automatic vs. Manual Caching

Cache discounts vary by provider and model. Anthropic and MiniMax M2.7 use manual caching with write costs; all others shown here use automatic caching.

What Breaks Your Cache

Understanding what invalidates the cache is critical. The most overlooked rule: changing the model resets the cache entirely. If you are building a conversation that switches from GPT-6.1 Sol to GPT-6 Luna midstream, perhaps to save money on simpler turns, every token must be reprocessed from scratch. Similarly, modifying any part of the cached prefix, even a single character, triggers a full cache miss.

Cache hit rates also vary with timing. Messages sent within a short window of each other have a much higher probability of hitting the cache. Function calls and their responses, which often contain structured, repeated data, are particularly cache-friendly. Conversely, long gaps between requests, longer than the provider’s TTL, mean the cache has expired and you start fresh.

Cache Hit Rate Variability

Even for the same model, cache hit rates can differ depending on which provider is hosting it. For example, Kimi K2.6 hosted directly by Moonshot may have a different cache hit profile than K2.6 hosted through OpenRouter or a third-party provider like DeepInfra. This is because each provider manages its own caching infrastructure, TTL policies, and cache eviction strategies.

Anthropic’s Unique Manual Caching Model

Anthropic’s approach is the most hands-on. You explicitly create a cache with a specified duration (5 minutes or 1 hour) and pay a write premium of 1.25x or 2x the base input rate. The trade-off is that cache reads are among the cheapest in the industry, falling as low as 2.5% of the input price on Fable 5.1. This model rewards careful prompt architecture: if you structure your application so that a large, detailed system prompt is reused across many requests, the write surcharge is amortized quickly, and each subsequent call is dramatically cheaper.

Google’s manual caching works similarly but charges for storage rather than writes: $1 per million tokens per hour for stored caches. This makes it more cost-effective for very large contexts that are reused over extended periods. MiniMax M2.7 also uses manual caching, charging $0.375 per million tokens for cache writes and $0.06 for reads.

The distinction between automatic and manual caching is not just academic; it fundamentally changes how you architect your application. With automatic caching (OpenAI, DeepSeek, Kimi, MiMo, MiniMax M3), you get the discount for free but have no control over when the cache expires. With manual caching (Anthropic, Google, MiniMax M2.7), you pay for control, and that control can save you substantially if used correctly.

Tokens Per Second: Why Speed Changes the Real Cost

Cost per token is only half the equation. The other half is how fast those tokens arrive, because speed directly affects user experience, throughput capacity, and the practical economics of your application. A model that costs half as much per token but takes four times as long to respond may cost you more in engineering complexity, timeout handling, and user churn than the per-token savings justify.

The table below shows output tokens per second for every current-generation model, measured through each provider’s own API by Artificial Analysis as of September 2026, sorted fastest to slowest.

Source: Artificial Analysis, accessed September 2026. Speeds measure output tokens per second through each model developer’s own API. No published speed data is available for Agnes 3.0 Flash at the time of writing.

Several patterns stand out. First, the cheapest models are often the fastest. Gemini 3.5 Flash-Lite (313 t/s), Gemini 3.8 Flash (239 t/s), DeepSeek V4.1 Flash (209 t/s), and GPT-6 Luna (148 t/s) all top the table while costing a fraction of the flagships, which is the opposite of the intuition that speed costs more.

Second, the same open-weight model is often several times faster on a dedicated host such as Fireworks, SambaNova, or Crusoe than on the developer’s own API, so your choice of inference provider can matter as much as your choice of model. Quantization is a related lever: providers using FP8 or NVFP4 (4-bit) precision serve models several times faster with minimal quality loss for most tasks. If your workload needs full precision, check the quantization level first.

Third, the fastest models are not the smartest. Within every family, the flagship reasoning models are the slowest: GPT-6 Astra at 56 t/s, Claude Fable 5.1 at 69 t/s, and Claude Opus 5.5 at 92 t/s, against 138 t/s for Claude Sonnet 5.5 and 148 t/s for GPT-6 Luna. Route high-volume, straightforward work to the fast, cheap models and reserve the slow flagships for genuinely hard problems.

Hidden Costs That Inflate Your API Bill

Headline per-token prices tell an incomplete story. Several less visible factors can add 10% to 50% to your actual costs.

Reasoning Tokens

When you use reasoning models at high effort levels, the model generates internal chain-of-thought tokens before producing its visible response. These reasoning tokens are billed as output tokens, at the full output rate, even though you never see them. A model that produces 5,000 reasoning tokens and 500 visible tokens costs you for 5,500 output tokens. This is why the “max” reasoning setting on GPT-6 Astra can produce dramatically higher bills than “low” or “none,” even when the final answer looks identical.

Tokenizer Differences

Not all tokens are created equal. Each provider uses a different tokenizer, which means the same text can produce a different number of tokens depending on which model processes it. A 1,000-word document that costs 1,300 tokens on OpenAI might cost 1,450 tokens on Anthropic or 1,200 on Google. These differences are typically 5% to 15%, but they compound at scale.

Cache Write Costs

Anthropic’s cache-write premium (1.25x the base input rate for a 5-minute TTL, 2x for 1 hour), Google’s storage fees, and MiniMax M2.7’s $0.375 write cost mean that even caching, which saves money overall, carries an upfront cost. If your application has a low cache hit rate because prompts vary frequently, you may pay the write premium without recouping it through discounted reads.

Rate Limits and Retry Costs

Every provider imposes rate limits: maximum requests per minute, tokens per minute, or both. Hitting these limits means failed requests, which you either retry (doubling your cost for that request) or queue (adding latency). Higher-tier models often have stricter rate limits than budget models, so your effective throughput may be lower than expected.

Cold Starts and Infrastructure Overhead

When a provider has not served a particular model recently, the first request incurs a cold start delay, the time needed to load the model into GPU memory. While most major providers have minimized this through always-warm infrastructure, smaller providers and newly released models may still experience cold starts. These do not directly cost money but add latency that can affect user experience.

Multi-Modal Input Costs

Images, audio, and video inputs are tokenized differently than text and often at higher effective rates. Gemini 3.1 Pro, for example, charges the text rate for image inputs but a higher rate for audio. Gemini 3.1 Flash Image charges 1,120 tokens per input image regardless of resolution. If your application processes images alongside text, these costs can quickly dominate your bill.

Token Efficiency: The Model That Costs More Per Token Can Cost Less Overall

A model’s per-token price tells you how much each individual token costs, but it does not tell you how many tokens the model needs to complete a given task. Some models are dramatically more token-efficient than others: they produce shorter, more concise responses that reach the same quality with fewer output tokens, and they may also require fewer input tokens through more efficient reasoning.

This is why comparing models solely on per-token pricing can be misleading. For example, Claude Opus 5.5 generates output more than 30% faster than its predecessor while using fewer tokens per task. GPT-6.1 Sol delivers frontier-level results at a fraction of Astra’s price with fewer output tokens per task. A model that costs 2x more per token but uses 3x fewer tokens to complete your specific workload is actually cheaper overall. Token efficiency varies by task type, so the only reliable way to compare total cost is to run your actual workload through both models and measure tokens consumed, not just look at the price sheet.

Output Quality and Task Suitability

Not all models produce equal-quality output, even when they are in the same price tier. A cheaper model that produces more errors, hallucinations, or unusable responses will cost you more in retries, manual review, and lost user trust than the per-token savings justify. For straightforward classification or extraction, a budget model like MiMo V2.6 Flash, Qwen 3.8 Flash, or GLM-5.3 Flash may be perfectly adequate. For complex reasoning, code generation, or customer-facing content, the additional cost of Claude Opus 5.5 or GPT-6 Astra often pays for itself in accuracy alone. Always test on your specific task before committing to a model based on price.

How to Estimate Your Monthly API Spend

Use this formula to budget before committing to a provider:

Monthly Cost = (Daily Requests x Avg Input Tokens x Input Price/MTok / 1,000,000) + (Daily Requests x Avg Output Tokens x Output Price/MTok / 1,000,000) x 30

Example 1: Customer Support Chatbot

500 conversations per day, 800 input tokens on average (system prompt + user message), and 400 output tokens on average. Using Claude Sonnet 5.5 ($2/$10):

• Input: 500 x 800 = 400,000 tokens/day = $0.80/day
• Output: 500 x 400 = 200,000 tokens/day = $2.00/day
• Monthly: ($0.80 + $2.00) x 30 = $84/month

With a 60% cache hit rate on the system prompt, input costs drop to approximately $0.32/day, bringing the monthly total to roughly $70/month.

Example 2: High-Volume Document Classification

50,000 documents per day, 200 input tokens on average, 50 output tokens on average. Using GPT-6 Luna ($0.10/$0.50):

• Input: 50,000 x 200 = 10,000,000 tokens/day = $1.00/day
• Output: 50,000 x 50 = 2,500,000 tokens/day = $1.25/day
• Monthly: ($1.00 + $1.25) x 30 = $67.50/month

At these rates, budget and frontier models live in entirely different cost universes. Running the same workload on the flagship GPT-6 Astra ($10/$50) would cost roughly $4,500/month, a 67x difference for the identical number of requests.

Example 3: Coding Assistant with Reasoning

200 code-generation requests per day, 3,000 input tokens on average (codebase context), and 1,500 output tokens on average (including reasoning tokens). Using GPT-6.1 Sol ($2/$10):

• Input: 200 x 3,000 = 600,000 tokens/day = $1.20/day
• Output: 200 x 1,500 = 300,000 tokens/day = $3.00/day
• Monthly: ($1.20 + $3.00) x 30 = $126/month

Note: If reasoning tokens average 1,000 of the 1,500 output tokens, roughly $60 of the monthly cost is spent on tokens the user never sees. Using the “low” reasoning setting instead of “high” could cut output tokens, and therefore cost, by 30% to 50% with minimal quality impact for many tasks.

Frequently Asked Questions

Which LLM API is the cheapest in 2026?

Agnes 3.0 Flash has the lowest list price of any capable model, at $0.05 input and $0.15 output per million tokens, and it is currently free through the Agnes AI API. Among paid options, MiMo V2.6 Flash ($0.14/$0.28) and Qwen 3.8 Flash ($0.14/$0.42) lead, with GLM-5.3 Flash ($0.15/$0.50, with vision) and DeepSeek V4.1 Flash ($0.15/$0.60 off-peak) close behind. Google’s free Gemini tier and NVIDIA’s NIM developer plan are also worth trying.

How much does it cost to use the OpenAI API vs. Claude API?

At the flagship tier, GPT-6 Astra ($10/$50) and Claude Fable 5.1 ($10/$50) are priced identically. The better value at the top end is Claude Opus 5.5 at $4/$20, which Anthropic says performs at the level of Fable 5.1 on most work for 60% less. At the mid-range, GPT-6.1 Sol ($2/$10) and Claude Sonnet 5.5 ($2/$10) match on both rates. At the budget tier, GPT-6 Luna ($0.10/$0.50) dramatically undercuts Claude Haiku 4.5 ($1/$5), coming in 10x cheaper on both input and output.

Is DeepSeek really cheaper than OpenAI?

Yes, though the gap has narrowed. DeepSeek V4.1 Flash ($0.15/$0.60 off-peak) costs roughly 13x less than GPT-6.1 Sol ($2/$10) on input and 17x less on output, and about 67x and 83x less than the flagship GPT-6 Astra ($10/$50). Even the higher-tier V4 Pro ($0.66/$1.98) undercuts GPT-6.1 Sol on both directions. The quality gap has narrowed significantly; V4 Pro scores competitively on coding benchmarks, but for tasks requiring nuanced reasoning or creative writing, the more expensive models still have an edge.

Does prompt caching work if I change models mid-conversation?

No. Changing the model, even within the same provider or the same model family, resets the cache entirely. Every token must be reprocessed from scratch. If your application switches between models, factor this into your cost calculations and consider whether the savings from using a cheaper model on some turns outweigh the lost cache efficiency.

Are there free LLM APIs?

Yes, but with limitations. Google offers free tiers for most Gemini models through AI Studio, with rate limits and a data usage policy that allows Google to use your inputs for product improvement. OpenRouter provides access to several free models, including DeepSeek R1 and Llama 3.3 70B, at zero cost. NVIDIA NIM API offers a free developer plan for Nemotron 3. These are suitable for prototyping and learning, but production applications typically need paid tiers for reliability and data privacy.

How do I get started with an LLM API?

Each provider requires an account and API key. OpenAI, Anthropic, and Google all offer developer dashboards where you can generate keys and monitor usage. Most providers offer pre-pay or post-pay options depending on your preference. For a step-by-step guide with code snippets for each major provider, see our forthcoming article on getting started with LLM APIs.

What is the difference between highspeed and standard variants?

Several providers, notably MiniMax and Kimi, offer highspeed variants of their models at roughly double the standard price. These variants use the same underlying model but are served with lower latency through prioritized infrastructure or optimized inference paths. MiniMax goes a step further with its Priority tier (1.5x standard pricing), which provides priority admission scheduling for faster response times and improved reliability without the full cost of the highspeed variant. The standard, highspeed, and priority tiers all produce identical-quality responses; you are paying purely for speed.

Should I use the first-party API or a third-party inference provider?

For proprietary models (GPT, Claude, Gemini), you have no choice: only the developer’s API is available. For open-weight models (Kimi, DeepSeek, MiMo, MiniMax, Qwen, Nemotron), third-party providers like Fireworks, Together AI, DeepInfra, and SambaNova often deliver significantly higher throughput at competitive or lower prices. The trade-off is that third-party providers may use lower-precision quantization (FP8, NVFP4) that slightly reduces quality, and their uptime and reliability guarantees may differ from the model developer’s own SLA. For production workloads, test both first-party and top third-party options on your specific task before committing.

Conclusion

The LLM API pricing landscape in mid-2026 offers more choice and a wider cost spread than ever before. The cheapest capable models, led by Agnes 3.0 Flash, cost a tiny fraction of the flagships (GPT-6 Astra and Claude Fable 5.1, at $50 per million output tokens). The right choice depends entirely on your workload: classification and extraction can run on budget models at pennies per day, while complex agentic coding and reasoning justify the premium tier.

Four principles should guide your decision-making. First, prompt caching is the single largest cost lever available: a 90% discount on input tokens transforms the economics of any application with a consistent system prompt, but you must understand each provider’s caching model (automatic vs. manual) to capture those savings. Second, the cheapest model is rarely the best value: a model that costs 10x less per token but uses 3x more tokens to complete a task or produces 5x more errors requiring retries may cost you more in total spend, user frustration, and engineering time than the savings justify. Token efficiency and output quality are just as important as per-token pricing. Third, tokens-per-second matters as much as cost-per-token: GPT-6 Luna at 154 t/s and $0.10/$0.50 will often complete tasks faster and cheaper than a slower model with a lower sticker price. Fourth, your inference provider can matter as much as your model choice: the same open-weight model can run 3x to 9x faster on a dedicated inference provider than on the developer’s own API, transforming both the cost and user experience of your application.

This article will be updated as new models launch and prices change. For deeper dives into specific topics, see our companion articles on why Chinese LLM APIs cost less, the LLM market share landscape, and our forthcoming guides on how to choose between models across providers and code snippets for getting started with each API.