Open model API prices per million tokens, November 2026, and when a rented GPU beats them

On 7 November 2026, gpt-oss-120b cost $0.015 per million input tokens and $0.057 per million output tokens at its cheapest listing (PrimeIntellect on OpenRouter, FP4) and $0.15 and $0.60 at Together, Fireworks and Groq. DeepSeek V4.1 Flash ran from $0.051 and $0.203 (Baidu on OpenRouter) to $0.30 and $1.20. At those prices a rented DGX Spark at $0.79 an hour beats the cheapest API only for some models, and only when kept about half busy or more; a rented RTX 5090 serving one user never does.

• gpt-oss-120b: $0.015 / $0.057 (cheapest) to $0.35 / $0.75 (Cerebras), input / output per million tokens.
• DeepSeek V4.1 Flash: $0.051 / $0.203 to $0.30 / $1.20.
• Kimi K3: $3.00 / $15.00 at most providers; output is the expensive side.
• Break-even, Qwen3-Coder-30B-A3B on one Spark: about 45 million output tokens a day against the cheapest API, 48% of measured capacity.

What do open-weight models cost per million tokens?

Under $1 of output per million tokens for most models that fit one GPU, and $4 to $15 for the largest. Each figure below comes from the provider's own pricing page or, for the "cheapest" column, from OpenRouter's per-provider endpoint listing, read on 7 November 2026. All prices are USD per million tokens, input / output.

Checked 7 November 2026. Sources: OpenRouter models API and its per-model endpoint lists, Together, DeepInfra, Fireworks, Groq models, Cerebras and Novita. "Cheapest" means the lowest output price among OpenRouter's endpoints for that model. "Via OpenRouter" means the provider's endpoint appears on OpenRouter but not on its own pricing page. Groq's own docs list Llama 3.3 70B as "ContactSales" and Qwen3.8-27B as a preview model. Licenses as tagged on each Hugging Face model card. Discounts were labeled as such on DeepInfra's page and may end.

What is the cheapest gpt-oss-120b API?

PrimeIntellect's FP4 endpoint on OpenRouter at $0.015 and $0.057, about a tenth of the mainstream $0.15 and $0.60. Across OpenRouter's 26 endpoints for the model, output ran from $0.057 to $0.95 per million tokens. DeepInfra's own model page lists $0.037 and $0.17 and labels the deployment bfloat16, with MoE layers in native MXFP4. Groq lists the model at 500 tokens per second and Cerebras at about 3,000, which is what Cerebras's $0.35 and $0.75 buy: the same weights, delivered six times faster than Groq.

The model is Apache 2.0 on its Hugging Face card, so you can also run it yourself; it fits one 128 GB DGX Spark at MXFP4, as the gpt-oss-120b on DGX Spark page shows.

What is the cheapest DeepSeek API?

For DeepSeek V4.1 Flash, Baidu's endpoint on OpenRouter at $0.051 input and $0.203 output. The mainstream price is $0.30 and $1.20 at Together, Fireworks and Novita. DeepInfra showed two snapshots with different discounts: V4.1-Flash at $0.14 and $0.42 (30% off) and the newer V4.1-Flash-1017 at $0.098 and $0.294 (51% off). Together charges $0.006 for cached input, so a long system prompt reused across calls costs almost nothing after the first request.

DeepSeek V4 Pro costs roughly two to six times more on output: $0.595 and $1.19 at Baidu, $1.30 and $2.60 at DeepInfra, $1.60 and $3.20 at Novita. Both are MIT-licensed on Hugging Face, but neither official checkpoint fits one 128 GB Spark; the DeepSeek-V4-Flash page covers what one and two Sparks can run of the earlier Flash release.

Why does one model cost ten times more at another provider?

Four reasons, visible in the listings. First, quantization: OpenRouter tags each endpoint, and the cheapest ones for gpt-oss-120b, GLM-5.3 and Kimi K3 are FP4 while others run FP8 or BF16. Second, speed: Cerebras and Groq price for tokens per second, not per token. Third, discounts and snapshots: DeepInfra's GLM-5.3 at $0.5625 and $2.50 was a 38% promotion on 7 November. Fourth, caching and batch tiers: Fireworks charges $0.015 for cached gpt-oss-120b input against $0.15 uncached, and OpenRouter lists separate ":batch" variants for several models.

Output tokens decide most bills. Verda's inference page states that reasoning tokens are billed as output tokens, which is the norm, so a model that thinks for 2,000 tokens before a 300-token answer is billed for 2,300 output tokens. Kimi K3's $15 output price makes that expensive fast; the reasoning token budget article covers how to cap it.

When does a rented DGX Spark beat the API?

When the model runs fast on the Spark and you keep it busy for most of the day. The arithmetic, using GPUwerk's $0.79 hourly rate and published throughput for the same model:

