LLM API Pricing November 2026: Per-Million-Token Costs for GPT, Claude, Gemini, Grok, DeepSeek and Mistral Compared
A 400,000-token prompt to GPT-6.1 Sol costs roughly twice what a 270,000-token prompt costs, even though it is only 48% longer. That cliff, and a dozen others like it, is why a flat table of list prices tells you less than you think about LLM API pricing. In November 2026 the six major API vendors price on at least four extra axes beyond input and output: cache reads and writes, service tier, context length, and region. DeepSeek adds a fifth, time of day.
This matters now because the spread between the cheapest small model and the most expensive flagship is 100x on input and more than 300x on output. Two of the listed prices also change within weeks: Google’s introductory Gemini 4 Argon rate ends on November 30. You leave this post with a verified price sheet as of November 15, 2026, three worked cost-per-task models, and a decision guide for routing workloads.
What this covers: methodology, results by tier (frontier, mid, small), long-context surcharges, caching and batch discounts, self-hosting break-even, and a routing checklist.
Context and Background
Per-token pricing became the default unit of AI procurement because it maps cleanly onto how transformer inference consumes compute. Prefill, the pass that processes your prompt, is compute-bound and parallel, so input tokens are cheap. Decode, which generates one token at a time and rereads the KV cache for each, is memory-bandwidth-bound, so output tokens cost four to eight times more at most vendors. Every number in this post follows from that asymmetry.
What changed in 2026 is the number of modifiers. OpenAI now publishes four service tiers (Standard, Flex/Batch, Fast and, for its top two models, Ultrafast), and a 272K-token long-context step. Anthropic prices its newest models flat across a 1M-token window but charges a 1.1x multiplier for US-only inference. Google still steps Gemini 3.1 Pro up above 200K tokens and bills explicit context caches by storage-hour. xAI applies a 200K step and a 20% batch discount instead of the usual 50%. DeepSeek halves its rates outside two weekday windows.
We covered the economics of individual levers in earlier posts. The break-even math for cache writes lives in our analysis of prompt caching economics and TTL break-even across providers. How a per-token price becomes a gross margin is in our piece on LLM token economics and unit economics for AI features. This post is the price sheet those analyses plug into, refreshed for November.
Every figure below comes from a vendor’s own pricing or model page, fetched on November 15, 2026. The primary sources are the OpenAI API pricing page, Anthropic’s Claude API pricing documentation, Google’s Gemini Developer API pricing page, xAI’s API pricing page, DeepSeek’s models and pricing page and Mistral’s API pricing documentation. Where a page was ambiguous or silent, we say so instead of filling the gap.
How LLM API Pricing Actually Works in November 2026
LLM API pricing in November 2026 is a per-million-token rate multiplied by up to five modifiers. Input, cached input, cache writes and output each carry a separate rate. Service tier (batch, flex, fast), long-context steps above 100K, 200K or 272K tokens, regional uplifts of about 10%, and DeepSeek’s peak window then scale that rate.

