LLM API Pricing 2026: OpenAI, Gemini, Claude & Grok

By late 2025, the landscape of large language model (LLM) APIs has grown intensely competitive and complex, with multiple providers offering a spectrum of model capabilities and pricing options. This report provides a detailed comparison of the API pricing for all major LLM models from OpenAI, Google’s Gemini, Anthropic’s Claude, Elon Musk’s xAI Grok, and China’s DeepSeek, synthesizing the latest public information. The current provider tables in this report use the catalog and standard rates published on August 19, 2026: OpenAI’s GPT-5.6 family; Google’s Gemini 3.1 Pro Preview, Gemini 3 Flash Preview, and Gemini 3.1 Flash-Lite; Anthropic’s Claude 5 family; xAI’s grok-4.6; and DeepSeek’s V4-Flash and V4-Pro. Current rates are not directly rankable without matching the input/output mix, cache status, context band, processing tier, and—where applicable—DeepSeek’s peak or off-peak period. Historical models and prices are identified as such below. (^[1]) (^[2]) (^[3]) (^[4]) (^[5])

These differences mean that for the same task, costs can vary by orders of magnitude depending on model choice. Throughout this report, we explore the historical evolution of these pricing schemes, compare them quantitatively in tables, and discuss implications for developers and businesses choosing among providers. We also include case studies illustrating real-world cost impacts, cite independent analyses of cost-cutting trends, and outline how aggressive pricing (especially by open-source-focused players) may reshape the future economics of AI. All figures and claims here are backed by official documentation and recent technology news sources (^[6]) (^[7]) (^[8]) (^[9]).

Large language models have revolutionized numerous industries by enabling advanced natural language understanding and generation. By 2025, LLM APIs are used for chatbots, coding assistants, document summarization, translation, and more. Unlike earlier AI models, modern LLMs expose sophisticated token-based billing: every API call’s input and output text (measured in tokens, roughly word pieces) incurs cost, aligning with a “pay-as-you-go” cloud model (^[10]). This token-based pricing offers fine-grained control of costs but demands careful model selection and prompt engineering.

The major LLM providers now include OpenAI, Google (via its Gemini models), Anthropic, xAI (Grok), and DeepSeek. Each has multiple model variants optimized for different trade-offs (accuracy, speed, context length). OpenAI’s current GPT-5.2 family includes standard, “Pro”, “mini”, and “nano” editions for different price/performance points (^[11]). Anthropic’s Claude line is tiered (Haiku, Sonnet, Opus), and Google’s Gemini offers “Pro” (large, multi-modal) vs “Flash” (lighter, cheaper) versions (^[12]) (^[8]). Grok 4 comes in standard and fast modes, plus a specialized coding variant (^[7]). DeepSeek’s current API price page lists deepseek-v4-flash and deepseek-v4-pro. Both support thinking and non-thinking modes, have a 1M-token context length, and use cache-status and peak/off-peak pricing. (^[5])

Pricing is a critical differentiator. All use per-token pricing, but rates vary widely by model. Generally, more capable models cost more per token. Historical context shows rapid evolution: for example, OpenAI halved its GPT-3.5 Turbo token price in 2023, then introduced GPT-4 (at ~10× the cost of 3.5), and in 2024 launched GPT-4o mini at just $0.15/$0.60 per million input/output – a 60% discount vs GPT-3.5 Turbo (^[6]). Similarly, Chinese startups like DeepSeek entered the market with dramatically lower pricing (DeepSeek R1 debuted at $0.55/$2.19 per million, undercutting competitors by ~90% (^[13])). These shifts reflect aggressive competition and have set new baselines. The historical discussion below should not be treated as a live provider catalog. The current model names, availability, context limits, and prices should be checked against the official provider pages linked in this article before a purchasing decision.

OpenAI offers several model families and service tiers. As of August 19, 2026, its pricing page identifies the GPT-5.6 family as its latest flagship family; prices differ by model, service tier, cache status, and whether a request uses long context. (^[1])

