How to Use the OpenRouter API
to Access GPT, Claude, Gemini & More (2026 Guide)

If you ship AI features across GPT, Claude, Gemini, Grok, and open-weight models, you already know the pain: five vendor dashboards, five billing cycles, five SDK configs. OpenRouter collapses that into one OpenAI-compatible endpoint, one API key, and 400+ models from 70+ providers. This guide covers what OpenRouter is, model vs provider routing, pricing and free tiers, a full OpenRouter vs direct-API comparison, five reasons to switch, when NOT to use it, six integration steps, curl/Python/Node/OpenAI SDK code with streaming and fallback, bilingual SEO advice for English pages, and FAQ — written for developers who want a comparison-first answer, not a translated brochure.

• TL;DR: Change base_url to https://openrouter.ai/api/v1, keep your OpenAI SDK code, swap model slugs. No token markup — OpenRouter charges a 5.5% credit fee (min $0.80) instead.
• Free tier: 25+ free models, 50 requests/day before any purchase, 1,000/day after a $10 top-up, capped at 20 req/min.
• Best fit: Prototypes, multi-model agents, and teams that want fallback without maintaining five integrations. Skip it for enterprise SLAs, custom fine-tunes, or strict single-vendor data residency.

SECTION 01 Multi-Vendor LLM API Pain Points: Keys, Routing, and Outages Stack Up Fast

By mid-2026 most production AI stacks call more than one model. The integration tax is real:

• Key sprawl: OpenAI, Anthropic, Google, xAI, Moonshot — each vendor has its own console, rate limits, and auth headers. Rotating credentials across CI/CD is a security audit waiting to happen.
• SDK fragmentation: Anthropic's Messages API differs from OpenAI's Chat Completions. Every new model family means another adapter layer in your agent framework.
• Outage blind spots: When a single provider goes down, your fallback logic must already know alternate model IDs, pricing, and latency profiles — or your agent pipeline stalls.
• Billing opacity: Comparing per-token costs across vendors requires spreadsheets. Teams evaluating Kimi K3 vs Claude vs GPT often discover the real cost is integration time, not list price.
• Prototype-to-production gap: You test on OpenRouter, then rebuild everything for direct APIs at scale — unless you plan routing from day one.

One-line positioning: OpenRouter is a unified LLM API gateway — one key, one OpenAI-compatible endpoint (https://openrouter.ai/api/v1), access to 70+ providers and 400+ models including GPT-5.x, Claude 4.x, Gemini 2.x, Grok, DeepSeek, and Kimi — with optional model fallback and BYOK support.

SECTION 02 What Is OpenRouter? Model Routing, Provider Routing, Fallback, and Pricing

OpenRouter sits between your application and upstream LLM providers. You send a standard Chat Completions request; OpenRouter handles provider selection, load balancing, and billing aggregation.

Free models and rate limits

OpenRouter maintains 25+ free models (community and vendor-sponsored tiers). Limits as of July 2026:

• Before any credit purchase: 50 free-model requests per day, not charged against your balance.
• After purchasing $10+ in credits: free-model quota rises to 1,000 requests per day.
• Rate cap: 20 requests per minute on free models across all accounts.

Pricing model — no token markup

SECTION 03 OpenRouter vs Direct API: Comparison, Five Reasons to Switch, and When NOT to Use It

Five reasons developers choose OpenRouter

1. One integration, every model: Swap model slugs without rewriting client code — same pattern we use when benchmarking Grok 4.5 against Claude and GPT.
2. OpenAI SDK compatibility: Point base_url at OpenRouter and keep existing Python/Node/TS code paths.
3. Automatic fallback: A single request can try Claude → GPT → Gemini in sequence if the primary is rate-limited or down.
4. Transparent pricing: The models catalog shows per-token rates with zero markup; you pay a small credit fee instead of hidden spreads.
5. Free tier for experimentation: 25+ free models let you prototype agents before committing to a vendor contract.

When NOT to use OpenRouter

OpenRouter is the wrong default in these scenarios — pick direct APIs instead:

• Enterprise SLAs and BAAs: Healthcare and finance workloads that require a signed BAA with a specific vendor cannot route patient data through a third-party gateway without legal review.
• Custom fine-tuned endpoints: Your private GPT-4 fine-tune or Vertex AI custom model is not in the public OpenRouter catalog.
• Strict data residency: If contracts mandate all inference stays inside AWS us-east-1 on Anthropic's dedicated capacity, provider routing on OpenRouter is not equivalent.
• Ultra-low-latency trading or voice: The extra gateway hop and provider selection add milliseconds that matter at the tail of real-time pipelines.
• High-volume negotiated rates: Teams spending six figures monthly often get 15–30% discounts direct — the 5.5% credit fee plus list price loses against a signed enterprise deal.

SECTION 04 OpenRouter API Code Examples: curl, Python, OpenAI SDK, Node.js, Streaming, and Fallback

All examples use the OpenRouter base URL and an API key from your dashboard. Re-open official docs after upstream updates to verify headers and parameters.

curl — basic chat completion

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -H "Content-Type: application/json" \
  -H "HTTP-Referer: https://your-app.com" \
  -H "X-Title: Your App Name" \
  -d '{
    "model": "openai/gpt-4o",
    "messages": [{"role": "user", "content": "Explain model routing in one paragraph."}]
  }'

