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

TL;DR: If you maintain separate accounts, SDKs, and billing dashboards for every LLM vendor, OpenRouter is the fastest way out — one API key and an OpenAI-compatible endpoint reach GPT-4o, Claude 3.5 Sonnet, Gemini 2.5 Pro, DeepSeek, and 400+ other models. This guide is for AI app developers and technical leads who need a production-ready setup: what OpenRouter actually is, an honest comparison against direct vendor APIs, five reasons teams switch, when not to use it, a seven-step key setup with curl / Python / Node.js samples, pricing facts you can cite, and a bridge to native compile infrastructure. Verdict: OpenRouter is nearly zero-migration for multi-model workloads at moderate scale; single-vendor, ultra-low-latency, or strict data-residency stacks should stay on direct APIs.

SECTION 01 What Is OpenRouter?

OpenRouter is a unified LLM API gateway. You authenticate once with Authorization: Bearer $OPENROUTER_API_KEY, send requests to the OpenAI-compatible endpoint https://openrouter.ai/api/v1/chat/completions, and pick any supported model using the provider/model slug — for example openai/gpt-4o, anthropic/claude-3.5-sonnet, google/gemini-2.5-pro, or deepseek/deepseek-chat. Existing OpenAI SDK code typically needs only a new base_url and api_key; message format, streaming, and tool-call shapes stay the same.

Under the hood, OpenRouter runs two routing layers:

The catalog spans 70+ providers and 400+ models. OpenRouter does not mark up per-token rates; it charges a 5.5% fee when you buy credits (minimum $0.80). BYOK mode routes through your own vendor keys — the first 1 million requests per month are free, then a 5% service fee applies on equivalent usage.

SECTION 02 OpenRouter vs Direct Vendor APIs

Direct APIs from OpenAI, Anthropic, and Google remain the right choice for some workloads. The table below is the decision matrix most teams actually need.

OpenRouter is not trying to replace vendor SDKs — it sits between "one model at massive scale" and "many models with one integration path."

SECTION 03 5 Reasons Developers Switch to OpenRouter

• One key, every model: Stop juggling OpenAI, Anthropic, Google, Meta, and DeepSeek accounts. Onboarding a new model is a string change, not a new vendor integration — especially valuable when you are also evaluating DeepSeek V4 GA pricing or running Kimi K3 long-horizon coding benchmarks.
• Near-zero SDK migration: Point the official OpenAI client at https://openrouter.ai/api/v1. Request bodies, streaming loops, and error handling stay intact.
• Built-in failover: A models array with route: "fallback" retries the next model when the primary rate-limits — no custom retry layer in your app.
• Unified spend visibility: Token usage, time-to-first-token, and per-model cost live in one dashboard instead of five vendor consoles.
• No token markup: List prices match upstream providers. Revenue is on credit purchases (5.5%), which keeps unit economics predictable for A/B tests and agent frameworks that swap models frequently.

SECTION 04 When You Should NOT Use OpenRouter

• Single-model, very high spend: At tens of thousands of dollars per month on one vendor, the 5.5% credit fee and gateway hop may cost more than a direct enterprise contract.
• Vendor-exclusive features: Anthropic Prompt Caching, OpenAI Batch API / Assistants, or Google Vertex AI pipelines are not fully exposed through the generic gateway surface.
• Latency-sensitive realtime paths: An extra 10–80 ms per request is unacceptable for voice, gaming, or sub-100 ms UX targets.
• Strict data residency: Traffic transits OpenRouter's US gateway before reaching the upstream provider. Regulated workloads may require BYOK or direct API contracts with geographic guarantees.

SECTION 05 Step-by-Step: Get Your OpenRouter API Key

1. Create an account: Sign up at openrouter.ai with Google, GitHub, or email and open the Dashboard.
2. Generate an API key: On the Keys page, create a key and store it as OPENROUTER_API_KEY — never commit it to version control.
3. Send a smoke-test request: Run the curl example below to confirm connectivity and billing.
4. Set attribution headers: OpenRouter recommends HTTP-Referer and X-Title for usage attribution and public rankings.
5. List available models: Call GET /api/v1/models to pull live slugs and pricing before hard-coding model names.
6. Configure a fallback chain: In production, pass a models array so rate limits on your primary model roll to alternates automatically.
7. Monitor spend: Use the Dashboard for token burn, TTFT, and latency; set credit alerts before load tests.

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 requests
import os

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 quicksort in Python."}
        ],
    },
)

print(response.json()["choices"][0]["message"]["content"])

from openai import OpenAI
import os

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://vpsnix.com",
        "X-Title": "VPSNIX Blog Demo",
    },
)
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 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);
}

Fallback payload — primary model rate-limited or erroring:

{
  "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" }]
}

OpenRouter walks the models list in order — your application does not need a separate retry loop.

List models and live pricing:

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

SECTION 06 OpenRouter Pricing Explained

Citable technical facts:

• Catalog scale: 70+ providers, 400+ models, single endpoint /v1/chat/completions
• Protocol: OpenAI Chat Completions — change two SDK lines to migrate
• Routing: Model selection via model; provider selection via provider with inverse-price weighting
• Failover: models + route: "fallback" for automatic model switching
• Revenue model: No per-token markup; 5.5% on credit purchases; BYOK first 1M req/month free
• Free tier: 25+ models; 50 req/day unfunded → 1,000 req/day after ≥ $10 top-up

Official sources — re-open these links after any OpenRouter policy update:

OpenRouter official documentation

OpenRouter FAQ — pricing, BYOK, and credit fees

OpenRouter model catalog and live pricing

SECTION 07 Pair OpenRouter Inference With Native M4 Build Infrastructure

OpenRouter solves multi-model API access, but it cannot compile an iOS app, sign with Apple certificates, or debug Metal shaders. Virtualized macOS stacks carry EULA risk and typically lose 20–40% of native performance to hypervisor overhead — cloud LLMs do not fix that gap.

The practical split: OpenRouter for reasoning, A/B tests, and agent orchestration; VPSNIX M4 / M4 Pro physical nodes for Xcode builds, CI/CD, and 24/7 agent deployment on bare Apple Silicon. If you are already routing Kimi K3 open weights or DeepSeek V4 through OpenRouter for code generation, keep the compile chain on compliant hardware with full Root access.

For production environments that need zero hypervisor loss, stable iOS CI/CD, and round-the-clock AI agent automation, VPSNIX cloud physical nodes are usually the better fit: genuine Apple hardware, complete Root privileges, no virtualization tax, and flexible daily / weekly / monthly billing. See the pricing page for current rates.

SECTION 08 FAQ