• GPT-5.2: The latest flagship model (Feb 2026), top performance in reasoning and agentic tasks.
• Input: $1.75 per 1M tokens.
• Cached input: $0.175 per 1M tokens.
• Output: $14.00 per 1M tokens.
• GPT-5.2 Pro: The premium tier of GPT-5.2 for maximum capability.
• Input: $21.00 per 1M tokens.
• Output: $168.00 per 1M tokens.
• GPT-5 mini: A smaller, cheaper model for well-defined tasks.
• Input: $0.25 per 1M.
• Cached: $0.025 per 1M.
• Output: $2.00 per 1M.
• GPT-5 nano: The smallest and cheapest variant.
• Input: $0.05 per 1M.
• Cached: $0.005 per 1M.
• Output: $0.40 per 1M (^[14]) (^[11]).

For example, sending 100K input tokens and receiving 100K output tokens on gpt-5.6-terra at the standard short-context rate costs $0.20 for input plus $1.20 for output, or $1.40 before any cache, service-tier, or regional-processing adjustments. Historical model prices should be treated as historical snapshots rather than a current catalog.

For comparison and thoroughness, below is a summary table of OpenAI’s key current models and rates:

Model (OpenAI)	Description	Input ($/M tokens)	Output ($/M tokens)	Notes
gpt-5.6-sol	Latest flagship family	$5.00	$30.00	Standard short-context rate
gpt-5.6-terra	Lower-cost latest-family model	$2.00	$12.00	Standard short-context rate
gpt-5.6-luna	Lowest-cost latest-family model	$0.20	$1.20	Standard short-context rate

Source:OpenAI API pricing. Note: fine-tuning, Batch, Flex, Fast mode, long-context, caching, and regional-processing prices can differ from the standard short-context rates shown above.

OpenAI’s pricing has trended sharply downward over the past two years. The GPT-4o mini launched in mid-2024 at $0.15/$0.60 per MTok -- a 60% reduction from GPT-3.5 Turbo (^[6]). The current GPT-5.6 family has different capability and cost trade-offs: gpt-5.6-sol is priced above terra and luna at the published standard short-context rate. Organizations should compare applicable context bands, cached-input rates, and service tiers rather than treating historical GPT-5 prices as current.

Google provides its LLMs through Vertex AI (Google Cloud) under the “Gemini” brand. Google's Gemini API catalog changes frequently and includes newer 3.x models. Google uses different standard, batch, Flex, and Priority prices for some models; Gemini 3.1 Pro Preview also changes rates when a prompt exceeds 200,000 tokens. (^[2])

• Gemini 2.5 Pro:

• Input tokens: $1.25 per 1M (for ≤200K input), $2.50 per 1M (for >200K).

• Text output (response & reasoning): $10 per 1M (≤200K input), $15 per 1M (>200K) (^[12]).

• Gemini 2.5 Flash (multimodal smaller model):

• Text/Image/Video input: $0.30 per 1M.

• Audio input: $1.00 per 1M.

• Text output: $2.50 per 1M (^[15]).

The Gemini Developer API lists Gemini 3 Flash Preview at paid-tier Standard rates of $0.50 per 1M text/image/video input tokens ($1.00 for audio) and $3.00 per 1M output tokens, including thinking tokens. Gemini 3.1 Flash-Lite is listed at $0.25 per 1M text/image/video input tokens ($0.50 for audio) and $1.50 per 1M output tokens under Standard pricing. Preview models can change before general availability. (^[2])

In plain terms, calling Gemini 2.5 Pro with a moderate prompt (e.g. 100K tokens) costs about $0.125 (input) + $1.00 (output) = $1.125 per 100K tokens, doubling if the prompt exceeds 200K. For Gemini 2.5 Flash, the cost is much lower: only $0.03 input + $0.25 output per 100K. Google’s strategy offers a “Pro” model competitive with premium pricing and a very cheap “Flash” model for volume tasks. Gemini 2.5 Pro below thresholds at $1.25/$10 per 1M is significantly lower than Grok 4’s $3/$15 (see Grok section) (^[16]).

Google also allows “grounding” with Google Search/Web to enrich responses, billed up to $35 per 1K grounded queries (^[17]). However, the base token costs above generally suffice for textual tasks.

Google Gemini Pricing Summary (per 1M tokens):

