Frontier LLM API providers

Every provider on this page will quote you a $/M token figure. Almost none of them will tell you how long the model behind it lives. That asymmetry is the single biggest hidden cost in this category, and it is why this page leads with a continuity column rather than a price column.

For most production work in 2026 the shortlist is short. Anthropic if the workload is agentic — tool calls, long multi-step runs, code — because effort control, prompt caching and MCP are first-class rather than bolted on. OpenAI if you need audio, image generation and text behind one billing relationship, or if your team is already fluent in the Responses API. Google if you need million-token context cheaply, native audio in and out, or an AU-resident deployment through Vertex. Those three are not interchangeable at the prompt level: a prompt tuned on one lands differently on the others, and the effort/thinking knobs have no common vocabulary.

The Chinese open-weight labs — DeepSeek, Moonshot, Qwen, Z.ai — have changed what the floor looks like. DeepSeek's flagship bills $0.42 per million output tokens against $50 for Claude Fable 5 and $15 for Claude Sonnet 5 — roughly a hundred and twenty times cheaper than Anthropic's top-end model, and still around thirty-five times cheaper than the volume tier most teams would actually reach for. For classification, extraction, summarisation and bulk rewriting the quality gap does not justify the price gap. The catch is governance, not capability: retention defaults are permissive, zero-data-retention is generally not on offer, and several expose only a rolling alias that silently upgrades under you. If the data is sensitive, run the weights yourself or route through a host that is contractually clean rather than calling the origin API.

Routers deserve more credit than they get. OpenRouter is the cheapest insurance policy in the category — one integration, hundreds of models, and a real chance that a retired model stays reachable somewhere because an open-weight copy is still hosted. Groq and Cerebras are not general-purpose substitutes; they are latency instruments. If your product's differentiator is that the answer appears instantly — voice, autocomplete, interactive search — they are worth an entire architecture. If it is not, their model menu will frustrate you within a quarter.

Where this is heading: prices keep falling, context windows have stopped being the differentiator, and the fight has moved to agentic fidelity — parallel tool calls that do not degrade, structured output that never breaks schema, caching that survives a long agent loop. Assume the model you ship on today will be retired inside two years. Build the abstraction layer now, keep an evaluation set you can re-run in an afternoon, and treat every provider on this page as replaceable.

Headline $/M is the least useful number in this category. Four things distort it.

First, output tokens dominate. A reasoning model can burn tens of thousands of thinking tokens before it writes a word you see, and those bill at the output rate. A provider with a cheap input rate and an expensive output rate is expensive for reasoning work and cheap for retrieval-augmented answering. Model your actual input:output ratio before comparing.

Second, cached input is where the real money is. Cache reads bill at roughly a tenth of the input rate at Anthropic and OpenAI, and an agent loop resending its history every turn is mostly cache reads. But caching is a prefix match — a timestamp in the system prompt, a non-deterministic JSON serialisation, or a tool list that varies per user destroys it silently. Watch the cache-read token counter, not the invoice.

Third, long-context surcharges. Google charges a higher rate above 200K tokens on its flagship; others quietly meter cache storage per hour. A million-token window advertised at the short-context rate is not what you will pay.

Fourth, batch — but check the column before you budget for it. Where an asynchronous endpoint exists the discount is usually a flat 50%, and Anthropic, OpenAI, Google, Mistral and Qwen all publish that rate, as do Bedrock and Together. It is not universal. DeepSeek offers no batch endpoint at all — its list price already sits below most competitors' batch rates — and neither does OpenRouter, which is a real cost if half your workload could tolerate async. xAI, Moonshot, Z.ai, Cohere, Fireworks and Cerebras publish nothing we could confirm, and Groq's batch discount is documented as existing without a percentage we could stand behind. Where the halving is there and part of your workload tolerates a few hours of latency, it is the one saving no negotiation will beat; where it is not, no amount of committed spend conjures it.

Assume an eighteen-month life for whatever you ship on. The providers that publish retirement dates are doing you a favour; the ones that don't are the ones that will break you.

Pin a dated snapshot wherever the provider offers one, and record the pin in configuration rather than code. Note that this is getting harder, not easier: Anthropic's current line-up ships as bare aliases with no dated model ID behind them, so 'pin the snapshot' is not always an available move any more, and you fall back on the published retirement date instead.

Keep the provider behind one seam. Not an abstraction that pretends every model is the same — that fails the moment you touch thinking blocks or tool-result shapes — but a single module that owns request construction, retry policy and response parsing per provider. Two implementations behind one interface is the cheap insurance; a universal adapter is the expensive fantasy.

Maintain an evaluation set you can re-run in an afternoon: fifty to two hundred real inputs with graded expected outputs. Without it, a forced migration becomes a multi-week vibe check. With it, a migration is a morning's work and a number you can defend.

Finally, know your escape hatch before you need it. For open-weight models it is total — the weights are on disk and vLLM will serve them for as long as you have GPUs. For closed models it is a router that may still have an upstream, or nothing at all.

Bulk text processing — classification, extraction, tagging, translation, summarising a firehose. Price dominates and capability differences barely register. DeepSeek, Qwen, Moonshot and Z.ai are the rational choices, or Groq and Together if you want open weights with a Western contract. Add the batch endpoint if latency is negotiable. Do not put sensitive data through a provider whose retention terms you haven't read.

Agent harnesses — a loop that plans, calls tools, reads results and iterates for minutes at a time. This is where the frontier labs earn their price. You need tool calls that stay well-formed at depth, structured output that is enforced rather than requested, an effort or thinking control so you can trade cost against quality per route, and prompt caching that survives the loop. Anthropic and OpenAI are the credible options; Google is close and cheaper on long context. Budget for the fact that a long agentic turn can now run for minutes on a single request.

Interactive, latency-critical UI — voice, live search, inline completion. Time to first token is the product. Cerebras and Groq are in a different class here, an order of magnitude ahead of first-party endpoints on tokens per second, and the constraint is that you take whichever open-weight models they have chosen to host. Design the feature around the model menu, not the other way around.

Pricing on this page is stale within a fortnight. That is not hedging — this category re-prices faster than any other on toolweight, so the page carries a seven-day verification cadence and every price cell is dated. Treat any cell whose date is more than a month old as indicative and click through to the vendor's pricing page before you build a forecast on it. Figures are pay-as-you-go list rates in USD per million tokens, before batch, cache or committed-spend discounts, and before any provider-specific long-context surcharge. One convention worth stating: where a vendor is running an unexpired introductory rate, the column carries the list price and the cell note carries the introductory rate and its expiry date. An introductory rate is not a discount you negotiate — it is what you actually pay today — so read the note before modelling a bill.

Entries here are providers, not models. Because a provider ships a dozen models at a dozen prices, every price, context and capability figure on a row describes that provider's current flagship model, named explicitly in the Flagship model column so no number is orphaned from the thing it measures. Compare rows knowing that a cheaper flagship often sits beside a cheaper mid-tier that would serve your workload better. The killer column, deprecation and continuity policy, records two things: how much notice you get before a model is retired, and whether you can pin a dated snapshot that keeps serving after the alias moves on. Continuity is judged from published deprecation pages and observed retirements, not from marketing claims, and where a provider publishes no policy at all we say so rather than guessing a number. Latency figures are community-reported from third-party benchmarks; toolweight has not run its own TTFT harness yet, so most of that column is honestly blank.