LLM API Pricing Disparity: Same Model, Price Differences Up to 32x

Title

LLM API Pricing Disparity: Same Model, Price Differences Up to 32x

Meta Description

A pricing analysis of 375 models across 137 LLM API providers based on LiteLLM data: median price spread is 0%, but 11% of models have spreads exceeding 200%, with openai/gpt-oss-120b showing a 26.7x spread for the same model. This article breaks down the causes of price spreads, the most severe cases, and developer strategies for coping.

Article Content

The same open-source model, offered by a different API provider, can cost up to 32 times more. A pricing analysis covering 137 providers and 4,033 model entries reveals a contradictory market: the median price spread is 0%, yet the long tail is extremely fragmented. For developers relying on LLM APIs, choosing the wrong provider costs far more than imagined.

Market Overview: Zero Median Coexisting with an Extreme Long Tail

This analysis is based on LiteLLM's model_cost table, covering 4,033 model entries and 137 providers. After filtering to 375 models that have at least two providers and comparable input prices, a counterintuitive conclusion emerges: the median input price spread is exactly 0.0%. In other words, for most models, all providers charge exactly the same price per million tokens.

But in the same sample, 42 models (11%) have price spreads exceeding 200%. Another 13 models fall in the 100%–200% range, and 25 in the 50%–100% range. 72% of models have spreads within 20%, but the outliers are not edge cases—they are precisely the critical minority that will blow up your cost model if you choose the wrong provider.

Input price spread	Number of models	Percentage
>200%	42	11%
100-200%	13	3%
50-100%	25	7%
20-50%	25	7%
<20%	270	72%

LiteLLM and the model_cost table: LiteLLM is an open-source unified calling layer for LLM APIs that allows developers to call hundreds of models and providers through an OpenAI-compatible interface. The model_cost table in its repository is a community-maintained pricing database that records, per model, each provider's input/output price per million tokens, context window, and other metadata. The table is periodically scraped and merged from providers' public pages by scripts, so different entries are updated at different frequencies. This analysis is based on this table structure, filtering to the subset of models that have at least two providers and comparable input prices to compute the spread distribution. Note that the model_cost table is a community collaboration product, and individual entries may lag or contain input errors, but this does not affect the structural conclusion reflected by the 0.0% median.

Why Is the Median Zero?

The 0.0% median is not a rounding artifact but a structural norm of the market. The report's mechanistic explanation is quite direct: most inference providers are essentially reselling the same pool of upstream compute. They list the same base model, run on the same generation of GPU hardware, and pass through the same upstream cost per token. When input costs are identical, the reseller's profit margin becomes the only variable, and in a commoditized market, that margin is compressed to near zero.

The second mechanism is list-price resale. Many providers do not set prices independently but mirror the public prices of the model originator or the mainstream market. When a provider's only cost is the upstream API call, the rational move is to compete for traffic at a price equal to or slightly below upstream rather than invent a premium. This explains an easily misread phenomenon: on the surface, 137 providers and thousands of models look like ample competition, but most providers sit on the same price line—essentially a pass-through market where no one truly owns the compute.

Pass-through market: In economics, pass-through pricing means upstream cost changes are almost fully transmitted to downstream selling prices, with intermediaries earning only a razor-thin service or traffic fee. The LLM API resale market is a typical example of this model: providers buy inference compute in bulk from model originators or cloud platforms and retail it to developers at near cost. Because resellers face essentially the same upstream quotes and switching costs are low, any attempt to add a markup quickly loses customers, and profit margins are compressed to near zero by competition. This also explains why 137 providers and thousands of model entries appear highly competitive but actually cluster on the same price line—they are more like different outlets for the same upstream compute than truly independent pricing entities.

Where Do the Huge Spreads Come From?

Large spreads do not come from commoditized resellers but from two business models at opposite ends of the pricing spectrum.

The first category is GPU-hour hosts, such as crusoe and hyperbolic. They price by raw compute rather than by token inference. Users rent a GPU billed by the hour and can run any model. Their per-token input price depends on how fast the model runs on that hardware, not on a deliberately set inference price. Differences in data center utilization, electricity costs, and hardware generations cause the per-token cost of the same model to fluctuate wildly. The most extreme case is openai/gpt-oss-120b: wandb quotes $0.03/M input tokens, crusoe quotes $0.80/M—a spread of +2566.7%. The low price may come from loss-leader traffic acquisition or underutilized hosts, while the high price is a host fully marking up raw compute.

The second category is specialized inference providers, which run their own serving stacks, often with custom batching, quantization, or routing. They must cover not just GPUs but engineering costs. For example, mistral-large-latest is $0.5/M on Mistral's own platform but $8/M on Azure—a spread of +1500.0%. Mistral prices on its own hardware cost plus margin, while Azure charges a premium for enterprise SLA, technical support, and integration capabilities. The same model, the same weights, but completely different service packaging.

According to the analysis, the 42 models with spreads exceeding 200% almost all fall in comparisons between these two categories and cheap commodity resellers. They are not pricing errors but two different products sold under the same model name.