Model	Input (\≤200K / >200K)	Output	Notes
Gemini 3 Flash Preview	$0.50 text/image/video; $1.00 audio	$3.00	Published paid-tier Standard rate; preview model
Gemini 3.1 Pro Preview	$2.00 / $4.00	$12.00 / $18.00	Published paid-tier rates; both change above 200K prompt tokens
Gemini 3.1 Flash-Lite	$0.25 text/image/video; $0.50 audio	$1.50	Published paid-tier Standard rate
Gemini 2.5 Pro	$1.25 / $2.50	$10.00 / $15.00	Published paid-tier rates; both change above 200K prompt tokens
Gemini 2.5 Flash	$0.30 text/image/video; $1.00 audio	$2.50	Published paid-tier standard rate

Source: Google Cloud Vertex AI pricing docs (^[12]). Notes: Above 200K input tokens, both input and output rates increase for Pro models.

In addition to token-pricing, Google’s Gemini (like Anthropic) often benefits from integration discounts if using Google Cloud infrastructure. Overall, direct per-token comparisons require matching the input/output mix, prompt-length band, cache status, processing tier, and platform. The current published rates for Gemini 3.1 Pro Preview and OpenAI’s GPT-5.6 family should be checked against their official pricing pages before making a purchasing decision. (^[2]) (^[1])

Anthropic’s Claude family (Haiku, Sonnet, Opus) targets safety and reliability. Anthropic uniquely offers prompt caching discounts in its pricing model (where repeat queries get cheaper). Anthropic's current price list includes newer Claude 5 models. The base, non-cache rates below are first-party Claude API rates; prompt caching, Batch API use, data residency, and Fast mode can change effective pricing. (^[3])

• Claude Fable 5:
• Base input: $10 per 1M tokens.
• Output: $50 per 1M tokens.
• Claude Opus 5:
• Base input: $5 per 1M tokens.
• Output: $25 per 1M tokens.
• Claude Sonnet 5:
• Base input: $2 per 1M tokens.
• Output: $10 per 1M tokens.
• Claude Haiku 4.5:
• Base input: $1 per 1M tokens.
• Output: $5 per 1M tokens.

Anthropic’s price page also lists other available and limited-availability models; the comparison below includes Fable alongside the Opus, Sonnet, and Haiku tier representatives. (^[3])

These rates assume standard (5-minute) caching or direct usage. Anthropic explains that “5m cache writes” cost 1.25× base input, and “cache reads” cost only 0.1× base (illustrating the impact of caching) (^[18]).

In simplified terms, Claude Opus 5 is priced at $5/$25 per million tokens, Claude Sonnet 5 at $2/$10, and Claude Haiku 4.5 at $1/$5. Direct price comparisons require the same input/output mix, cache status, context band, service tier, and platform; DeepSeek’s current rates also vary by cache status and peak/off-peak period.

For illustrative clarity, one can also view Claude batch rates (50% off) or long-context premium (detailed on Anthropic’s site); however, the base token costs above capture the primary differences.

Anthropic Claude Pricing Summary (per 1M tokens):

Model	Input (base)	Output (base)	Notes
Claude Fable 5	$10.00	$50.00	Highest-capability current model listed by Anthropic
Claude Opus 5	$5.00	$25.00	Current Opus model
Claude Sonnet 5	$2.00	$10.00	Current Sonnet model
Claude Haiku 4.5	$1.00	$5.00	Current small model

Source: Anthropic API pricing docs (^[8]). Note cache writes (~x1.25-2x) and cache hits (~x0.1) impact effective cost for repeated prompts, and Anthropic offers a 50% discount on input/output under its Batch API (not shown above for brevity).

In practice, published base input/output rates for Claude Opus 5, Sonnet 5, and Haiku 4.5 are $5/$25, $2/$10, and $1/$5 per million tokens, respectively. Cache, Batch API, data-residency, Fast mode, and any applicable context-band charges can change the effective bill. Teams can route workloads among tiers based on their quality, latency, and cost requirements. (^[3])

xAI (Elon Musk’s AI startup) began public Grok releases in 2023. The earlier Grok 3 and Grok 4 entries are not the current xAI catalog. xAI's documentation identifies grok-4.6 as its flagship text-and-code model. Its standard short-context rate is $2.00 per 1M input tokens, $0.50 cached input, and $6.00 output, with a 500,000-token context window. Once a prompt reaches 200,000 tokens, xAI applies its long-context rates to all tokens in the request. (^[4])

