OpenRouter: A Gateway for AI Models

Updated: 2026-09-17

OpenRouter is a hosted gateway that gives you more than 500 AI models from over 80 providers behind a single OpenAI-compatible API. It is built for developers and teams who want to test or combine models without opening an account with each provider. You pay each model’s rate with no markup, plus a 5.5% fee when you buy credits, and more than 25 free models come with a daily cap.

In this guide you will see what OpenRouter is, how its single API opens up hundreds of models, and how routing, failover and pricing work. You will also see how to call it from your agent and how it differs from running your own proxy with LiteLLM. We checked every fact against the official sources on 16 September 2026. The same explanation is available in Spanish.

Key takeaways

• OpenRouter is a hosted gateway (SaaS): you install and maintain nothing. Its home page sums it up as "The Unified Interface For Every Model".
• A single OpenAI-compatible API opens up more than 500 models for text, images, video and audio from over 80 providers; in September 2026 it advertises more than 400 trillion tokens a month and more than 10 million users.
• You change the base URL to https://openrouter.ai/api/v1 and use one key; the rest of your OpenAI client code stays untouched.
• It ships automatic routing (openrouter/auto), failover (a list of backup models) and per-provider preferences to prioritise price, throughput or latency.
• Pass-through token pricing: you pay the provider’s rate and OpenRouter charges 5.5% when you buy credits (8% on the Business plan). Free models are capped at 50 requests a day, or 1,000 once you have bought at least 10 credits.
• On 19 August 2026 Stripe announced an agreement to acquire OpenRouter; the company says the product and existing integrations do not change.

What is OpenRouter?

OpenRouter is a hosted gateway that sits between your application and the model providers. Its pitch is direct: one account, one key and one balance give you the commercial and open models from OpenAI, Anthropic, Google, Mistral, DeepSeek or xAI, among others. There are no separate contracts or credentials to manage with each company. Its home page defines it as "The Unified Interface For Every Model".

The company started in early 2023 and is run by its co-founder, Alex Atallah. In May 2026 it raised a 113-million-dollar Series B led by CapitalG, the growth fund of Alphabet (Google’s parent). According to The New York Times, as cited by TechCrunch, that round valued it at around 1.3 billion dollars.

The biggest change came on 19 August 2026, when Stripe announced an agreement to acquire OpenRouter. In its own announcement, OpenRouter says it will keep operating under the same name, product and roadmap, and that nothing about your integration changes. The deal was subject to customary closing conditions. As of 16 September 2026, neither Stripe nor OpenRouter had announced that it had closed.

The figure that best explains its traction is volume. Its home page advertises more than 400 trillion tokens a month, more than 10 million users and more than 250,000 apps using the platform. Stripe names NVIDIA, Zoom and Lovable among the companies that use it: this is infrastructure already moving production traffic at scale.

A single API for hundreds of models

OpenRouter’s core value is the catalogue, and it is no longer text only: from a single access point you generate text, images, video, speech and transcriptions. The catalogue covers OpenAI’s GPT family, Anthropic’s Claude, Google’s Gemini, the models from Mistral, DeepSeek, Meta or xAI, and open weights that other providers serve on your behalf. Each model is identified by a string of the form author/model, for example anthropic/claude-sonnet-5 or openai/gpt-5.6-sol.

The full list is public: the /api/v1/models route answers without a key. These three calls count the catalogue and the providers:

curl -s https://openrouter.ai/api/v1/models | jq '.data | length'
curl -s "https://openrouter.ai/api/v1/models?output_modalities=all" \
  | jq '.data | length'
curl -s https://openrouter.ai/api/v1/providers | jq '.data | length'

On 16 September 2026 they returned 444, 599 and 107. The first counts only the models that generate text, which is the default filter; the second adds every modality, and the third counts providers. The figures include variants: of the 444 text entries, 74 are :batch versions for the Batch API, 20 are free (:free) and 18 are aliases of the form ~author/family-latest.

The same response carries each model’s price in dollars per token. This jq filter pulls out Claude Sonnet 5:

curl -s https://openrouter.ai/api/v1/models \
  | jq '.data[] | select(.id == "anthropic/claude-sonnet-5")
        | {id, context_length, pricing: (.pricing | {prompt, completion})}'

This was the actual output:

{
  "id": "anthropic/claude-sonnet-5",
  "context_length": 1000000,
  "pricing": {
    "prompt": "0.000002",
    "completion": "0.00001"
  }
}

Multiplied by a million, that is 2 dollars per million input tokens and 10 per million output tokens. Those are the same figures Anthropic lists for Claude Sonnet 5 on its pricing page, which is what "no markup" means.

This solves a concrete problem. Suppose your product wants to compare two models, or migrate from one to another because a better or cheaper version shipped. Without OpenRouter you would have to register a new account, generate a key, add a card and adapt that provider’s SDK.