Figure 1: Four token categories, each with its own rate, pass through four modifiers before they become the effective cost of a task.
The diagram reads left to right. A single API call splits into uncached input, cache writes, cache reads, and output (which, for every reasoning model in this survey, includes hidden thinking tokens). Each category has its own per-million rate. Then the service tier, any long-context step, any regional uplift and, for DeepSeek, the time of day multiply those rates. Only the product of all of them is comparable across vendors.
Output tokens dominate, and thinking tokens are output
Across the 21 model rows we price below, the output-to-input price ratio ranges from 1:1 (Ministral 3 8B) to 6:1 (Gemini 3.5 Flash, Gemini 3.1 Pro Preview and Gemini 3.1 Flash-Lite). OpenAI, Anthropic and Google all price their current flagships at a 5:1 ratio. xAI’s Grok 4.7 is the clear exception at 3:1, and Mistral Large 4 is also 3:1.
The trap is that reasoning models emit thinking tokens you never see, and every vendor here bills them as output. Google states this explicitly for Gemini 4 Argon (“output, including thinking tokens”). Anthropic’s Opus 5.5 uses adaptive thinking that its model page says cannot be disabled, only tuned through an effort parameter. So a model with a cheaper output rate can still produce a larger bill if it thinks longer for the same answer.
Cache reads are now the biggest lever on input cost
Cache-read discounts have widened sharply. Anthropic charges cache hits at 0.05x base input for Opus 5.5 and Sonnet 5.5, and at 0.025x for Fable 5.2 and Mythos 5.2, against 0.1x on older Claude models. OpenAI’s GPT-6 family reads cache at 0.05x (Sol, Terra) or 0.1x (Astra, Luna). Gemini 4 Argon’s implicit caching gives a 95% discount on hits for prompts of at least 4,096 tokens, according to Google’s model page.
DeepSeek is the extreme case. Its deepseek-flash model charges $0.006 per million cache-hit tokens at peak against $0.30 for a miss, a 50x gap. For an agent that resends a growing conversation on every turn, the cache-read rate matters more than the headline input price. We show this in the worked agent example below.
Tier discounts are almost always 50%, with two exceptions
OpenAI, Anthropic, Google and Mistral all price batch processing at 50% of standard. OpenAI and Google also sell a Flex tier at the same discount for latency-tolerant synchronous calls. xAI is the exception, listing a 20% batch discount on Grok 4.3 through 4.7 and no discount at all on grok-build-0.1. DeepSeek’s pricing page lists no batch tier; its off-peak window plays the same role.
Going the other way, OpenAI’s Fast mode (renamed from Priority processing on July 30, 2026, per its pricing page) costs 2x. Anthropic’s fast mode on Opus 5.5 also costs 2x, at $8 input and $40 output, for what it describes as up to 2.5x higher output speed. Gemini’s Priority tier runs at 1.8x standard on every model we checked.
Methodology: How We Built the November 2026 Price Sheet
We built this LLM API pricing sheet as a reproducible pipeline, not a scrape of a third-party aggregator. Aggregators lag, and several of them still list retired models. The steps are shown below.