Current xAI pricing should be compared only with like-for-like assumptions. For grok-4.6, the published short-context rates are $2.00 per 1M input tokens, $0.50 cached input tokens, and $6.00 output tokens; the context window is 500,000 tokens. Prompts of 200,000 tokens or more use the model’s published long-context rates for all tokens in the request. (^[4])

Grok Pricing Summary (per 1M tokens):

Model (xAI Grok)	Input	Output	Context (tokens)	Notes
grok-4.6	$2.00	$6.00	500,000	Current flagship; standard short-context rate
grok-build-0.1	$1.00	$2.00	256,000	Current build-oriented model; standard short-context rate

Source:xAI API pricing. All prices are USD per 1M tokens; long-context rates, caching, and tool charges may differ.

Direct price rankings require like-for-like assumptions about context band, cache status, service tier, and input/output mix. xAI’s pricing page should be checked for current model availability and tool charges before choosing a model.

DeepSeek is a Chinese AI startup that gained fame for open and affordable models. Its initial DeepSeek-R1 (open-source) hit the market in January 2025, offering GPT-4 class performance at a fraction of the usual price (^[19]). DeepSeek then evolved through its V3 series. In September 2025, DeepSeek-V3.2-Exp (Experimental) was documented with the following historical Chat and Reasoner rates and a 128K-token context window. DeepSeek’s current catalog and pricing are V4-Flash and V4-Pro; see the comparative table for their current peak cache-miss rates. (^[5])

• Input tokens: $0.028 per 1M (cache hit), $0.28 per 1M (cache miss) (^[9]).
• Output tokens: $0.42 per 1M (^[9]).

DeepSeek introduced a cache mechanism: if a prompt (or subprompt) is already used (“cache hit”), input cost is only $0.028/M; otherwise $0.28/M. This means repeated queries become almost free, incentivizing stateful use. Notably, DeepSeek cut all its prices by ~50% in Sep 2025 (^[20]) compared to the prior V3.2-beta (the Reuters piece states “reducing API pricing by over 50%” (^[20])).

For context, DeepSeek’s original R1 model had pricing around $0.55/$2.19 (input/output) (^[13]). Thus V3.2-Exp’s $0.28/$0.42 rates were dramatically lower than the GPT-5.2 prices used in this historical comparison; they are not comparable to the current GPT-5.6 catalog. TechRadar reports: ”DeepSeek-R1 debuted at $0.55 input/$2.19 output” and comments that LLM pricing “has cratered” since (^[13]). DeepSeek’s new prices validate that trend.

In September 2025, these V3.2-Exp rates were unusually low, but they are not a basis for a current universal API price ranking. For example, processing 1M tokens of input and 1M output (a huge request) would cost just $0.28 + $0.42 = $0.70 total (cache-miss). Even with repeated use (cache hits), cost is only $0.028 + $0.42 = $0.448. By comparison, OpenAI’s cheapest model (GPT-5 nano) would cost $0.05 + $0.40 = $0.45 (similar), but GPT-5 nano has only a 32K context. DeepSeek’s model offers 128K context (^[21]), far more data at similarly tiny price.

DeepSeek V3.2-Exp Pricing Summary (per 1M tokens):

Mode	Input (cache-hit)	Input (cache-miss)	Output	Context
DeepSeek Chat	$0.028	$0.28	$0.42	128K tokens
DeepSeek Reasoner	$0.028	$0.28	$0.42	128K tokens

Source: DeepSeek API documentation (Sept 2025) (^[9]). Note: caching heavily affects input pricing.

The aggressive pricing is a deliberate strategy. As quoted by Reuters, DeepSeek aims “to match or exceed rivals’ performance at reduced costs” to “solidify its position” (^[22]). Industry commentary underscores this “price war”: Chinese models (DeepSeek, Baidu’s Ernie) have pushed token costs near zero, challenging Western providers (^[23]). In fact, TechRadar notes “China is commoditizing AI faster than the West can monetize it”, since free open models threaten the business case for paid ones (^[23]).

