One endpoint. Every model.

1. Create an account — you get $5 in free credits, no card required.
2. In the dashboard, open API Keys and create a key. Copy it immediately — it's shown only once.
3. Make your first request:

curl https://api.routerplex.com/v1/chat/completions \
  -H "Authorization: Bearer $ROUTERPLEX_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-5.5",
    "messages": [{"role": "user", "content": "Hello!"}]
  }'

Swap "gpt-5.5" for any model in the catalog — same endpoint, same request shape.

Every request needs your API key in the Authorization header:

Authorization: Bearer sk-...

Keys are created and managed in the dashboard. Treat them like passwords: server-side only, never in browser code or public repos. If a key leaks, delete it in the dashboard — revocation is immediate.

Fully OpenAI-compatible, so the official SDKs work as-is.

from openai import OpenAI
 
client = OpenAI(
    base_url="https://api.routerplex.com/v1",
    api_key="sk-...",  # your RouterPlex key
)
 
response = client.chat.completions.create(
    model="gemini-3.5-flash",
    messages=[{"role": "user", "content": "Explain HTTP in one line"}],
)
print(response.choices[0].message.content)

import OpenAI from "openai";
 
const client = new OpenAI({
  baseURL: "https://api.routerplex.com/v1",
  apiKey: process.env.ROUTERPLEX_KEY,
});
 
const response = await client.chat.completions.create({
  model: "deepseek-v4-pro",
  messages: [{ role: "user", content: "Explain HTTP in one line" }],
});
console.log(response.choices[0].message.content);

Function calling, tool use, JSON mode, and vision inputs work the same way as with OpenAI — pass tools, response_format, or image content parts as usual.

Set stream: true to receive tokens as server-sent events, exactly like the OpenAI API:

stream = client.chat.completions.create(
    model="gpt-5.5",
    messages=[{"role": "user", "content": "Write a haiku"}],
    stream=True,
)
for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        print(delta, end="", flush=True)

Streams stay open for up to 10 minutes — enough for long reasoning-model outputs.

OpenAI-compatible image generation. Images are returned base64-encoded and billed by token (prompt text in, image tokens out).

from openai import OpenAI
import base64
 
client = OpenAI(base_url="https://api.routerplex.com/v1", api_key="sk-...")
 
result = client.images.generate(
    model="gpt-image-2",
    prompt="A lighthouse on a cliff at dusk, watercolor",
    size="1024x1024",
    quality="medium",  # low | medium | high
)
with open("lighthouse.png", "wb") as f:
    f.write(base64.b64decode(result.data[0].b64_json))

Sizes: 1024x1024, 1536x1024, 1024x1536. Higher quality uses more output tokens. You can try it without code in the playground.

List the models your key can use (also OpenAI-compatible):

curl https://api.routerplex.com/v1/models \
  -H "Authorization: Bearer $ROUTERPLEX_KEY"

The live catalog shows current per-token pricing and context windows. Model IDs are used verbatim in the model field — e.g. gpt-5.5, gemini-3.1-pro, kimi-k2.7.

Anything that speaks the OpenAI API can use RouterPlex: point it at https://api.routerplex.com/v1 with your key, and use any model ID from the catalog. Setup for the major coding tools:

https://api.routerplex.com/v1

Base URL:   https://api.routerplex.com/v1
API Key:    sk-...        # your RouterPlex key
Model ID:   claude-opus-4-8

Base URL:   https://api.routerplex.com/v1
API Key:    sk-...        # your RouterPlex key
Model ID:   claude-opus-4-8

{
  "language_models": {
    "openai": {
      "api_url": "https://api.routerplex.com/v1",
      "available_models": [
        { "name": "claude-opus-4-8", "display_name": "Claude Opus 4.8 (RouterPlex)", "max_tokens": 1000000 },
        { "name": "deepseek-v4-pro", "display_name": "DeepSeek V4 Pro (RouterPlex)", "max_tokens": 1000000 }
      ]
    }
  }
}

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "routerplex": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "RouterPlex",
      "options": {
        "baseURL": "https://api.routerplex.com/v1",
        "apiKey": "{env:ROUTERPLEX_API_KEY}"
      },
      "models": {
        "claude-opus-4-8": { "name": "Claude Opus 4.8" },
        "gpt-5.5": { "name": "GPT-5.5" }
      }
    }
  }
}

model = "gpt-5.5"
model_provider = "routerplex"
 
[model_providers.routerplex]
name = "RouterPlex"
base_url = "https://api.routerplex.com/v1"
env_key = "ROUTERPLEX_API_KEY"   # export ROUTERPLEX_API_KEY=sk-...

Claude Code talks to Anthropic's native Messages API rather than the OpenAI format, which RouterPlex doesn't expose yet — so it can't point at us today. Every tool above uses the OpenAI-compatible endpoint and works with all 25+ models, Claude included.

A key used inside an editor is still just a RouterPlex key — give it its own budget and model allowlist so an agent gone wild can't drain your balance.

Each key can have its own guardrails, set at creation or later from the dashboard:

• Budget — a hard spend cap for the key. Requests fail once it's reached.
• Allowed models — restrict a key to specific models (e.g. only cheap ones for a side project).
• Rate limits — optional requests-per-minute and tokens-per-minute caps.

Per-request logs (time, model, tokens, cost) are available per key in the dashboard under API Keys → Logs.

Standard OpenAI-style error responses:

Requests are limited to 60/s per IP at the edge, and request bodies up to 50 MB (plenty for base64 vision payloads).

Pure pay-as-you-go: you top up a balance (card or crypto), and every request deducts its exact token cost — the same prices shown in the catalog, no subscriptions, no minimum spend. When your balance runs out, requests stop; they resume the moment you top up.

Your live balance, total spend, and per-model breakdown are on the dashboard.