The difference between GPU-hour billing and per-token pricing: GPU-hour hosts rent out GPUs as raw compute units (e.g., A100/H100 billed by the hour), and users deploy models themselves and bear the engineering work of inference frameworks, batching, and autoscaling. Their "per-token price" is not actively set but derived from model throughput: the same GPU running different models generates different numbers of tokens per second, so the converted cost per million tokens naturally varies enormously. In contrast, per-token inference providers bundle hardware, scheduling, and operations into a unit price, so developers need not worry about underlying utilization. The two models serve different needs: the former suits users with engineering capability who want extreme cost efficiency or custom fine-tuning; the latter suits teams that want plug-and-play, pay-as-you-go service. The extreme values in the spread table are often the result of comparing these two pricing logics on the same dimension.

The Most Severe Cases in the Spread Table

Model	Number of providers	Lowest price	Highest price	Spread
Qwen/Qwen3-235B-A22B-Instruct-2507	3	$0.09/M (deepinfra)	$3/M (crusoe)	+3233.3%
openai/gpt-oss-120b	13	$0.03/M (wandb)	$0.8/M (crusoe)	+2566.7%
deepseekAd-ai/DeepSeek-R1-Distill-Qwen-14B	2	$0.07/M (nscale)	$1.6/M (together_ai)	+2185.7%
mistral-large-latest	3	$0.5/M (mistral)	$8/M (azure)	+1500.0%
Qwen/Qwen2.5-Coder-32B-Instruct	3	$0.06/M (nscale)	$0.8/M (together_ai)	+1233.3%
deepseek-ai/DeepSeek-R1-0528	5	$0.25/M (hyperbolic)	$3/M (crusoe)	+1100.0%
Qwen/Qwen3-235B-A22B	3	$0.18/M (deepinfra)	$2/M (hyperbolic)	+1011.1%
meta-llama/Llama-3.3-70B-Instruct-Turbo	2	$0.1/M (deepinfra)	$1.04/M (together_ai)	+940.0%

openai/gpt-oss-120b deserves particular attention: 13 providers span from $0.03/M to $0.8/M, roughly a 27x gap. Choosing a provider at random for this model is like flipping a coin between the cheapest and most expensive options in the dataset.

Three Things the Spread Table Doesn't Tell You

The limitation of short context. These prices are per-token input rates at short context lengths. Long-context requests are priced separately by many providers; that $0.03/M price is likely based on standard context, and long-context requests could push the price up by an order of magnitude. So the 2566.7% figure actually underestimates the real fluctuation in production workloads.

A snapshot, not a live quote. These prices are a data scrape at a point in time. Providers' public list prices change frequently, sometimes weekly. What looks like a 2566.7% anomaly today could become a 10% spread next week. The 0.0% median is robust to this, but the long tail is not.

Same-name models are not necessarily bit-identical. Providers may offer different quantization levels (FP16 vs. INT8) or different batch sizes under the same model name. Providers offering quantized versions can reasonably charge less because they use less memory and bandwidth. This also means the 270 models with spreads below 20% are a more reliable baseline, while for the 42 models with spreads over 200%, the model name may be the only thing they have in common.

The impact of quantization level on price: Quantization is the technique of compressing model weights from high precision (e.g., FP16) to lower precision (e.g., INT8, INT4), which significantly reduces memory usage and bandwidth requirements, thereby improving throughput and lowering costs, though it may cause slight quality loss. Providers often offer different quantized versions under the same model name without clearly labeling them in the API name, leading to "same name, different quality" when comparing prices. Therefore, the group of models with spreads below 20% is more suitable as a baseline, because their providers most likely run the same precision; while in cases with spreads over 200%, the low-price side may be undercutting precisely through quantization or more aggressive batching, and developers sensitive to output quality should verify actual inference precision and consistency beyond price comparison.

How Should Developers Respond

Before putting a model into production, first confirm whether it is offered by multiple providers. In the analysis, 382 models have two or more providers, and 375 have comparable input prices. Although the median spread is 0.0%, 42 models (11%) have spreads exceeding 200%. A simple provider price comparison query can tell you whether you are overpaying for nothing.

Switching providers often requires only a one-line code change: most OpenAI-compatible SDKs just need a different base_url and API key, with no need to refactor inference code or change prompt templates. The cost is at the operational level, including new rate limits, latency characteristics, and support SLAs. It is advisable to first run a smoke test on the cheaper endpoint before migrating production traffic. For cost-sensitive workloads, if the model is open-weight, the first step is always to enumerate providers and compare actual per-million-token prices rather than just looking at the model name.

On the data source side, LiteLLM's model_cost table provided the raw data for this analysis. It is rebuilt daily from per-provider price tables on each model page and can serve as a reference for ongoing price comparison.

One-line Summary

The LLM API market has a zero median spread but an extreme long tail; choosing the wrong provider can mean paying tens of times more.

Paragraph Summary

A pricing analysis covering 137 providers and 4,033 model entries shows that the LLM API market has a structure of coexisting zero median and extreme long tail: the median input price spread across 375 multi-provider models is 0.0%, but 11% of models have spreads over 200%, with the most extreme, openai/gpt-oss-120b, showing a 27x spread across 13 providers. The large spreads stem from two business models—raw-compute GPU-hour hosts and specialized inference platforms that charge a premium for SLA and integration—rather than pricing errors. The report also notes three hidden biases in the spread data: short-context limitations, point-in-time snapshots, and same-name models possibly having different quantization levels. It recommends that developers enumerate providers and compare prices before production, and run smoke tests on cheaper endpoints first.