To compare across providers, consider example per-token costs. Table below contrasts representative high-capacity and low-cost models:

Provider	Model	Input ($/M)	Output ($/M)	Context (tokens)	Remarks
OpenAI	gpt-5.6-sol	$5.00	$30.00	See provider documentation	Latest-family standard short-context rate
OpenAI	gpt-5.6-terra	$2.00	$12.00	See provider documentation	Lower-cost latest-family standard short-context rate
OpenAI	gpt-5.6-luna	$0.20	$1.20	See provider documentation	Lowest-cost latest-family standard short-context rate
Google	Gemini 3.1 Pro Preview	$2.00-$4.00*	$12-$18*	See provider documentation	Gemini Developer API paid-tier Standard rates
Google	Gemini 3.1 Flash-Lite	$0.25 text/image/video; $0.50 audio	$1.50	See provider documentation	Gemini Developer API paid-tier Standard rate
Google	Gemini 2.5 Pro	$1.25-$2.50*	$10-$15*	2M	Tiered pricing
Google	Gemini 2.5 Flash	$0.30	$2.50	2M	Cheap, versatile
Anthropic	Claude Opus 5	$5.00	$25.00	See provider documentation	Current Opus model
Anthropic	Claude Sonnet 5	$2.00	$10.00	See provider documentation	Current Sonnet model
Anthropic	Claude Haiku 4.5	$1.00	$5.00	See provider documentation	Current small model
xAI	grok-4.6	$2.00	$6.00	500K	Current flagship; standard short-context rate
DeepSeek	deepseek-v4-flash	$0.44*	$1.32	1M	Current peak cache-miss input rate
DeepSeek	deepseek-v4-pro	$1.32*	$3.96	1M	Current peak cache-miss input rate

* DeepSeek’s off-peak rates are half of peak rates, and cache-hit input is priced separately.

This comparison should not collapse cache-hit, cache-miss, peak/off-peak, long-context, or service-tier rates into one ranking. A cache-miss DeepSeek V4-Flash input token at its published peak rate ($0.44 per 1M) is more expensive than OpenAI gpt-5.6-luna input ($0.20 per 1M), while DeepSeek’s off-peak or cache-hit rates are lower. Evaluate a provider with the request mix and service conditions that apply to the workload.

Price per 100K tokens (example): A 100K-input, 100K-output standard short-context request costs $0.20 + $1.20 = $1.40 on OpenAI gpt-5.6-terra. Direct cross-provider comparisons require the same stated input/output split, cache status, context band, and service tier; provider tables should not be converted into a single ranking without those assumptions.

The table is a rate reference, not a universal capability ranking or a complete bill estimate. Model choice should account for workload quality requirements as well as input/output volume, cache behavior, context length, service tier, tools, and any regional or platform-specific charges.

Case 1: Customer Support Chatbot. A monthly total-token estimate is insufficient to calculate an API bill because input and output are charged separately and cache status can change the input rate. For example, a workload with 8M short-context input tokens and 2M output tokens would cost $40 + $60 = $100 on OpenAI gpt-5.6-sol at published standard rates. The same split would cost $16 + $24 = $40 on gpt-5.6-terra, before cache, batch, Flex, long-context, tools, or regional-processing adjustments.

Case 2: Enterprise Document Summarization. Assume 100 documents per month, each with 60K input tokens and a 6K-token summary: 6M input tokens and 0.6M output tokens total. At first-party standard rates, Claude Opus 5 would cost $30 for input plus $15 for output, or $45; Claude Sonnet 5 would cost $12 plus $6, or $18; and OpenAI gpt-5.6-terra would cost $12 plus $7.20, or $19.20. Actual bills can differ with caching, batch processing, long-context requests, or tool use.

Real-World Example: Bing Chat Integration. Microsoft documented that the new AI-enhanced Bing used GPT-4 and that it worked with the model for months before GPT-4’s public release in March 2023. OpenAI introduced the distinct o1 reasoning-model family in September 2024, so it was not the model used in Bing’s 2023 launch. This article therefore uses publicly posted API rates as its comparison baseline rather than making claims about undisclosed internal agreements or discounts. (^[24]) (^[25])