Figure 2: The methodology runs from official pages to normalized rates, then through three task profiles to a decision guide.
First, we fetched each vendor’s official pricing page and, where the pricing page was ambiguous, the individual model page. Second, we recorded input, cached input, cache write and output rates per million tokens, plus every published modifier. Third, we flagged conflicts and gaps. Fourth, we grouped models into three tiers by price and positioning. Finally, we ran three task profiles through each rate card to get an illustrative cost per task.
What we could not verify
Three gaps are worth stating up front. OpenAI’s pricing page labels its tier tabs “Standard, Flex/Batch, Fast, Ultrafast” but does not label the tables themselves; we confirmed the 50% Batch/Flex and 2x Fast rules from the individual model pages for GPT-6 Astra, GPT-6.1 Sol and GPT-6 Luna. The Ultrafast mapping ($12/$60 for Sol, $60/$300 for Astra) is our reading of the table order and is unverified.
Google’s pricing page does not yet include a row for Gemini 4 Argon. Its price comes from the Gemini 4 Argon model page, which lists only standard input, cached input and output. Batch, Flex and Priority rates for Argon, and any long-context step, are unverified.
Mistral’s two official pages disagree. The API pricing documentation and the Mistral Large 4 model card both list $0.70 input and $2.10 output. Mistral’s marketing pricing page shows “$0.5 per million input tokens and $1.5 per million output tokens” as an example for Mistral Large. We use the documentation figures, which match the model card, and flag the conflict.
Why we do not publish a single “blended” ranking
A common shortcut is a 3:1 blended price, three parts input to one part output. We compute it for reference, but it is a poor proxy for most production traffic. Retrieval-augmented generation (RAG) runs closer to 15:1, agents with growing context run 40:1 or higher, and most of that input is cached. A blended number that ignores caching overstates agent costs by three to four times on the models with steep cache discounts.
Tokenizers are the other reason. Anthropic’s pricing page notes that Claude 4.7 and later models use a newer tokenizer that produces about 30% more tokens for the same text than its predecessor. Vendors do not publish cross-vendor token ratios, so we cannot convert one vendor’s million tokens into another’s. Every cost-per-task figure below assumes the same token count on every model, and you should replace that assumption with measured counts from your own prompts.
Results: LLM API Pricing by Tier
All LLM API pricing figures in this section are USD per million tokens, standard tier, as of November 15, 2026, from the official pages linked above. “Cached” means the cache-hit or cached-input rate. Batch is the published batch rate, or “50%” where the vendor states a rule rather than a table row.
Frontier tier
| Model | Input | Cached input | Output | Batch | Context | Notes |
|---|---|---|---|---|---|---|
| GPT-6 Astra (OpenAI) | $10.00 | $1.00 | $50.00 | 50% off | 1.05M | 2x input, 1.5x output above 272K |
| Claude Fable 5.2 (Anthropic) | $8.00 | $0.20 | $40.00 | $4 / $20 | 1M | Flat to 1M; Mythos 5.2 same price |
| Claude Opus 5.5 (Anthropic) | $4.00 | $0.20 | $20.00 | $2 / $10 | 1M | Flat to 1M; released Sep 22, 2026 |
| Gemini 4 Argon (Google) | $2.00 | $0.10 | $10.00 | unverified | 1,048,576 | Intro price to Nov 30; $4 / $0.20 / $20 from Dec 1 |
| GPT-6.1 Sol (OpenAI) | $2.00 | $0.10 | $10.00 | $1 / $5 | 1.05M | 2x input, 1.5x output above 272K |
| Grok 4.7 (xAI) | $2.00 | $0.50 | $6.00 | 20% off | 500K | $4 / $1 / $12 at 200K and above |
| DeepSeek V4 Pro | $1.32 | $0.044 | $3.96 | none listed | 1M | Peak rate; off-peak is half |
| Mistral Large 4 | $0.70 | $0.07 | $2.10 | 50% off | 1M | Open weights; marketing page conflicts |
The frontier tier now spans a 14x range on input ($0.70 to $10) and a 24x range on output ($2.10 to $50). Two pairs share identical standard rates: Claude Sonnet 5.5 and GPT-6.1 Sol at $2/$10, and Claude Opus 5.5 and post-promotion Gemini 4 Argon at $4/$20. When list prices converge like that, the deciding variables become cache-read rates, long-context steps and tokens per task.
Mid tier
| Model | Input | Cached input | Output | Batch | Notes |
|---|---|---|---|---|---|
| Claude Sonnet 5.5 (Anthropic) | $2.00 | $0.10 | $10.00 | $1 / $5 | 1M context, flat pricing |
| Gemini 3.1 Pro Preview (Google) | $2.00 | $0.20 | $12.00 | $1 / $6 | $4 / $18 above 200K |
| Gemini 3.5 Flash (Google) | $1.50 | $0.15 | $9.00 | $0.75 / $4.50 | Output includes thinking |
| GPT-6.1 Terra (OpenAI) | $1.00 | $0.05 | $5.00 | $0.50 / $2.50 | 1.05M context |
| Grok 4.3 (xAI) | $1.25 | $0.20 | $2.50 | 20% off | 1M context; $2.50 / $5 above 200K |
| grok-build-0.1 (xAI) | $1.00 | $0.20 | $2.00 | none | 256K context |
Gemini 3.5 Flash is the outlier here. Its $9 output rate is 6x its input rate and nearly as high as Gemini 3.1 Pro Preview. For output-heavy work, GPT-6.1 Terra at $5 or Grok 4.3 at $2.50 is materially cheaper; for input-heavy work with caching, the gap narrows.
Small tier
| Model | Input | Cached input | Output | Batch | Notes |
|---|---|---|---|---|---|
| GPT-6 Luna (OpenAI) | $0.10 | $0.01 | $0.50 | $0.05 / $0.25 | 2x input above 272K |
| Claude Haiku 5.5 (Anthropic) | $0.10 | $0.01 | $0.50 | $0.05 / $0.25 | $0.50 / $2.50 above 100K prompt |
| Gemini 2.5 Flash-Lite (Google) | $0.10 | $0.01 | $0.40 | $0.05 / $0.20 | Older generation |
| Gemini 3.1 Flash-Lite (Google) | $0.25 | $0.025 | $1.50 | $0.125 / $0.75 | Audio input $0.50 |
| deepseek-flash (DeepSeek V4.1 Flash) | $0.30 | $0.006 | $1.20 | none listed | Peak; off-peak $0.15 / $0.003 / $0.60 |
| Mistral Small 4 | $0.15 | $0.015 | $0.60 | 50% off | |
| Ministral 3 8B | $0.15 | $0.015 | $0.15 | 50% off | 1:1 output ratio |
GPT-6 Luna and Claude Haiku 5.5 now share identical rates on short prompts, down to the cent: $0.10 input, $0.01 cached and $0.50 output. That convergence is the most notable shift in the small tier this year. The two models diverge only on long prompts, where Haiku 5.5 jumps 5x above 100K tokens and Luna doubles its input rate above 272K.
Third-party resale and cloud marketplaces
Mistral’s API now resells other vendors’ open models alongside its own. Its pricing page lists DeepSeek V4.1 Flash 1017 at $0.30 input, $0.007 cached and $1.20 output, close to DeepSeek’s own peak rates, without the off-peak discount. It also lists Z.ai GLM 5.3 at $1.40/$4.40 and GLM 5.3 Flash at $0.15/$0.50. That makes Mistral’s endpoint a single-contract option for EU buyers who want those weights.
For hyperscaler marketplaces, Anthropic’s pricing page states that regional and multi-region endpoints on Amazon Bedrock and Google Cloud carry a 10% premium over global endpoints for Sonnet 4.5, Haiku 4.5, Opus 4.5 and later. Anthropic applies the same 1.1x multiplier for inference_geo: "us" on Claude 4.6 and later models in its own API. OpenAI applies a 10% uplift for regional processing and FedRAMP endpoints on models released on or after March 5, 2026. Budget 10% for data residency on any of the three.
Worked Examples: What a Task Actually Costs
Rate cards only become useful when you multiply them by a workload, so this section turns LLM API pricing into cost per task. The three profiles below are illustrative. Token counts are assumptions chosen to represent common workloads, not measurements. All use standard-tier list prices from the tables above and assume identical token counts across vendors, which, as noted, is not strictly true.
Profile 1: a RAG query
Assume a 1,000-token system prompt that is cached, 5,000 tokens of retrieved context that is not, and a 400-token answer. Cost per query is 1,000 × cached rate + 5,000 × input rate + 400 × output rate.
| Model | Cost per query | Cost per 1,000 queries |
|---|---|---|
| GPT-6 Astra | $0.0710 | $71.00 |
| Claude Fable 5.2 | $0.0562 | $56.20 |
| Claude Opus 5.5 | $0.0282 | $28.20 |
| Gemini 3.1 Pro Preview | $0.0150 | $15.00 |
| GPT-6.1 Sol / Claude Sonnet 5.5 | $0.0141 | $14.10 |
| Gemini 4 Argon (intro price) | $0.0141 | $14.10 |
| Grok 4.7 | $0.0129 | $12.90 |
| Gemini 3.5 Flash | $0.0113 | $11.25 |
| DeepSeek V4 Pro (peak) | $0.0082 | $8.23 |
| GPT-6.1 Terra | $0.0071 | $7.05 |
| Mistral Large 4 | $0.0044 | $4.41 |
| deepseek-flash (peak) | $0.0020 | $1.99 |
| Gemini 3.1 Flash-Lite | $0.0019 | $1.88 |
| Mistral Small 4 | $0.0010 | $1.01 |
| GPT-6 Luna / Claude Haiku 5.5 | $0.0007 | $0.71 |
The spread from Astra to Luna is 100x for this profile. Because RAG prompts are dominated by uncached retrieved context, the input rate drives the result, and a model’s output rate barely moves the ranking. Gemini 4 Argon’s cost per 1,000 queries doubles to $28.20 on December 1 when the introductory price ends.
Profile 2: a 25-turn agent run
Assume an agent that runs 25 tool-calling turns. Across all turns it sends 600,000 input tokens, because each turn resends the growing conversation. With a stable prefix, 510,000 of those are cache hits and 90,000 are new tokens. It emits 15,000 output tokens, including thinking. We ignore cache-write premiums here; explicit caching would add up to 25% on the 90,000 new tokens.
| Model | With caching | Without caching | Saving |
|---|---|---|---|
| GPT-6 Astra | $2.16 | $6.75 | 68% |
| Claude Fable 5.2 | $1.42 | $5.40 | 74% |
| Claude Opus 5.5 | $0.76 | $2.70 | 72% |
| Grok 4.7 | $0.53 | $1.29 | 59% |
| Gemini 3.1 Pro Preview | $0.46 | $1.38 | 67% |
| GPT-6.1 Sol / Claude Sonnet 5.5 | $0.38 | $1.35 | 72% |
| Gemini 3.5 Flash | $0.35 | $1.04 | 67% |
| DeepSeek V4 Pro (peak) | $0.20 | $0.85 | 76% |
| GPT-6.1 Terra | $0.19 | $0.68 | 72% |
| Mistral Large 4 | $0.13 | $0.45 | 71% |
| deepseek-flash (peak) | $0.05 | $0.20 | 76% |
| GPT-6 Luna / Claude Haiku 5.5 | $0.02 | $0.07 | 68% |
Two things stand out. First, caching cuts agent cost by 59% to 76% on every model, so a cache-breaking bug is a bigger cost risk than picking the wrong vendor within a tier. Second, Grok 4.7 has the cheapest output in its class but the most expensive cache reads ($0.50, 5x Sol’s $0.10). In the uncached case it beats Sol and Sonnet; once caching is on, it falls behind them.
Fable 5.2’s 0.025x cache-read multiplier is why it saves the most of any Anthropic model here. Its cache hits cost $0.20, the same as Opus 5.5, despite a base input rate twice as high. For long agent sessions on Anthropic’s top tier, the effective price gap between Fable and Opus is much smaller than the 2x headline suggests: $1.42 against $0.76 in this profile, under 1.9x.
Profile 3: a million-document batch classification
Assume one million documents, each 800 input tokens and 50 output tokens, submitted through the batch API. That is 800 million input tokens and 50 million output tokens.
| Model and tier | Total job cost |
|---|---|
| Gemini 2.5 Flash-Lite, batch | $50.00 |
| GPT-6 Luna, batch | $52.50 |
| Claude Haiku 5.5, batch | $52.50 |
| Mistral Small 4, batch | $75.00 |
| Gemini 3.1 Flash-Lite, batch | $137.50 |
| deepseek-flash, off-peak | $150.00 |
| Grok 4.3, batch (20% off) | $900.00 |
| Claude Sonnet 5.5, batch | $1,050.00 |
| GPT-6.1 Sol, batch | $1,050.00 |
This profile is 94% input by token count, so input rates decide it. The three cheapest options land within $2.50 of each other. At this point the deciding factors are classification accuracy on your labels, batch turnaround time and rate limits, not price. For the scheduling side of large batch jobs, see our guide to offline batch LLM inference with provider batch APIs versus self-hosted vLLM.
Methodology caveats for the worked examples
These numbers are arithmetic on list prices, not measured bills. Real bills differ for at least four reasons. Token counts per task vary by tokenizer, so the same text can be 20% to 30% more tokens on one model than another. Reasoning models vary widely in how many thinking tokens they spend, and that can change the ranking. Cache hit rates in production are rarely as high as our 85% assumption without deliberate prompt design. Negotiated enterprise discounts and committed-use contracts are not public, so we cannot include them.
Long-Context Surcharges in LLM API Pricing: Where the Cliffs Are
Long-context pricing is the least understood part of LLM API pricing in 2026. Most vendors apply a step that reprices the whole request once the prompt crosses a threshold, not just the tokens above it. The figure below shows the thresholds that apply on November 15, 2026.