Python — requests library

import os, requests

resp = requests.post(
    "https://openrouter.ai/api/v1/chat/completions",
    headers={
        "Authorization": f"Bearer {os.environ['OPENROUTER_API_KEY']}",
        "HTTP-Referer": "https://your-app.com",
        "X-Title": "Your App Name",
    },
    json={
        "model": "anthropic/claude-sonnet-4",
        "messages": [{"role": "user", "content": "Summarize this API design..."}],
    },
)
print(resp.json()["choices"][0]["message"]["content"])

OpenAI SDK — drop-in replacement

from openai import OpenAI

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

response = client.chat.completions.create(
    model="google/gemini-2.5-pro",
    messages=[{"role": "user", "content": "Compare GPT and Claude for code review."}],
)
print(response.choices[0].message.content)

Node.js — fetch

const resp = await fetch("https://openrouter.ai/api/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.OPENROUTER_API_KEY}`,
    "Content-Type": "application/json",
    "HTTP-Referer": "https://your-app.com",
    "X-Title": "Your App Name",
  },
  body: JSON.stringify({
    model: "x-ai/grok-4",
    messages: [{ role: "user", content: "Write a TypeScript retry helper." }],
  }),
});
const data = await resp.json();
console.log(data.choices[0].message.content);

Streaming responses

from openai import OpenAI

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

