Short answer: right now, the cheapest inference available is an open-weight model on DeepInfra, Novita, or OpenRouter, starting at 4 cents per 1M output tokens for tiny models and staying under a dollar all the way up through DeepSeek-V3. Frontier closed models from the major labs cost 10 to 30 dollars per 1M output tokens by comparison, roughly 100 to 500 times more per token. The table below is pulled straight from the numbers our live rankings use, re-checked weekly across 88 models.
The cheapest inference right now, by model
Per 1M output tokens, cheapest verified endpoint from our latest check:
| Model | Cheapest price | Where | Tier |
|---|---|---|---|
| Mistral Nemo | $0.04 | DeepInfra | Tiny |
| Llama 3.1 8B | $0.05 | DeepInfra, Novita | Small |
| gpt-oss-20b | $0.14 | DeepInfra | Mid |
| gpt-oss-120b | $0.17 | DeepInfra | Large |
| Llama 4 Scout | $0.30 | DeepInfra | Large |
| Llama 3.3 70B | $0.32 | OpenRouter | Very large |
| DeepSeek-V3 | $0.89 | DeepInfra | Flagship-class open |
| DeepSeek-R1 | $2.15 | DeepInfra | Reasoning |
These figures come directly from the same source-of-truth pricing data behind the Perkstack rankings, which re-checks 88 model tables weekly. Treat the live table as authoritative; a printed number in any blog post, including this one, can be weeks stale by the time you read it.
Why "cheapest" is a model question, not a brand question
The most expensive mistake in picking an inference provider is treating it as a single decision. It is not. The market has split cleanly into two tiers:
- Frontier closed models (the flagship models from the major labs) are priced by the maker directly, with no third-party host serving the same weights. You pay whatever that lab charges, full stop.
- Open-weight models are served by a dozen or more competing hosts running the exact same weights, and the price for the identical output can differ by 2 to 4 times between providers, occasionally 7 times on models we track. Picking the host, not the model, is where the savings live.
That means the real question behind "cheapest inference" is almost always "cheapest for which model," and the answer changes per model, sometimes month to month. For the full methodology behind how these numbers are checked and normalized, see cheapest AI inference API.
The 2026 gap between open and frontier
The spread this year is stark enough to change how most teams architect their stack. A tiny open model at 4 cents per 1M output tokens costs roughly 0.2 to 0.4 percent of a frontier flagship at 10 to 30 dollars. Even DeepSeek-R1, a full reasoning model, lands at $2.15, still a fraction of frontier pricing. The practical implication: if your workload does not specifically need frontier-level reasoning or the newest closed model's capabilities, the cheapest inference option is almost always an open-weight model on a discount host, not a smaller tier from a closed-model vendor.
The providers that keep winning
Three names dominate the cheap side of the table in 2026:
- DeepInfra, the single most frequent cheapest-endpoint winner across the models above. See the full breakdown in DeepInfra pricing in 2026.
- Novita, consistently within cents of the leader across a wide open-model catalog, and the co-winner on Llama 3.1 8B. See Novita AI pricing in 2026.
- OpenRouter, an aggregator rather than a direct host, which sometimes routes below every direct provider (as it does on Llama 3.3 70B above) and whose free routes are unbeatable for development traffic.
Groq and Cerebras are worth naming even though neither leads this particular table: both post the fastest tokens-per-second in third-party throughput benchmarks, often several times a standard GPU-backed endpoint, but they are rarely the cheapest price per token. If your bottleneck is a user waiting on a streaming response rather than a monthly bill, that trade is often worth making; the Groq startup program is one way to access that speed at a discount while you evaluate it.
Applying this table today: the switch is usually one line
Because open-weight models are the same weights served by every host, moving from one provider to a cheaper one for a specific model is typically a base URL and API key change, not a rewrite, since most of these hosts expose an OpenAI-compatible endpoint. The practical sequence:
- Pick your model first, based on capability, not price. Decide what quality bar the task actually needs.
- Look up that exact model in the live rankings. Find the current cheapest verified endpoint, not the one you assumed was cheapest last month.
- Point your existing SDK at the new base URL. Most of the providers above are OpenAI-compatible, so this is a small config change.
- Run a day of real traffic before moving volume. Occasional differences in quantization or rate limits show up fastest in production-shaped traffic, not a quick test call.
- Re-check monthly. Our last weekly pass corrected 36 prices across the 88 model tables we track, some by 2x or more in either direction, so a host that wins today is not guaranteed to win in a quarter.
Price is not the only cost
A cheap per-token rate does not automatically mean a cheap bill. Three things quietly change the real cost:
- Rate limits. A host that throttles you into retries under real load is not actually cheap; check the advertised limits at your usage tier before committing volume.
- Quantization and quality drift. Some discount hosts serve more aggressively quantized weights. For most product tasks this is invisible; for evals or precision-sensitive work, test before switching.
- Startup credits stack on top. Whatever the per-token price, a startup credit grant from a provider like Groq's $10,000 program or Anthropic's startup credits covers real months of usage before any of this table matters. Check the startup credits checklist before you spend cash on inference you could be covering with a credit grant instead.
What "cheap" looks like for a real workload
The table above is per 1M output tokens, but very few products spend evenly across input and output. A chat feature with short prompts and long generations is dominated by the output rate; a summarization or extraction task with long inputs and short outputs is dominated by the input rate, which is typically priced lower across every provider we track. Before picking a model purely off the output-token column above, estimate your actual input-to-output ratio for the workload in question, since that ratio can change which host is actually cheapest for you even when the published output rate looks identical.
The other variable that changes the real-world number is batching. Several providers, including the frontier labs, offer a batch or asynchronous mode at roughly half the synchronous rate for workloads that do not need an immediate response: backfills, evals, and offline scoring are the obvious candidates. Combined with routing to the cheapest open-weight host for the model tier you need, batch discounts are the fastest way to cut an inference bill that looks fixed at first glance.
Bottom line
Cheapest inference right now, in 2026: tiny and small open-weight models from 4 to 5 cents per 1M output tokens on DeepInfra or Novita, mid and large open models from 14 cents to under a dollar, and open reasoning models like DeepSeek-R1 still well under frontier pricing at $2.15. Frontier closed flagships remain 10 to 30 dollars per 1M output tokens for comparison. Pick the model for the task, take the cheapest verified host for that exact model from the live rankings, and read the full cheapest-inference methodology for how these numbers are checked. Create a free Perkstack account to track startup credits alongside the live price table.
Related reading: cheapest AI inference API, LLM API pricing comparison, the cheapest way to run LLMs.