With OpenRouter, switching from anthropic/claude-sonnet-5 to openai/gpt-5.6-sol is editing a string. That zero friction turns model evaluation, a theme we also touch on when discussing open models with tool calling, into something you can do on the fly. If you would rather not pin a version, an alias such as ~anthropic/claude-sonnet-latest always points at the newest one in the family.

Which provider serves a given open model is not fixed: the same weights can come from more than one, and each provider sets its own price, speed and reliability. OpenRouter presents them together and, unless you say otherwise, spreads traffic across them according to your preferences. You see one model; underneath is a marketplace competing to serve your request.

Routing, failover and pricing

This is where OpenRouter stops being a mere catalogue. Routing is controlled with two mechanisms, and a third one, the auto-router, picks the model for you.

The first is the list of backup models. You send a models field with names ordered by preference: if the first returns an error, OpenRouter tries the next without your application noticing. Provider downtime, a rate limit, a context that is too long or a moderation flag all count as errors. You pay only for the model that ends up answering, and the response names it in its model field.

The second is the provider object, with which you fine-tune which inference providers are used (order, only, ignore) and how they are sorted (sort). By default, OpenRouter balances load across providers with no recent outages and favours the cheapest ones. With sort you prioritise price ("price"), throughput ("throughput") or latency ("latency"). The same object accepts data_collection: "deny" and zdr: true to rule out providers that store your data.

As a shortcut, adding :floor to the model name sorts by price and :nitro sorts by throughput. Today they do more than sort: :floor also makes flex service tier endpoints eligible, and :nitro does the same for the priority tier.

The third is the auto-router (openrouter/auto), rebuilt on 10 August 2026. It classifies each request into one of about 30 task types and picks the models the OpenRouter community spent the most on for that type over the last 7 days. With cost_tier you set the cost band, from low to max, and it charges nothing beyond the chosen model.

The pricing model is what most surprises anyone arriving from other gateways. OpenRouter adds no per-token markup: you pay the same rate you would pay going straight to the provider. Its business is a fee charged when you buy credits, not on each request. This table sums up what you pay as of September 2026:

In exchange for the fee you avoid managing a dozen invoices and contracts. Credits are denominated in dollars, and OpenRouter’s terms let it expire credits still unused one year after purchase. If you allow OpenRouter to use your prompts and completions to improve its product, it takes 1% off your usage.

Using it from your agent (OpenAI-compatible API)

The reason OpenRouter is adopted in minutes is that it speaks the dialect almost the whole ecosystem already uses: the OpenAI API. There is no mandatory in-house SDK, although OpenRouter publishes its own (@openrouter/sdk for TypeScript and openrouter for Python). You take your OpenAI client, change the base_url and the key, and keep calling chat.completions.create as always. This Python example routes the request to Claude Sonnet 5 through OpenRouter:

from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="your_openrouter_key",
)

response = client.chat.completions.create(
    model="anthropic/claude-sonnet-5",
    messages=[
        {"role": "user", "content": "Explain what a model gateway is"},
    ],
    extra_headers={
        "HTTP-Referer": "https://jacar.es",
        "X-OpenRouter-Title": "My agent",
    },
)
print(response.choices[0].message.content)

Both headers are optional: HTTP-Referer creates your app’s entry on OpenRouter’s public leaderboard and X-OpenRouter-Title gives it a name. The latter replaces X-Title, which still works for backwards compatibility. Failover is declared in the request body itself, with no extra code, by passing a models list instead of a single name:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "models": ["anthropic/claude-sonnet-5", "openai/gpt-5.6-sol"],
    "provider": {"sort": "price", "allow_fallbacks": true},
    "messages": [{"role": "user", "content": "Hello"}]
  }'

We have not run these two calls with a real key, because we did not open an OpenRouter account for this update. We did check the model names and parameters against the public models API and the official documentation, as of 16 September 2026. Without a key, the curl call above gets a 401 with the message Missing Authentication header, and the Python example, with the openai library 3.14.1 and a made-up key, ends in an AuthenticationError with the same code.

The OpenAI chat API is no longer the only way in. OpenRouter’s Responses API (/api/v1/responses) left beta on 25 July 2026, and the /api/v1/messages route accepts Anthropic’s message format, with its own fallbacks parameter. That means the OpenAI Agents SDK and Anthropic’s SDK also work when pointed at OpenRouter.

Because it speaks OpenAI, it fits out of the box with agent frameworks and observability tools. You can, for instance, put Helicone in front to watch spend; it is an observability platform that logs every call to your LLM to track cost, latency and usage. You can also take advantage of the prompt caching to cut costs on the catalogue models that support it.