stream = client.chat.completions.create(
    model="openai/gpt-4o",
    messages=[{"role": "user", "content": "Stream this response."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="")

Fallback routing — models array

{
  "models": [
    "anthropic/claude-sonnet-4",
    "openai/gpt-4o",
    "google/gemini-2.5-flash"
  ],
  "messages": [
    {"role": "user", "content": "If Claude is down, try GPT, then Gemini."}
  ]
}

Post this JSON to /chat/completions with model omitted (or set to the first entry). OpenRouter tries each slug until one succeeds.

List available models

curl https://openrouter.ai/api/v1/models \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  | jq '.data[] | {id, pricing}'

SECTION 05 How to Set Up OpenRouter: Six Steps from Sign-Up to Production Fallback

1. Create an account and generate an API key: Sign up at openrouter.ai, open Settings → Keys, and create a key. Store it in a secrets manager — never commit to git.
2. Add credits (optional for free models): Purchase at least $10 if you need the 1,000 free-model requests/day tier. Paid models draw from the same balance at provider list prices.
3. Point your client at the OpenRouter endpoint: Set base_url=https://openrouter.ai/api/v1 in the OpenAI SDK, or use the raw REST URL in curl/requests/fetch.
4. Pick model slugs from the catalog: Browse the models API or dashboard. Use vendor/model format — e.g. openai/gpt-4o, anthropic/claude-sonnet-4, google/gemini-2.5-pro, moonshotai/kimi-k3.
5. Configure fallback for production agents: Add a models array with two or three alternates. Log which model actually served each request so you can tune cost and latency.
6. Set attribution headers and monitor usage: Include HTTP-Referer and X-Title (required for some free models). Track spend in the OpenRouter dashboard and set budget alerts before wiring into CI/CD or customer-facing agents.

SECTION 06 Citable OpenRouter Data, English SEO Checklist, and Production Takeaways

• Catalog scale: 70+ providers, 400+ models, single OpenAI-compatible endpoint at https://openrouter.ai/api/v1.
• Free tier: 25+ free models; 50 req/day uncharged before purchase; 1,000 req/day after $10 credit top-up; 20 req/min rate limit.
• Revenue model: Zero token markup; 5.5% credit fee (minimum $0.80 per transaction); 5% crypto fee; BYOK 1M requests/month free.
• Routing: Model routing optimizes per slug; provider routing pins a vendor; models arrays enable automatic fallback.
• SDK compatibility: Drop-in OpenAI SDK — change base_url and api_key only.
• Attribution headers: HTTP-Referer and X-Title required for ranking on OpenRouter's free model leaderboard.

Re-open these official sources after upstream updates to verify pricing, limits, and API behavior:

OpenRouter official documentation

OpenRouter FAQ — pricing, free models, and BYOK

OpenRouter models API — live catalog and per-token pricing

Why English blog pages often get zero traffic — diagnostic checklist

If you publish bilingual content and the English URL flatlines while Chinese ranks, run through this list before blaming the topic:

• CDN / WAF geo-blocking: Confirm US and EU edge nodes return HTTP 200, not 403 or challenge pages.
• hreflang errors: Mismatched hreflang pairs, missing x-default, or pointing EN to a machine-translated stub hurts both locales.
• robots.txt / meta robots: Ensure /en/blog/ is not accidentally disallowed or set to noindex.
• Sitemap gaps: English URLs must appear in a dedicated sitemap with correct lastmod dates.
• Client-side rendering (CSR): If article body loads only after JS, crawlers may see an empty shell. MACNOX blog pages are static HTML — keep them that way.
• Machine translation: Google detects thin translated copies. English must be an independent rewrite with different paragraph structure and examples.
• Keyword mismatch: English searchers type "OpenRouter API tutorial" not "OpenRouter 教程". Match intent, not literal translation.
• E-E-A-T signals: Author org, dated updates, working code samples, and outbound links to official docs build trust.
• Backlinks: English pages need distribution on dev.to, Hacker News, Reddit r/LocalLLaMA, and X — not just CN social channels.

English keyword matrix and title signals

hreflang, canonical, and sitemap recommendations

For bilingual site owners publishing this topic in multiple locales:

• Canonical: Each language version canonicalizes to itself — e.g. https://macnox.com/en/blog/2026-openrouter-api-guide-gpt-claude-gemini.html — never cross-canonical EN to ZH.
• hreflang: Declare reciprocal link rel="alternate" hreflang pairs only when both versions are fully localized (not machine translated). Include x-default pointing to your primary market.
• Sitemap: One sitemap index with per-locale child sitemaps. Set accurate lastmod on every URL.

Schema.org — BlogPosting + FAQPage

Combine BlogPosting with a nested FAQPage in mainEntity (as this page does). Match FAQ JSON-LD questions verbatim to visible <details> items. Add dateModified when you update pricing or rate limits.

Distribution channels

• dev.to / Hashnode: Cross-post with canonical pointing back to your domain.
• Hacker News: Submit as "Show HN" when you add a novel benchmark or fallback pattern.
• Reddit: r/LocalLLaMA, r/MachineLearning, r/OpenAI — follow sub rules, lead with comparison tables not links.
• X / LinkedIn: Thread the "When NOT to use OpenRouter" section — contrarian angles earn shares.
• GitHub: Link from a public agent template repo that defaults to OpenRouter routing.

P0–P2 action checklist

Metrics to track

• Google Search Console: Impressions and CTR for "OpenRouter API", "OpenRouter vs OpenAI", and long-tail code queries.
• Baidu (if CN locale exists): Separate property — do not merge EN and ZH metrics.
• Analytics: Scroll depth on code blocks, outbound clicks to openrouter.ai/docs, and time-on-page vs bounce.
• Business: API sign-ups attributed via UTM, credit purchases after tutorial traffic, support tickets mentioning the guide.

OpenRouter solves model access, but teams wiring multi-model API agents, macOS CI/CD, and 24/7 automated test pipelines still hit three production gaps: (1) gateway outages do not fix local infrastructure that sleeps or reboots; (2) VM-based macOS CI carries Metal and Core ML compatibility overhead; (3) a developer MacBook on a desk is not a 24/7 agent host. For workloads that need zero-overhead native Apple compute, stable iOS CI/CD, and always-on AI agent automation, MACNOX cloud physical Mac nodes are usually the better fit: 100% genuine Apple hardware, full root access, no hypervisor tax, flexible daily/weekly/monthly billing. See our Kimi K3 multi-vendor API integration guide, Grok 4.5 Agent cost analysis, and Mac Mini M4 rent vs buy TCO comparison, or visit the pricing page.

SECTION 07 FAQ