Open Source LLM Pricing Comparison

Snapshot used in this guide

Rates come from data/ai-provider-pricing.json, generated at 2026-08-22T10:54:07.443Z. GPU rental rates come from data/gpu/gpu-pricing.json, generated at 2026-08-22T14:22:27.451Z. Throughput measurements come from data/gpu/gpu-throughput.json, generated at 2026-07-09T12:35:09.683Z. Architecture facts come from data/gpu/open-model-specs.json, generated at 2026-08-04T06:48:51.735Z. Confirm rates on provider pages before buying, since this guide does not recheck live pages.

API rates in the snapshot

All rates are USD per 1M tokens. Each row names the exact provider and model record.

Model	Record	Input	Output	Cache read	Context
`qwen-turbo`	`alibaba`	`0.05`	`0.20`	unknown	`1,000,000`
`open-mixtral-8x7b`	`mistral`	`0.70`	`0.70`	unknown	`32,000`
`MiniMax-M2.5`	`minimax`	`0.30`	`1.20`	`0.03`	`204,800`
`deepseek-v4-flash`	`deepseek`	`0.44`	`1.32`	`0.014`	`1,000,000`
`kimi-k2.5`	`moonshotai`	`0.60`	`3.00`	`0.10`	`262,144`
`qwen3.5-397b-a17b`	`alibaba`	`0.60`	`3.60`	unknown	`262,144`
`glm-5`	`zhipuai`	`1.00`	`3.20`	`0.20`	`204,800`
`glm-5.2`	`zhipuai`	`1.40`	`4.40`	`0.26`	`1,000,000`

unknown means the committed record carries no cache-read rate for that row. Context windows range from 32,000 tokens for Mixtral 8x7B to 1M for DeepSeek V4 Flash, GLM-5.2, and Qwen Turbo, so check fit before comparing prices.

Equal-workload math

One shared unit keeps versions comparable, 1M input tokens plus 1M output tokens:

qwen-turbo: 0.05 + 0.20 = $0.25
open-mixtral-8x7B: 0.70 + 0.70 = $1.40
MiniMax-M2.5: 0.30 + 1.20 = $1.50
deepseek-v4-flash: 0.44 + 1.32 = $1.76
kimi-k2.5: 0.60 + 3.00 = $3.60
qwen3.5-397b-a17b: 0.60 + 3.60 = $4.20
glm-5: 1.00 + 3.20 = $4.20
glm-5.2: 1.40 + 4.40 = $5.80

A documentation workload of 50M input and 10M output tokens per month preserves the ordering while showing scale:

deepseek-v4-flash: 50 × 0.44 + 10 × 1.32 = 22.00 + 13.20 = $35.20
kimi-k2.5: 50 × 0.60 + 10 × 3.00 = 30.00 + 30.00 = $60.00
MiniMax-M2.5: 50 × 0.30 + 10 × 1.20 = 15.00 + 12.00 = $27.00

Caching changes repeated-prefix workloads the most. One million repeated input tokens cost 1,000,000 ÷ 1,000,000 × 0.014 = $0.014 as cache reads on deepseek-v4-flash, against $0.44 uncached. The same million costs $0.10 cached on kimi-k2.5 and $0.03 on MiniMax-M2.5. Cache behavior belongs in every comparison with long shared prefixes.

Self-host math, modeled

Throughput measurements and modeled cost stay in separate steps. The committed throughput file records the Kimi K2.5 class (kimi-k2-5) at 260.58 decode tokens per second per GPU on h200-sxm-141gb with vLLM, int4, 1k input and 1k output tokens, and concurrency 64. The GPU catalog records a $4.59 median hourly rate per H200 GPU across 216 records. The modeled chain runs:

260.58 × 3,600 = 938,088 output tokens per GPU hour, about 0.94M.

4.59 × 730 = $3,350.70 per GPU for a 730-hour month.

938,088 × 730 = 684,804,240 tokens per month at full use, about 684.8M.

3,350.70 ÷ 684.80 = $4.89 per 1M output tokens at full use.

That modeled $4.89 already exceeds the $3.00 API output rate for kimi-k2.5 before staff time, replicas, or long-context slowdown. A second committed measurement is kinder to self-hosting: MiniMax-M3 records 2,814.84 decode tokens per second per GPU on b200 with vLLM and fp4, and the B200 median sits at $6.79 per hour, which models to $0.67 per 1M output tokens at full use and breaks even against the $1.20 API output rate near 56 percent sustained use. Measure the exact setup before trusting either sketch, since both lab rows used short 1k contexts at fixed concurrency.

When API pricing usually wins

API pricing often wins when traffic is small, bursty, or hard to predict, and when the team cannot operate inference around the clock. Managed caching, batch discounts, and high context windows add to the API side when reproducing them in house would cost more. Use the self-host versus API calculator with measured volume to test the call for a specific workload.

When self-hosting can win

Self-hosting can win with steady base load, a model that fits efficient hardware at an acceptable precision, high measured throughput, and strong sustained use. Data control and existing infrastructure operations point the same way. Size VRAM with the GPU VRAM fit calculator and convert GPU spend into cost per 1M output tokens with the open model token cost calculator before committing.

These throughput figures are normalized per GPU across a serving cluster. They do not imply the model fits on one GPU; total rental spend scales with the number of GPUs required. These output-only sketches exclude API input charges and are not complete service-cost comparisons.

Frequently asked questions

Are open source LLMs free to run?

No. Open weights do not guarantee free commercial use; check the license. Inference still needs GPUs, energy or rental spend, serving software, monitoring, failover, and engineering time.

Is self-hosting always cheaper than API pricing?

No. The Kimi K2.5 sketch above models $4.89 per 1M output tokens at full use against a $3.00 API rate, while the MiniMax-M3 sketch needs about 56 percent sustained use to match its API rate. Utilization and measured throughput decide.

Which snapshot row is cheapest for equal volumes?

Qwen Turbo at $0.25 per 1M input plus 1M output tokens, with Mixtral 8x7B next at $1.40. Both carry caveats, 32,000 context for Mixtral and unknown cache terms for Qwen Turbo, so confirm fit before choosing on price. Price says nothing about quality either way.

Open Source LLM Pricing Comparison: API Rates and Self-Host Math