OpenRouter

OpenRouter is a unified API gateway for large language models: a single, OpenAI-compatible endpoint that routes one request across 400+ models from 70+ providers, automatically choosing a host for price, speed, and reliability while consolidating everything into one bill. Instead of holding separate accounts, keys, and SDKs for Anthropic, OpenAI, Google, xAI, DeepSeek, and dozens of inference hosts, a developer integrates once and can switch models by changing a single string.

Overview

OpenRouter was founded in early 2023 by Alex Atallah — co-founder and former CTO of the NFT marketplace OpenSea — together with engineer Louis Vichy. The premise was that the model landscape would fragment into hundreds of specialized models, and that developers would need a marketplace and routing layer to navigate it rather than betting on a single vendor. That thesis has aged well: by mid-2026 OpenRouter describes itself as the largest AI gateway, advertising 400+ models across 70+ providers and reporting on the order of 10 million users and roughly 100 trillion tokens processed per month (about 25 trillion per week) — a roughly 5× increase over the prior six months.

The company has the funding to match the traffic. A $40 million Series A closed in 2025 (led by Andreessen Horowitz and Menlo Ventures, with Sequoia participating), and in May 2026 OpenRouter raised a $113 million Series B led by CapitalG, Alphabet's growth fund, at an approximately $1.3 billion post-money valuation. Later-stage strategic investors — NVIDIA's NVentures, plus the venture arms of ServiceNow, MongoDB, Snowflake, and Databricks — joined alongside the existing backers.

The core value proposition is vendor neutrality. Because switching from one model to another is a one-line change and billing is unified, OpenRouter makes it cheap to route different tasks to different models based on cost and quality, and to avoid lock-in to any single provider's API, pricing, or uptime.

Key Features

