LLM API Providers in 2026: The Four Types and How to Choose
What "LLM API providers" covers in 2026
Search for LLM API providers and you get lists that put OpenAI next to Groq, AWS Bedrock next to OpenRouter, as if they were the same kind of company. They are not. A provider is anyone who sells you an HTTP endpoint that returns model output, but there are four different business models behind that endpoint, and each one changes who you sign the contract with, where your data goes, and what happens when a model is retired.
This guide sorts LLM API providers into those four types, shows what each type is good and bad at, and gives you a short checklist to run before you commit. It deliberately does not rank providers by price. Rate cards change too often, and the headline per-token rate is only one of five variables in the bill; for that, use the LLM API pricing comparison.
The four types of LLM API providers
|
Type |
Examples |
You get |
Main trade-off |
|---|---|---|---|
|
Model labs (first-party) |
OpenAI, Anthropic, Google Gemini API, Mistral, xAI, DeepSeek |
The lab's own models, newest first, on the lab's own API |
One vendor per model family; each has its own SDK quirks, limits, and terms |
|
Cloud AI platforms |
AWS Bedrock, Google Vertex AI, Microsoft Azure AI Foundry |
Several labs' models inside your existing cloud account, billing, IAM, and regions |
New models and features can arrive later than on the lab's own API; per-cloud APIs |
|
Open-weight inference hosts |
Groq, Together AI, Fireworks AI, DeepInfra |
Hosted open-weight models (Llama, Qwen, DeepSeek, Mistral and others), often tuned for speed or price |
Same model name can behave differently across hosts (quantization, context length, tool-calling support) |
|
Aggregators and routers |
OpenRouter, self-hosted or managed LLM gateways |
One key and one endpoint in front of many of the providers above |
An extra hop and an extra party in your data path; you still inherit each upstream's limits |
The same model can appear in more than one row. A Claude model, for example, is available from Anthropic directly, from cloud platforms, and through routers. Choosing a provider is therefore usually a choice about contract, data path, and operations, not only about which model you want.
Model labs: go direct when you need the newest model and the full feature set
First-party APIs are where new models, new parameters, and new tools usually land first. If your product depends on a specific capability, such as a lab's prompt caching, batch API, or structured output mode, the lab's own API is the reference implementation.
The cost is fragmentation. Each lab has its own request format, error codes, rate-limit tiers, and billing console. Several labs now offer an OpenAI-style compatibility path to lower switching cost. Google documents an OpenAI compatibility endpoint for Gemini, and DeepSeek's API docs say its format is compatible with the OpenAI and Anthropic SDKs. Read the fine print, though. Anthropic's OpenAI SDK compatibility page says the layer is mainly for testing and comparing models and "is not considered a long-term or production-ready solution for most use cases." Compatibility gets a request through; it does not guarantee every feature maps across. For what an OpenAI-compatible API does and does not promise, read that explainer before you rely on one.
Go direct when:
- you need a model or feature on day one;
- one model family covers most of your traffic;
- you want the lab's own data-use and retention terms, not a reseller's.
Cloud AI platforms: go through your cloud when procurement and governance decide
AWS Bedrock, Google Vertex AI, and Azure AI Foundry put models from several labs behind your existing cloud account. The appeal is rarely the model. It is that usage lands on a bill your finance team already pays, access is controlled by the IAM you already run, and you can pick regions to match data-residency rules.
The trade-offs are API shape and timing. Each cloud has its own interface, such as Bedrock's Converse API, and model availability varies by region. Some lab features and new model versions can show up on the cloud later than on the lab's own endpoint, so check the specific model page in the cloud console rather than assuming parity.
Choose a cloud platform when:
- enterprise procurement, existing commitments, or compliance reviews are the real bottleneck;
- you need regional deployment or private networking;
- you want one vendor relationship covering several labs.
Open-weight inference hosts: go here for speed, price, and model choice
Hosts such as Groq, Together AI, Fireworks AI, and DeepInfra run open-weight models on their own infrastructure. Most expose an OpenAI-style endpoint; Groq, for example, says its API is "mostly compatible" with OpenAI's client libraries. Their advantages are throughput, low latency on some hardware, and access to many open models without running GPUs yourself.
The risk is assuming a model name means the same thing everywhere. Two hosts serving the "same" open model can differ in quantization, maximum context, tool-calling support, and default sampling. Before you move production traffic, run your own evaluation set against the exact host and model ID, and measure the three latency numbers that matter rather than trusting a benchmark chart.
Aggregators and routers: one key in front of many providers
A router such as OpenRouter gives you one API and one bill in front of many upstream providers; its quickstart describes access to hundreds of models through a single endpoint with automatic fallbacks. A gateway, managed or open source, does a similar job inside your own stack: routing, keys, quotas, logging, and failover. The two approaches are compared in LLM gateway vs OpenRouter.
What aggregation does not remove:
- Upstream limits. If the upstream provider throttles or deprecates a model, the router cannot invent capacity.
- Data path. Your prompts pass through one more company. Check its logging and retention terms in addition to the upstream's.
- Feature gaps. Provider-specific parameters may be dropped or translated when a request is normalized.
If you are weighing whether to add this layer at all, LLM API gateway: what it does and when you need one and the LLM API aggregation platform guide cover the decision.
How to choose LLM API providers: a seven-point checklist
Run these checks against the specific provider and model ID you plan to ship, not the brand in general.
- Model availability. Is the exact model and version you tested available on this provider, in the region you need, with the context length you need?
- API format. Native SDK, OpenAI-compatible, or cloud-specific? List the features you use (streaming, tool calls, JSON or structured output, images, caching, batch) and confirm each one works on this endpoint.
- Rate limits and tiers. What are the requests-per-minute and tokens-per-minute limits at your spend level, and how do you move up a tier? Throttling at launch is a provider-choice problem.
- Data use and retention. Is API data used for training by default? How long are prompts and outputs logged? For routers and clouds, read both the intermediary's terms and the upstream's.
- Total cost, not the headline rate. Compare tokenizer differences, output length, cache discounts, and retries on your own prompts; the pricing comparison walks through the method.
- Reliability and fallbacks. Check the status page history and decide what happens when the provider returns 429 or 5xx. A second provider for the same model, or a gateway with failover, is cheaper than an outage.
- Key and billing operations. Who holds the keys, how are they rotated, and how is spend capped per team or project? See API key rotation best practices.
Common setups that work
- Single lab, direct. One model family, small team, fast access to new features. Add a second provider only when an outage or rate limit actually hurts.
- Cloud platform for production, lab API for experiments. Governance and billing go through the cloud; the team prototypes on the lab's API to get features early.
- Gateway in front of two or three providers. One internal endpoint, per-team keys and quotas, failover between providers for the same model family, and logs in one place. This is the usual end state once several teams ship LLM features.
FAQ
What are the main LLM API providers?
They fall into four groups: model labs that sell their own models (OpenAI, Anthropic, Google, Mistral, xAI, DeepSeek), cloud platforms that resell several labs' models (AWS Bedrock, Google Vertex AI, Azure AI Foundry), open-weight inference hosts (Groq, Together AI, Fireworks AI, DeepInfra), and routers or gateways that sit in front of the others (OpenRouter, self-hosted gateways).
Is it better to use the model lab's API or a cloud platform?
Use the lab's API when you need new models and features first. Use a cloud platform when procurement, data residency, IAM, or an existing cloud commitment is the deciding factor. Many teams use both.
Are OpenAI-compatible providers drop-in replacements?
For basic chat completions, often yes: you change the base URL, key, and model name. For advanced features such as tool calling, structured output, or caching, behavior can differ. Test each feature you rely on.
Which LLM API provider is cheapest?
There is no stable answer. It depends on the model, your prompt and output lengths, caching, and retries. Compare on a sample of your real traffic rather than on published per-million-token rates.
Should I use more than one LLM API provider?
Once LLM features are customer-facing, usually yes. A second provider or a gateway with failover protects you from rate limits, regional outages, and model deprecations. Start with one, and add the second when you can name the failure it protects against.
Bottom line
"LLM API providers" is four different markets. Pick the type first: a lab for the newest models, a cloud for governance, an open-weight host for speed and choice, or a router or gateway for one endpoint across many. Then run the seven checks against the exact model ID you will ship, and re-check prices and limits on the provider's own pages before you commit.