1. Hardware cost per million output tokens = hourly rate / (output tok/s x 3,600 / 1,000,000).
2. API cost for the same work = output price + (input tokens per output token x input price), at the benchmark's own input to output ratio.
3. Break-even output tokens per day = 24 x hourly rate / API cost from step 2. Divide by the machine's daily capacity (output tok/s x 86,400) to see how busy it must be.

Worked example, Qwen3-Coder-30B-A3B. GPUwerk measured 3,235 tok/s total at 256 concurrent requests on one Spark (vLLM 0.27.1, AWQ, 512 tokens in and 256 out, 2 September 2026); generated tokens alone were 1,078 tok/s, per the benchmark logs. Step 1: 1,078 x 3,600 = 3.88 million output tokens an hour, so $0.79 / 3.88 = $0.20 per million output tokens, with the 2 million input tokens included. Step 2: SiliconFlow's $0.28 + 2 x $0.07 = $0.42. Step 3: $18.96 a day / $0.42 = 45.1 million output tokens a day, which is 48% of the 93.1 million the Spark produced at that load.

My calculation from the prices in the first table and the cited throughput. Dendro Logic labels its figure "aggregate TPS" without saying whether input is counted; its concurrency-1 value of 33.5 tok/s matches a decode speed, so I treat it as generated tokens. Real traffic with longer prompts lowers throughput, and idle hours on a 24-hour rental raise the hardware cost per token.

Two of three cases end in "never" against the cheapest API, and the third needs the Spark half-busy around the clock. A sparse model with about 3B active parameters is the Spark's best case. A dense 70B is its worst: at 162 tok/s for the whole machine, DeepInfra's $0.32 output price beats it at any load. The method in on-premise vs cloud API cost is the same; the table just fills it with today's prices.

When does a rented RTX 5090 beat the API?

Not for one user. The llama.cpp maintainers' gpt-oss guide reports an RTX 5090 at 282.5 tok/s generation and 9,848 tok/s prompt processing on gpt-oss-20b (MXFP4, build 6210, discussion #15396). One million output tokens plus two million input tokens take 3,540 + 203 seconds, 1.04 hours, which is $0.93 at $0.89 an hour. The same mix costs $0.20 at DeepInfra's $0.03 and $0.14, and $0.45 at Groq.

To break even, the card has to generate at least 549 tok/s sustained against Groq's price, or 1,236 tok/s against DeepInfra's, by my arithmetic. That means batched serving with vLLM or SGLang at real concurrency, kept up all day. I have not found a published RTX 5090 concurrency run for gpt-oss-20b that I could check, so measure it before you plan on it. Against PrimeIntellect's $0.004 and $0.017, the card would need almost 9,900 tok/s, which no single consumer GPU will reach on this model.

What does the per-token price leave out?

Who can read the prompts, where they are processed, and whether the model behind the name changes. An API endpoint can swap snapshots, as DeepSeek's V4.1-Flash and V4.1-Flash-1017 listings show, or change quantization between providers. A rented machine runs the exact weights you load and keeps prompts on one tenant's hardware. The Together AI and Groq comparisons cover data handling for two of the providers above.

My verdict: for prototyping and spiky traffic on any model in the table, use the API, and pick the provider by output price and quantization, not by brand. Rent a Spark when you have a sparse model, a steady queue that keeps it at least half busy, or a data rule that forbids shared endpoints. The GPU rental vs API cost guide adds ops time and idle hours to that decision.

FAQ

Sources

Every figure above is attributed to its source in the sentence or table where it appears. Pages were read on 7 November 2026 unless a date says otherwise.

• Models API and per-model endpoints (gpt-oss-120b, gpt-oss-20b, DeepSeek V4.1 Flash, V4 Pro, Qwen3.8-27B, Qwen3-Coder-30B-A3B, Llama 3.3 70B, Kimi K3, GLM-5.3, GLM-5.3-Flash, MiniMax M3), OpenRouter
• gpt-oss-120b endpoints, OpenRouter
• Pricing, Together AI
• Pricing, DeepInfra
• openai/gpt-oss-120b, DeepInfra
• Pricing, Fireworks AI
• Supported models, GroqCloud docs
• Pricing, Cerebras
• Models overview, Cerebras inference docs
• Pricing, Novita AI
• Pricing (inference), Verda
• NVIDIA DGX Spark concurrency benchmark, Dendro Logic, 2026-04-22
• guide: running gpt-oss with llama.cpp, ggml-org/llama.cpp discussion #15396, 2025-08-18
• openai/gpt-oss-120b model card, Hugging Face
• deepseek-ai/DeepSeek-V4.1-Flash model card, Hugging Face
• moonshotai/Kimi-K3 model card, Hugging Face
• zai-org/GLM-5.3 model card, Hugging Face
• MiniMaxAI/MiniMax-M3 model card, Hugging Face
• Qwen/Qwen3.8-27B model card, Hugging Face