The market splits into frontier-lab APIs (Anthropic, OpenAI), open-model speed shops (Fireworks, Together, Baseten, DeepInfra, Groq), raw serverless GPU platforms (Modal), aggregators (OpenRouter), and workbench-fused offerings. On the open-model side, list prices are now nearly identical: Fireworks, Together, and Baseten all charge $1.40 in / $4.40 out per million tokens for GLM 5.2 and $3.00 / $15.00 for Kimi K3, checked August 2026. DeepInfra undercuts them by roughly 5 percent. That makes throughput, time to first token, and catalog the real differentiators.
- List prices have converged. Fireworks, Together, and Baseten quote the same $1.40 / $4.40 for GLM 5.2. Do not shop on price alone.
- Frontier models are single-source. Claude Sonnet 5 is $2 / $10 per million and only Anthropic and its cloud partners sell it.
- Groq is the throughput outlier: 1,000 tokens/sec on gpt-oss-20b, and it publishes the number.
- Modal is not a token API at all. It bills per GPU second, from $0.000164/sec on a T4.
- OpenRouter adds no inference markup. It takes 5.5 percent on Stripe credit purchases instead.
- For coding agents, the axis that matters is agent-turn latency, not headline $/Mtok.
The five kinds of inference provider
"Inference provider" covers companies with genuinely different business models, and comparing them on a single price column produces nonsense. Sort them first, then compare inside a tier.
| Tier | Who | Billing unit | What you are buying |
|---|---|---|---|
| Frontier-lab APIs | Anthropic, OpenAI, Google | Per token | Models nobody else can serve. Single source, no price competition. |
| Open-model speed shops | Fireworks, Together, Baseten, DeepInfra, Groq | Per token | Someone else's open weights, served fast. Interchangeable on paper. |
| Serverless GPU platforms | Modal, RunPod | Per GPU second | Compute. You bring the model, the server, and the container. |
| Aggregators | OpenRouter | Per token, passthrough | One key and one endpoint across hundreds of models and dozens of upstreams. |
| Workbench-fused | Continuum and similar | Flat monthly with an allowance | Inference bundled into the tool the tokens are spent from. |
The tier boundary that catches people out is the third one. Modal and RunPod do not sell you a model. They sell you a container with a GPU attached, priced by the second, and everything above that line is your problem: weights, server, batching, autoscaling, and the on-call rotation when it falls over. That is the right trade for a fine-tune or an embedding batch and the wrong one for "I want a chat completions endpoint by lunchtime."
What the same model costs at each provider
Three models are served by nearly everyone in the open tier, which makes them a fair yardstick. All figures below were read from each vendor's own pricing page in August 2026, and they are per million tokens, input first.
| Provider | DeepSeek V4 Flash | GLM 5.2 | Kimi K3 |
|---|---|---|---|
| Fireworks | $0.14 / $0.28 | $1.40 / $4.40 | $3.00 / $15.00 |
| Together | $0.14 / $0.28 | $1.40 / $4.40 | $3.00 / $15.00 |
| Baseten | $0.13 / $0.26 | $1.40 / $4.40 | $3.00 / $15.00 |
| DeepInfra | $0.09 / $0.18 | Not listed | $2.85 / $14.25 |
| OpenRouter | Upstream price, no markup | $1.40 / $4.40 | Upstream price, no markup |
DeepInfra is the exception, undercutting by roughly 5 percent on Kimi K3 and by about 35 percent on DeepSeek V4 Flash. That discount is real, and so is the reason for it: DeepInfra competes on price where the others compete on latency and support. If your workload is a batch job that nobody is watching, the cheap row is the right row. If it is an interactive agent, buy the latency.
The frontier tier does not have a price column
Claude and GPT models are single-source. There is no shopping around, only choosing which frontier model you can afford.
| Model | Input | Cached read | Output |
|---|---|---|---|
| Claude Opus 5 | $5.00 | $0.50 | $25.00 |
| Claude Sonnet 5 | $2.00 | $0.20 | $10.00 |
| Claude Haiku 4.5 | $1.00 | $0.10 | $5.00 |
| gpt-5.6-sol | $5.00 | $0.50 | $30.00 |
| gpt-5.6-terra | $2.00 | $0.20 | $12.00 |
| gpt-5.6-luna | $0.20 | $0.02 | $1.20 |
Two footnotes that change the arithmetic more than the headline rates do. Anthropic prices the full 1M-token context window at the standard rate on Claude 4.6 and later, so a 900k-token request costs the same per token as a 9k one. OpenAI does not: on the GPT-5.6 family, requests past 272K tokens pay double on input and 1.5x on output, so gpt-5.6-sol becomes $10.00 / $45.00. For a long-running coding agent that accumulates context, that surcharge is a bigger line item than the choice of provider.
Scoring a provider on the things that are not price
Since price has converged, here are the five axes that still separate them, and how each tier actually performs on each.
| Fireworks | Together | Baseten | DeepInfra | Groq | Modal | |
|---|---|---|---|---|---|---|
| Price | Market rate | Market rate | Market rate | Cheapest | Cheap on small models | Per GPU second |
| Speed | Fast and Priority tiers sold separately | Good | Best published TTFT | Average | Fastest throughput | Depends on your code |
| Catalog | Broad, plus per-size fallback pricing | Broadest, plus image, video, audio | 12 models on the API | Broad, includes Claude and Gemini passthrough | Two text models | Anything you can containerize |
| Free tier | $1 in credits | None published | Credits on signup | None published | Free tier with rate limits | $30/month credits |
| Ops burden | None | None | None on the API, real on dedicated | None | None | All of it |
Speed is the one with published numbers
Artificial Analysis measures every provider on the same 60-prompt set and publishes both throughput and time to first token. On the August 2026 board, Groq led output speed at 457 tokens per second (Qwen3.6 27B), with Nebius at 453 on Nemotron 3 Ultra, Google at 372 on Gemini 3.7 Flash, and Databricks at 347 on GLM 5.2. The lowest time-to-first-token figures cluster near half a second, with Baseten posting 0.49 seconds on Inkling Small.
Those are two different races, and which one you care about depends entirely on the shape of your workload. See tokens per second versus time to first token for why an agent that runs twenty tool calls per task is bound by the second number and a chat UI is bound by the first.
Free tiers are mostly a formality
Fireworks gives $1 in credits and then requires a payment method. Together publishes no ongoing free credit on its pricing page as of August 2026. Modal is the genuine outlier: the Starter plan is $0 per month and includes $30 of compute credits every month, renewed, which is enough to run real embedding jobs indefinitely. OpenRouter grants 50 free-model requests per day, rising to 1,000 per day once you have purchased at least $10 in credits.
Which one for a coding agent
Coding agents are an unusual inference workload and most provider marketing is not written for them. A single task is a long chain of short model calls separated by tool execution: read a file, think, run a test, read the failure, patch. Three consequences follow.
- Per-turn overhead dominates. Twenty turns at 0.8s of time-to-first-token is 16 seconds of pure waiting, which the user experiences as the agent being slow no matter what the tok/s figure says.
- Cache pricing is the real bill. The system prompt, the repo context, and the transcript are resent every turn. A provider charging 10 percent of input for cache reads (Anthropic) versus 20 percent (some open shops) changes the monthly total more than a 5 percent list-price gap.
- Frontier quality still wins on hard edits. A cheap model that makes a wrong patch costs you a whole turn plus the human review, which is more expensive than the tokens it saved.
Practically: run the cheap open models for mechanical work (renames, test scaffolding, docstrings) and a frontier model for anything requiring judgment. That is exactly what a router does, and it is why model routing pays off faster on agent traffic than on chat traffic. Which cheap model is good enough is an empirical question rather than a price question: our coding-model leaderboard puts each model's measured pass rate next to its cost per task, and every model card carries the rows behind it.
When you do not need one of these at all
Three cases where hiring an inference provider is the wrong move.
- You already pay a subscription. Claude Max and similar plans include a large usage allowance at a flat price. Buying tokens on top of an underused subscription is paying twice. Check the crossover arithmetic before adding an API bill.
- Your volume is trivial. Under roughly a million tokens a month, every option costs less than a lunch and the correct optimization is to stop optimizing.
- The model fits on hardware you own. A 4B model doing classification runs fine on a laptop or a single old GPU. Per-token pricing on tiny models exists because it is convenient, not because it is cheap: Fireworks charges $0.10 per million for anything under 4B parameters, which is real money at scale for a job an idle machine could do for free.
Questions people ask
What is an inference provider?
A company that runs a trained model on its own hardware and sells you access to it over an API, usually billed per million tokens. The term covers frontier labs selling their own models (Anthropic, OpenAI), companies serving open weights that somebody else trained (Fireworks, Together, Baseten, DeepInfra, Groq), and platforms that rent you the GPU and let you serve the model yourself (Modal, RunPod).
Which inference provider is cheapest?
For open models, DeepInfra had the lowest published rates in August 2026: $0.09 in / $0.18 out per million for DeepSeek V4 Flash against $0.13 to $0.14 in at Fireworks, Together, and Baseten, and $2.85 / $14.25 for Kimi K3 against $3.00 / $15.00 elsewhere. Every provider also discounts batch work by 50 percent, so an asynchronous job at the market rate beats an interactive one at the cheap rate.
What is the best inference provider for speed?
Groq for raw throughput, at a published 1,000 tokens per second on gpt-oss-20b and 500 on gpt-oss-120b, and 457 tok/s measured by Artificial Analysis on Qwen3.6 27B in August 2026. Baseten posts the lowest time to first token on that same board at 0.49 seconds. Which matters depends on your workload: long single answers want throughput, agent loops want low TTFT.
Is OpenRouter cheaper than going direct to a provider?
No, and it does not claim to be. OpenRouter passes upstream prices through with no inference markup and makes its money on credit purchases instead: 5.5 percent on Stripe with a $0.80 minimum, or 5 percent on crypto. You pay that fee for one key across hundreds of models and automatic failover between upstreams, which is a fair trade for breadth but not a saving.
Do I need an inference provider if I already pay for Claude Pro or Max?
Usually not for interactive work. A subscription bundles a usage allowance at a flat price, and the marginal turn costs nothing until you hit the cap. Adding a metered API bill on top is worth it only for workloads a subscription cannot serve: batch jobs, production traffic from your own product, or models the subscription does not include.
What is the difference between serverless inference and a serverless GPU platform?
Serverless inference sells you a model behind an endpoint and bills per token; you send a prompt and never think about hardware. A serverless GPU platform like Modal sells you a container with a GPU attached and bills per second; you supply the weights, the server process, and the scaling logic. The second is cheaper at very high sustained utilization and far more work at any utilization.
Sources
Every figure above was read from these pages on August 2026. Vendors reprice without notice; if you find a stale number, tell us.
- Fireworks serverless pricing Standard, Priority, and Fast per-model rates
- Together AI pricing serverless, GPU cluster, and dedicated rates
- Baseten pricing Model API rates and per-minute GPU pricing
- DeepInfra pricing per-model rates and GPU hourly rates
- Groq models and pricing published tokens/sec and per-model rates
- Modal pricing per-second GPU rates and plan credits
- Claude API pricing model rates, caching multipliers, batch discount
- OpenAI API pricing GPT-5.6 family rates and long-context surcharge