OpenRouter versus a self-hosted proxy (LiteLLM)

The natural comparison is with LiteLLM, the open-source proxy that unifies model providers. They solve the same problem, putting the whole model catalogue behind one API, but from opposite philosophies.

LiteLLM you run yourself. It is free software you deploy as your own server, and you supply your own provider keys. In exchange you control everything: virtual keys per team, budgets, redaction of sensitive data, and no traffic leaving your perimeter. The cost is that you administer that piece, with its database and its updates.

OpenRouter someone else runs. You deploy nothing and maintain no infrastructure, and provider keys are optional: if you bring your own (BYOK, bring your own key), OpenRouter tries them before its own capacity. In exchange, your traffic and your billing pass through a third party, and you depend on its availability and its data policy.

The rule of thumb is this. If you want immediate access to the whole model market, to experiment without opening ten accounts and to run no servers, OpenRouter wins.

You may need control over your own keys, per-team governance or data that never leaves home, for example by serving models on your own machine with Ollama. In that case a self-hosted proxy like LiteLLM is the answer. They are not mutually exclusive: it is common to use OpenRouter to prototype and test models, and migrate critical workloads to a self-hosted proxy once volume and compliance demands justify it.

Frequently asked questions

Does OpenRouter make calls more expensive than going straight to the provider?

Not per token: OpenRouter passes through the provider’s rate with no markup, and Claude Sonnet 5 costs 2 and 10 dollars per million tokens in both places. The cost is the fee when you buy credits: 5.5% by card (0.80-dollar minimum), 5% with cryptocurrency and 8% on the Business plan. In practice, that fee can cost less than the time spent managing a separate account, key and invoice for each provider. If you move high volumes and only use one or two providers, going direct may come out slightly cheaper.

Can you use OpenRouter for free?

Yes, with limits. Its pricing page advertises more than 25 free models, which you request with the :free variant, and the openrouter/free router picks one at random among those that support what your request needs. If you have bought fewer than 10 credits, you get 20 requests per minute and 50 a day; once you have bought at least 10, the cap rises to 1,000 a day. Failed attempts count toward the daily quota, and providers may rate-limit the most popular free models at peak times.

Do I need to learn a new SDK to use OpenRouter?

No. OpenRouter exposes an OpenAI-compatible API, so you reuse the OpenAI client (or any library that already speaks it) by changing only the base_url to https://openrouter.ai/api/v1 and the key. It also accepts the Responses API format and Anthropic’s message format. Agent frameworks and observability tools that assume those dialects work unchanged, and OpenRouter’s own SDKs are optional.

Is it safe to send sensitive data through OpenRouter?

It depends on your case: OpenRouter does not store your prompts or completions unless you turn logging on, but your data passes through a third party before reaching the provider. You can restrict routing to providers that do not train on your data or that apply zero data retention (ZDR). On the Business and Enterprise plans, requests sent to eu.openrouter.ai are processed only in the EU. If the requirement is that no data leaves your network, the right option is a self-hosted proxy such as LiteLLM, or serving the model on your own infrastructure.

What changes with Stripe’s acquisition of OpenRouter?

For now, nothing for anyone integrating its API. Stripe announced the agreement on 19 August 2026, and OpenRouter says it will keep its name, product, roadmap and neutrality across models and providers. The deal was pending customary closing conditions, and as of 16 September 2026 neither company had announced that it had completed.

Conclusion

OpenRouter turns the fragmentation of the model market into a single line of configuration. An OpenAI-compatible API, one key and one balance give you more than 500 models from over 80 providers, with routing, failover and pass-through token pricing. It is the most direct way to test and combine models without opening ten accounts or standing up servers, and since August 2026 it has an acquisition agreement with Stripe behind it.

Its downside is the dependence on a third party, which is precisely what you avoid with a self-hosted proxy like LiteLLM. The next step is to create a key, point your client’s base_url at OpenRouter and compare two models with the same code.

Sources

1. Official OpenRouter documentation
2. Provider routing in the OpenRouter docs
3. OpenRouter repositories on GitHub
4. OpenRouter more than doubles valuation to 1.3B, in TechCrunch
5. OpenRouter plans and pricing
6. OpenRouter FAQ on fees and BYOK
7. OpenRouter credit and rate limits
8. Model fallbacks in OpenRouter
9. OpenRouter Auto Router
10. App attribution headers in OpenRouter
11. OpenRouter API changelog
12. In-region routing in the US and the EU, on the OpenRouter blog
13. OpenRouter is joining Stripe, on the OpenRouter blog
14. Stripe agrees to acquire OpenRouter, in the Stripe newsroom
15. Claude model pricing in the Anthropic docs
16. OpenRouter home page

Route: Agent Ecosystem: MCP, Gateways and Platforms