• One OpenAI-compatible API: A single endpoint (https://openrouter.ai/api/v1) that is a drop-in replacement for the OpenAI API. The official OpenAI SDKs and most tools that speak "OpenAI" work unchanged.
• 400+ models, 70+ providers: Frontier and open-weight models from Anthropic, OpenAI, Google, xAI, DeepSeek, Meta, Mistral, and many independent inference hosts, all under one catalog with a consistent request shape.
• Provider routing: When a model is served by several hosts, OpenRouter picks one based on your preferences — lowest price, lowest latency, highest throughput — and you can pin or exclude specific providers.
• Automatic failover: If a provider errors or is down, the request transparently retries against another host serving the same model, improving effective uptime over any single API.
• Unified billing and credits: One prepaid credit balance covers every model. No per-provider invoices, minimums, or separate contracts.
• Model and app rankings: Public leaderboards at openrouter.ai/rankings show which models and applications are consuming the most tokens — a widely cited real-usage signal.
• Data and privacy controls: Account-level policies restrict which providers may receive your prompts and can prefer zero-data-retention endpoints.
• Bring your own key (BYOK): Route through your own provider accounts while still using OpenRouter's unified interface, routing, and analytics.
• Presets and analytics: Saved model/parameter presets, plus per-request activity and cost analytics.

How It Works

OpenRouter sits between your application and the underlying inference providers:

1. Send one request: Call the OpenAI-compatible /chat/completions (or completions) endpoint with your OpenRouter API key and a model slug such as anthropic/claude-..., openai/gpt-..., or deepseek/deepseek-.... You can also target an auto-router that selects a model for you.
2. Route to a provider: For models with multiple hosts, OpenRouter selects one according to your routing preferences (price, latency, or throughput) and any allow/deny list you set.
3. Normalize the response: Streaming, tool/function calling, and structured outputs are smoothed into a consistent shape so behavior does not change when you swap models.
4. Fail over on error: If the chosen host fails, the request retries against an alternative provider serving the same model, so a single provider's outage does not take your app down.
5. Meter and bill: Usage is drawn from your prepaid credit balance (or billed through your own provider key under BYOK), and logged with token counts and cost in your activity dashboard.

Technical Details

The API mirrors OpenAI's request and response schema, so migration is usually a matter of changing the base URL and key. Models are addressed by namespaced slugs (provider/model), which is also the convention OpenRouter's public models API exposes — the same catalog that many third-party sites and model pages cite for canonical pricing and availability. Beyond chat, OpenRouter surfaces provider-level metadata such as context-window limits, supported parameters, and reasoning flags, which can differ between hosts of the same model (for example, one provider may cap the maximum output length or the usable context window lower than another).

Use Cases

For developers and startups

• Ship without provider lock-in: Integrate once and A/B test models across vendors by changing a string rather than rewriting an integration.
• Cost/quality routing: Send cheap, high-volume calls to smaller or open-weight models and reserve frontier models for hard tasks — from one codebase.
• Resilience: Use failover to survive a provider outage without an on-call scramble.

For AI coding tools and agents

• Model-agnostic coding assistants and agent frameworks — including Cline, Aider, Kimi Code, and Qwen Code — commonly let users plug in an OpenRouter key to reach any supported model without bundling a dozen provider integrations.

For teams and enterprises

• Consolidated billing and governance: One account, one invoice, and data policies that constrain which providers see company prompts.
• Model evaluation: Compare frontier models from Anthropic, OpenAI, Google, and xAI side by side on real workloads before committing.

For experimentation

• Free-tier prototyping: Build against rotating free models before deciding what to pay for.

Integrations

Because the API speaks OpenAI's dialect, OpenRouter drops into most of the ecosystem that already targets OpenAI: the official Python and TypeScript SDKs, LangChain and LlamaIndex, and OpenAI-compatible fields in editors, agent frameworks, and no-code tools. It also offers a hosted chatroom for trying models in the browser, and its models API is what many external catalogs and dashboards read for live pricing and availability.

Pricing & Access

OpenRouter is pay-as-you-go with a free tier and no subscription or minimum spend.

• Pass-through per-token pricing: For most models you pay the underlying provider's list price per token — OpenRouter does not add a per-token markup.
• Platform fee (~5.5%): A fee of about 5.5% is applied when you buy credits with a card; that prepaid balance then covers usage across every model.
• Free models: A rotating set of models costs nothing per token but is rate-limited (on the order of a few dozen requests per day) and may carry looser data policies — good for prototyping, not production.
• Bring your own key (BYOK): Route through your own provider accounts and OpenRouter charges a fee (about 5%) on usage above a monthly free allowance — reported as roughly $25,000 of list-price inference per month on pay-as-you-go, and around $200,000 on Enterprise.
• Enterprise: Higher BYOK allowances and custom terms.

Pricing and free-model rate limits change often; confirm current figures on the official pricing page.

Getting Started

Step 1: Create an account and add credits

1. Sign up at openrouter.ai.
2. Add a small amount of credit, or start with free models.
3. Create an API key in your account settings.

Step 2: Point your code at OpenRouter

• Set the base URL to https://openrouter.ai/api/v1 and use your OpenRouter key with the OpenAI SDK you already have.
• Choose a model by its provider/model slug, or use an auto-router.

Step 3: Tune routing (optional)

• Set provider preferences (cheapest, fastest, highest throughput) and allow/deny specific hosts.
• Turn on failover so requests retry against alternate providers.

Step 4: Monitor and control

• Watch token usage and cost in the activity dashboard.
• Apply data policies to restrict which providers receive your prompts before sending anything sensitive.

Limitations

• You inherit the provider's terms: OpenRouter normalizes the interface, but data retention, rate limits, and content policies still come from whichever host serves the request. Check the per-model policy for regulated or sensitive data.
• Not the absolute cheapest for a single fixed model: If you only ever use one model at high volume, a direct enterprise contract or committed-use discount with that provider may beat the gateway once the ~5.5% credit fee is counted.
• Capability drift between hosts: The same model can differ by provider in context window, max output, or supported parameters, so routing choices can subtly change behavior.
• Added dependency: You are inserting a third party into your critical path — its own availability and account status now matter, even though failover reduces provider-level risk.
• Prepaid credits: The card-purchase fee and prepaid balance model can be less convenient than direct postpaid billing for some finance workflows.

Alternatives

• Direct provider APIs — Going straight to Anthropic, OpenAI, Google, or xAI removes the middle layer and the credit fee, at the cost of managing multiple keys, SDKs, and bills yourself.
• Ollama and LM Studio — Run open-weight models locally with an OpenAI-compatible endpoint when privacy or offline use matters more than access to frontier models.
• Other aggregators and proxies — Services such as Together AI and Requesty, or the self-hosted LiteLLM proxy, offer overlapping "one API for many models" functionality; they differ in model coverage, routing, and whether you host the layer yourself.

Consumer chat apps like ChatGPT, Claude, Google Gemini, and Grok solve a different problem — they are end-user assistants, not developer gateways — but are worth naming for readers who want a product rather than an API.

Community & Support

• Documentation: openrouter.ai/docs for the API reference, routing options, and BYOK setup.
• Model catalog & rankings: openrouter.ai/models and openrouter.ai/rankings.
• Announcements: openrouter.ai/announcements/all for launches and provider additions.
• Discord: An active developer community for support and provider/model requests, linked from the site footer.