Figure 3: Long-context pricing steps. Crossing a threshold reprices every token in the request, not only the excess.
The thresholds, vendor by vendor
Claude Haiku 5.5 is the first to step, at 100,000 prompt tokens. Above that line its input price rises from $0.10 to $0.50 and output from $0.50 to $2.50, a 5x jump on both. Anthropic counts cache reads and writes toward the prompt length.
At 200,000 tokens, Gemini 3.1 Pro Preview and Gemini 2.5 Pro step up. Gemini 3.1 Pro doubles input to $4 and raises output from $12 to $18. xAI’s long-context rates also start at 200,000 prompt tokens and apply to all tokens in the request: Grok 4.7 goes from $2/$6 to $4/$12.
OpenAI’s step sits at 272,000 input tokens. Above it, the GPT-6 Astra, GPT-6.1 Sol and GPT-6 Luna model pages all specify 2x input and cache rates and 1.5x output, “for the full request.” The pricing page offers Short and Long context selectors but no numbers, so we rely on the model pages.
Anthropic’s Opus 5.5, Sonnet 5.5 and Fable 5.2 have no step at all. Their pricing page states that Claude 4.6 and later models, except Haiku 5.5, include the full 1M-token window at standard pricing, with a 900K-token request priced per token like a 9K one. DeepSeek and Mistral publish no long-context surcharge for their 1M-context models.
The cliff in numbers
For GPT-6.1 Sol, a 270,000-token prompt with a 2,000-token answer costs $0.56. A 275,000-token prompt with the same answer costs $1.13. Five thousand more tokens doubles the bill. The general rule: if a prompt lands just past a threshold, trimming it below the line usually saves more than any other optimization.
At 400,000 input tokens and 2,000 output tokens, the stepped and flat models converge. GPT-6.1 Sol costs $1.63, Gemini 3.1 Pro Preview $1.64, Grok 4.7 $1.62 and flat-priced Claude Opus 5.5 $1.64. Claude Sonnet 5.5, flat at $2/$10, costs $0.82, half as much. GPT-6 Astra above 272K costs $8.15 for the same request.
This convergence is the clearest example of why list prices mislead. Sol and Sonnet 5.5 are identically priced below 272K. Above it, Sonnet costs half as much. If your workload sends whole codebases or long contracts, the long-context rule matters more than the base rate. Whether a model actually uses all that context well is a separate question, covered in our fact-check on 1M-token context windows and effective context length.
Caching and Batch Discounts: Stacking Rules
Discounts stack in vendor-specific ways, and they move the effective LLM cost per million tokens more than most base-rate changes do, and getting the stacking wrong produces budget errors of 2x or more. This section summarizes what each pricing page says.
Anthropic
Anthropic publishes the most explicit stacking rules. Cache writes cost 1.25x base input for a 5-minute TTL and 2x for a 1-hour TTL. Reads cost 0.05x on Opus 5.5 and Sonnet 5.5, 0.025x on Fable 5.2 and Mythos 5.2, and 0.1x on most older models. The page says caching breaks even after one read for 5-minute writes and two reads for 1-hour writes.
The Batch API halves input and output. Fast mode is not available with batch, while caching and data-residency multipliers stack on top of fast-mode prices. A US-only Opus 5.5 fast-mode request with cache reads therefore pays $8 × 1.1 for input and $0.20 × 2 × 1.1 for cache reads, by our reading of the stacking rule; Anthropic does not publish a fast-mode cache-read row, so that last figure is unverified.
OpenAI
OpenAI lists cache writes as separate line items: on GPT-6.1 Sol, $2.50 for a 30-minute write and $5.00 for a 12-hour write, against $2.00 base input. Cached input on Sol is $0.10. The model pages say Batch and Flex are 50% of Standard and Fast is 2x “the applicable rates,” which means Fast stacks on top of long-context multipliers.
That stacking matters at scale. A GPT-6 Astra request above 272K tokens in Fast mode pays $10 × 2 × 2 = $40 per million input tokens and $50 × 1.5 × 2 = $150 per million output tokens, by our arithmetic on the published multipliers.
Gemini caching has two modes. Implicit caching is automatic and discounts hits; Google’s Argon page cites 95% for prompts of at least 4,096 tokens. Explicit context caches have a per-token read price plus a storage charge per million tokens per hour: $1.00 per hour on Gemini 3.5 Flash and $4.50 on Gemini 3.1 Pro Preview. Argon’s page says explicit caching is not supported.
Storage billing changes the break-even. A 100,000-token explicit cache on Gemini 3.1 Pro Preview costs $0.45 per hour to keep alive. You need enough reads within that hour to save more than $0.45 compared with paying $2 per million for uncached input; that works out to at least three full reads per hour, after the first write.
xAI, DeepSeek and Mistral
xAI lists a cached input price on every model ($0.50 on Grok 4.7, $0.20 on Grok 4.3) and a 20% batch discount. DeepSeek’s cache-hit rate is 2% of its miss rate on deepseek-flash and about 3.3% on V4 Pro, and its off-peak discount halves everything. Mistral’s documentation says batch processing runs “at a 50% discount” and lists cached input at 10% of base on every model we checked.
DeepSeek’s peak hours are 01:00 to 04:00 and 06:00 to 10:00 UTC, Monday to Friday, excluding Chinese public holidays. In India Standard Time, that is 06:30 to 09:30 and 11:30 to 15:30. A job scheduler that avoids those seven hours gets a 50% discount with no code changes.
Self-Hosting Break-Even Against GPU Prices
The case for self-hosting open weights against LLM API pricing rests on one ratio: GPU cost per hour divided by tokens served per hour. Our cloud GPU pricing survey for November 2026 found H100 on-demand list prices from $4.39 per GPU-hour on a neocloud to $12.29 on a hyperscaler, and B200 from $7.69 to $14.24.
The cost per million output tokens is: node price per hour ÷ (tokens per second × 3,600 × utilization) × 1,000,000. The throughput figures below are the same illustrative assumptions used in that survey, not measurements: 10,000 aggregate output tokens per second for an 8×H100 node and 25,000 for an 8×B200 node.
| Node (illustrative) | Node $/hour | At 30% util | At 60% util | At 85% util |
|---|---|---|---|---|
| 8×H100, neocloud at $4.39/GPU | $35.12 | $3.25 | $1.63 | $1.15 |
| 8×H100, AWS on-demand at $6.88/GPU | $55.04 | $5.10 | $2.55 | $1.80 |
| 8×B200, neocloud at $7.69/GPU | $61.52 | $2.28 | $1.14 | $0.80 |
Now invert it. To match deepseek-flash’s peak output price of $1.20 per million, the neocloud H100 node needs 81% utilization around the clock. To match Mistral Large 4’s $2.10 output price, it needs 47%. To match DeepSeek V4 Pro’s $3.96 peak output price, 25% is enough. Against GPT-6 Luna’s $0.50 output price, no utilization below 100% wins on this node.
Model size changes the hardware, not just the throughput
That table assumes the model fits on one node, which is not a given. Mistral Large 4 is the only frontier model in this survey with published open weights; its model card lists 1.05 trillion total parameters with 52 billion active, under the Mistral Ecosystem Open Weight License. At 8-bit precision the weights alone need about 1.05 TB of memory, more than an 8×H100 node’s 640 GB.
An 8×B200 node, with 8 × 180 GB = 1.44 TB, fits those weights with room for KV cache. So the relevant comparison for self-hosting Large 4 is the B200 row, and its real throughput will be lower than our illustrative 25,000 tokens per second for a smaller model. At our illustrative 25,000 tokens per second, the B200 node would need about 33% utilization to match Mistral’s $2.10 output price. A 1-trillion-parameter model will serve fewer tokens per second than that assumption, which pushes the real break-even higher, before you add engineering time, on-call cost and idle capacity.
The conclusion is not “never self-host.” Self-hosting pays when you have steady, high-utilization demand for a model whose API price is well above its hardware cost, or when data cannot leave your environment at all. It rarely pays for bursty traffic, for frontier quality, or against the small tier. The full cost model for serving engines is in our vLLM cost economics deep dive.
Trade-offs, Gotchas, and What Goes Wrong
LLM API pricing sheets fail in predictable ways. These are the ones we see most often in production budgets.
Promotional prices expire. Gemini 4 Argon doubles on December 1, 2026, from $2/$10 to $4/$20. OpenAI’s pricing page notes that GPT-5.6 Sol’s promotional pricing lasts until November 30, 2026, without saying which rows it applies to. A cost model built on November rates for a December launch is wrong by up to 2x.
Cross-vendor token counts are not equal. Anthropic itself states its newer tokenizer produces about 30% more tokens than its older one for the same text. Across vendors, the gap is unpublished and workload-specific. Measure with each vendor’s token-counting endpoint on a sample of real prompts before comparing.
Thinking budgets swamp output prices. A model at $6 output that spends 4,000 thinking tokens per answer costs more than a model at $10 that spends 1,500. Every reasoning model here bills thinking as output. Cap reasoning effort explicitly, and log reasoning tokens separately, for example through the attributes described in our guide to OpenTelemetry GenAI semantic conventions for token cost.
Cache hit rates collapse silently. A timestamp in a system prompt, a reordered tool list or parallel requests that race the first cache write can drop hit rates from 85% to near zero. In our agent profile that turns a $0.38 run into $1.35. Alert on cache-hit ratio, not just spend.
Long-context steps apply to the whole request. Crossing 200K on Gemini 3.1 Pro or Grok, or 272K on OpenAI, reprices every token. Retrieval pipelines that “just add more context” can double cost per call without any visible change in behavior.
Rate limits and tiers interact. Batch and Flex tiers are cheaper but slower and can be capacity-limited. Teams that move latency-tolerant traffic to Flex should still plan for 429 responses and fallback, covered in our guide on handling LLM API rate limits, retries and provider fallback.
Retired names still resolve. DeepSeek’s page says deepseek-v4-flash requests are now served by DeepSeek-V4.1-Flash-1017 at the Flash price. Silent model upgrades change quality as well as cost, so pin versions in regulated workloads.
Practical Recommendations
The cheapest way to use the LLM API pricing above is to start with the workload, not the vendor. Classify each LLM call by latency tolerance, prefix stability, prompt length and quality bar, then route accordingly. The decision flow below captures the logic.

