How to Use the OpenRouter API to Access GPT, Claude, Gemini & More

What is OpenRouter — and why multi-model teams hit a wall without it

OpenRouter is a unified LLM API gateway. You authenticate once with a single API key, send requests to the OpenAI-compatible endpoint at https://openrouter.ai/api/v1/chat/completions, and OpenRouter routes traffic to models from 70+ providers — more than 400 models in total — without registering at OpenAI, Anthropic, Google, DeepSeek, and everyone else separately.

The pain points it targets are practical, not theoretical:

• Account sprawl: every vendor wants its own signup, billing profile, and rate-limit tier.
• SDK fragmentation: switching from GPT to Claude to Gemini often means rewriting client code or maintaining adapter layers.
• Billing reconciliation: finance has to pull usage from three or four dashboards to understand one product's AI spend.
• Outage handling: when a single provider throttles or returns 503, you either accept downtime or build your own retry and failover logic.

OpenRouter addresses the last two with built-in routing. Model IDs follow a provider/model pattern — for example openai/gpt-4o, anthropic/claude-3.5-sonnet, or google/gemini-2.5-pro. Existing OpenAI SDK code typically needs only a base_url and api_key change.

Two independent routing layers sit behind every request:

For resilience, pass a models array alongside your primary model. If the first choice is rate-limited or errors out, OpenRouter walks the list automatically — failover logic lives in the gateway, not in your application retry loop.

OpenRouter vs direct vendor APIs — side-by-side comparison

OpenRouter is not a replacement for every production workload. It is a consolidation layer for teams that need model choice, unified billing, and automatic failover more than they need vendor-exclusive features.

Five reasons to use OpenRouter — and when to skip it

1. One key, every model. Swap models by changing a string — no adapter rewrite when you move from GPT-4o to Claude to Gemini for an A/B test.

2. Automatic cross-provider failover. Configure a fallback chain with the models array; OpenRouter retries the next entry when the primary host fails.

3. Unified usage analytics. One dashboard tracks cost, latency (TTFT), and throughput across every model you call.

4. Transparent token pricing. OpenRouter does not mark up per-token rates; the surcharge appears only when you buy credits (5.5%, minimum $0.80). BYOK mode lets you bring your own vendor keys — first 1M requests per month are free, then 5% on the equivalent spend.

5. Fast prototyping. Ideal for multi-model experiments, agent frameworks that should run on any frontier model, and apps spending up to a few thousand dollars per month on inference.

Set up the OpenRouter API in six steps

Run this on a machine you control — a fresh macOS box avoids stale Python installs and conflicting SDK versions that make debugging harder than the API itself.

1. Create an OpenRouter account: sign up at openrouter.ai with GitHub or email.
2. Generate an API key: open Dashboard → Keys, create a key, and store it in OPENROUTER_API_KEY — never commit it to git.
3. Add credits (optional): paid models require a positive balance. Credit purchases incur a 5.5% fee (minimum $0.80). Without credits you can still hit 25+ free models under daily rate limits.
4. List available models: call GET /api/v1/models to confirm the exact model ID and current pricing before you wire production code.
5. Send your first completion: POST to /v1/chat/completions with curl or an SDK, setting the model field to your target.
6. Validate streaming and fallback: test stream: true and a models fallback array before shipping — confirm your client handles partial tokens and model switches correctly.

curl https://openrouter.ai/api/v1/models \
  -H "Authorization: Bearer $OPENROUTER_API_KEY"

OpenRouter API code examples — curl, Python, Node.js, streaming, and fallback

OpenRouter recommends sending HTTP-Referer and X-Title headers so your app can appear on public usage rankings. All examples below assume OPENROUTER_API_KEY is already exported.

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "anthropic/claude-3.5-sonnet",
    "messages": [
      { "role": "user", "content": "Explain quantum computing in one sentence." }
    ]
  }'

import os
import requests

response = requests.post(
    url="https://openrouter.ai/api/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {os.environ['OPENROUTER_API_KEY']}",
        "Content-Type": "application/json",
    },
    json={
        "model": "google/gemini-2.5-pro",
        "messages": [
            {"role": "user", "content": "Write a Python quicksort implementation."}
        ],
    },
)
print(response.json()["choices"][0]["message"]["content"])

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ["OPENROUTER_API_KEY"],
)

completion = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Hello!"}],
    extra_headers={
        "HTTP-Referer": "https://your-app-domain.com",
        "X-Title": "My App",
    },
)
print(completion.choices[0].message.content)

import OpenAI from "openai";

const openai = new OpenAI({
  baseURL: "https://openrouter.ai/api/v1",
  apiKey: process.env.OPENROUTER_API_KEY,
});

const completion = await openai.chat.completions.create({
  model: "deepseek/deepseek-chat",
  messages: [{ role: "user", content: "Explain OpenRouter in one sentence." }],
});

console.log(completion.choices[0].message.content);

const stream = await openai.chat.completions.create({
  model: "anthropic/claude-3.5-sonnet",
  messages: [{ role: "user", content: "Write a short poem about autumn." }],
  stream: true,
});

for await (const chunk of stream) {
  const content = chunk.choices[0]?.delta?.content;
  if (content) process.stdout.write(content);
}

{
  "model": "anthropic/claude-3.5-sonnet",
  "models": [
    "anthropic/claude-3.5-sonnet",
    "openai/gpt-4o",
    "google/gemini-2.5-pro"
  ],
  "route": "fallback",
  "messages": [{ "role": "user", "content": "Hello" }]
}

When the primary model is throttled or returns an error, OpenRouter tries the next entry in models in order — no extra retry loop required in your service layer.

Free tier, BYOK, and pricing numbers worth knowing

• 25+ free models: OpenRouter hosts free-tier variants (partial Llama, Gemma, DeepSeek, and others). Unfunded accounts get about 50 free calls per day; after a $10 top-up, the limit rises to 1,000 calls per day at 20 requests per minute.
• BYOK (bring your own key): attach vendor API keys you already own. The first 1 million requests per month incur no OpenRouter service fee; beyond that, OpenRouter charges 5% on the equivalent spend.
• No token markup: inference is billed at upstream vendor rates. OpenRouter revenue comes from a 5.5% fee when you purchase credits (minimum $0.80), plus an additional 5% if you pay with cryptocurrency.
• Gateway latency overhead: expect roughly 10–80 ms added per request compared with a direct vendor call — fine for most apps, noticeable in sub-100 ms interactive loops.

Free model lists, rate limits, and fee schedules change over time. Treat the official links below as the source of truth rather than this article.

OpenRouter — official documentation

OpenRouter — FAQ (pricing, BYOK, and free tier)

OpenRouter — provider routing explained

FAQ

OpenRouter solves the multi-vendor API problem, but it does not clean up your local dev environment. Conflicting Python versions, half-finished agent scripts, and Node.js dependency trees pile up fast when you are iterating across four models in one afternoon. A disposable, real Apple Silicon Mac mini — one you can SSH into, test against, and wipe without touching your daily driver — keeps that experimentation contained. We used the same "clean box" approach in our Kimi K3 model testing guide and our Xcode CI runner setup guide; OpenRouter multi-model integration fits the pattern exactly.