Illustrative daily estimate. A 50,000-token daily workload needs an explicit input/output split. If it consists of 25,000 input and 25,000 output tokens, gpt-5.6-terra’s published short-context rates produce $0.05 of input cost plus $0.30 of output cost, or $0.35 per day. At that same split, 100 bots running for 30 days would cost about $1,050 before caching, Batch, Flex, Fast mode, long-context, tool, or regional-processing charges. (^[1])

The rapid evolution in LLM pricing reflects both market competition and technological advances. Key trends and implications include:

• Pricing pressure and model segmentation: Provider pricing changes frequently, and catalogs segment by capability, latency, context length, caching, and processing mode. Current published rates show substantial variation even within one provider’s model family, but they do not establish that any provider’s models are “effectively free” or support a universal forecast for future price cuts. (^[1]) (^[3]) (^[5])

• Differentiated Offerings: Providers segment their catalogs by price, capability, context, latency, and modality. OpenAI’s current flagship family includes sol, terra, and luna; Google offers Pro and Flash-family models; Anthropic offers Opus, Sonnet, and Haiku; and xAI lists grok-4.6 and grok-build-0.1. Organizations can route workloads to models that meet their quality, latency, and cost requirements rather than applying a single model everywhere. (^[1]) (^[2]) (^[3]) (^[4])

• Two-Part Pricing and Ecosystem Effects: Tiered pricing (volume discounts, batch APIs) and multi-modal features complicate direct comparisons. For instance, Google charges extra for “grounded” search queries, while Anthropic’s long-context pricing premium and caching create effective nonlinear cost curves (^[17]) (^[8]). This means vendors might not strictly compete on raw token price, but on value (e.g. freshness, search, tool use). Pricing strategy becomes part of lock-in: e.g. Google bundling lower Gemini rates for Cloud users. We already see enterprises bundling LLM spend into cloud contracts (Azure, AWS Bedrock multi-LLM billing) to manage cost predictability (^[26]).

• Use of Tokens vs. Alternatives: Some providers experiment with non-token billing. For example, OpenAI offers a “request-based” pricing for certain APIs (e.g. Vision API in dollar per image rather than per token). Large-scale use cases might evolve hybrid pricing (e.g. fixed-price content creation subscription). However, the fundamental token model will likely remain primary for text generation at least through 2026. Tools and prompt optimization (e.g. GPT’s “cost consciousness” like avoiding ChatGPT answer verbosity) will become best practices for controlling token spend.

• Long-Term Outlook: Provider catalogs and prices can change quickly. Published prices alone do not establish a reliable forecast for future prices, market structure, or provider subsidy practices. Teams should monitor official pricing pages and re-estimate their own workloads when models, context bands, processing modes, or tool charges change.

In sum, cost optimization is now a core part of the AI developer playbook. Our analysis suggests that enterprises must carefully match model selection to use-case, balancing “best model” vs “acceptable model” based on token budgets. For example, as one recent whitepaper notes, using a cheaper model for 70% of routine tasks and reserving the most expensive model for 30% yields better ROI than all-in on the top model (^[10]). As Gartner analysts have forecast, by 2026 AI services cost will become a chief competitive factor, potentially surpassing raw performance in importance. The pricing data compiled here will help stakeholders make informed choices in that landscape.

This August 2026 update (originally published October 2025) describes an LLM API market with material cost differentials. Published rates alone do not establish a provider-wide price or capability ranking: actual charges depend on the selected model, input/output mix, cache status, context length, service tier, tools, region, and platform. The DeepSeek figures in this article use the provider’s current V4 catalog, but they still depend on cache status and whether usage occurs during peak or off-peak hours.

Crucially, these rates are dynamic. New model releases, volume agreements, and one-off promotions will further shift the playing field. We recommend that AI consumers continuously re-evaluate pricing, consider multi-provider strategies, and leverage specialized offerings (batch APIs, caching, long-context) to optimize costs.

The current model and rate references above are based on the providers’ official pricing documentation and should be rechecked immediately before publication or purchase. (^[1]) (^[3]) (^[4]) (^[5]) Continued transparency from providers and third-party tracking will be essential for navigating the ongoing AI pricing revolution.