Figure 4: A routing guide. Latency tolerance, prefix reuse, quality bar and utilization decide the cheapest acceptable option.
For latency-tolerant work, use batch or Flex first; it is a 50% discount at OpenAI, Anthropic, Google and Mistral, and nearly free to adopt. For interactive agents with stable system prompts and tool schemas, favor models with low cache-read rates, such as Sonnet 5.5 or Sol at $0.10, over models with cheap output but expensive cache reads. For high-volume classification or extraction, test the small tier first: GPT-6 Luna, Claude Haiku 5.5 and Gemini 2.5 Flash-Lite cost within 10% of each other.
Reserve the frontier tier for tasks the mid tier measurably fails. A cascade that escalates only on low-confidence answers often cuts spend by more than switching vendors; see our analysis of LLM routing and model cascades. A gateway that enforces per-team budgets helps keep those rules in place, as compared in our LLM gateway comparison.
A short checklist:
- Re-fetch official prices monthly, and diary every promotion end date.
- Measure tokens per task on each candidate model with real prompts.
- Keep prompts below 100K (Haiku 5.5), 200K (Gemini Pro, Grok) or 272K (OpenAI) where possible.
- Track cache-hit ratio and reasoning tokens as first-class metrics.
- Move non-urgent jobs to batch, Flex or DeepSeek off-peak windows.
- Budget a 10% uplift for regional or US-only processing.
- Model self-hosting only above roughly 50% sustained GPU utilization.
Frequently Asked Questions
What is the cheapest LLM API pricing in November 2026?
On LLM cost per million tokens for short prompts, GPT-6 Luna and Claude Haiku 5.5 both cost $0.10 per million input tokens and $0.50 per million output tokens. Gemini 2.5 Flash-Lite is cheaper on output at $0.40, and Ministral 3 8B is cheapest on output at $0.15. With caching, DeepSeek’s deepseek-flash has the lowest cache-hit rate at $0.003 off-peak. The cheapest option depends on your input-to-output ratio and cache hit rate, so run your own token counts through each rate card rather than picking by headline price.
How much does the OpenAI API cost per million tokens?
On November 15, 2026, OpenAI API pricing for its current lineup is $10 input and $50 output for GPT-6 Astra, $2 and $10 for GPT-6.1 Sol, $1 and $5 for GPT-6.1 Terra, and $0.10 and $0.50 for GPT-6 Luna. Cached input runs from $0.01 to $1.00. Batch and Flex cost 50% of standard, while Fast mode costs 2x. Prompts above 272K input tokens pay 2x input and 1.5x output for the whole request on the models whose pages we checked.
How does Claude API pricing compare with Gemini API pricing?
Claude Sonnet 5.5 costs $2 input and $10 output, flat to 1M tokens. Gemini 3.1 Pro Preview costs $2 and $12 below 200K and $4 and $18 above it. At the top end, Claude Opus 5.5 at $4/$20 matches Gemini 4 Argon’s post-December 1 price exactly; until November 30, Argon’s introductory rate is half that. Claude’s cache reads are cheaper on its latest models, at $0.10 to $0.20, while Gemini explicit caches add an hourly storage fee.
Does batch processing really cut LLM costs in half?
At OpenAI, Anthropic, Google and Mistral, yes: their published batch rates are 50% of standard on input and output. xAI’s batch discount is 20% on Grok 4.3 through 4.7, and grok-build-0.1 has none. DeepSeek publishes no batch tier but halves all prices outside its weekday peak windows. Batch jobs complete asynchronously, so they suit evaluation runs, backfills, classification and embedding-style enrichment, not interactive traffic. Anthropic’s fast mode cannot be combined with batch.
Why does my long prompt cost more than the per-token price suggests?
Most vendors reprice the whole request once a prompt crosses a threshold. OpenAI’s step is at 272K input tokens, Google’s Gemini 3.1 Pro and xAI’s Grok models step at 200K, and Claude Haiku 5.5 steps at 100K. On GPT-6.1 Sol, a 275K-token prompt costs about twice a 270K-token one. Claude Opus 5.5 and Sonnet 5.5 have no step up to 1M tokens. Check whether your retrieval pipeline routinely pushes prompts just over one of these lines.
When is self-hosting cheaper than an LLM API?
Only when sustained utilization is high and the API price is well above hardware cost. With illustrative throughput of 10,000 output tokens per second on an 8×H100 neocloud node, you need about 81% round-the-clock utilization to match deepseek-flash’s $1.20 peak output price, but only 25% to match DeepSeek V4 Pro’s $3.96. Against GPT-6 Luna’s $0.50, self-hosting on that node does not win. Large open-weight models such as Mistral Large 4 also need B200-class memory.
Further Reading
- Cloud GPU pricing for November 2026: H100, H200, B200 and MI300X per-hour costs — the hardware side of the self-hosting break-even.
- Offline batch LLM inference: provider batch APIs versus self-hosted vLLM — throughput and scheduling for the 50% tier.
- Prompt caching economics: explicit versus implicit caching, TTLs and break-even math — the full model behind the cache-read lever.
- LLM token economics and gross margin of AI features — turning per-token prices into product margins.
- Anthropic Claude API pricing documentation and OpenAI API pricing — the primary sources to re-check before you commit a budget.
By Riju — about
