OpenRouter MCP

Live

OAUTH 2.1

LLM ROUTING

AI

OpenRouter MCP gives agents authenticated access to LLM routing: search the model catalog, compare providers and benchmarks, and send messages across hundreds of models.

  • Per-user credentials: each call uses the actual user's token, never a shared bot.
  • Encrypted per-tenant vault: AES-256, resolved at request time, never in LLM context.
  • Scoped before every call: pre-call scope check, 90-day SIEM-exportable audit chain.
OpenRouter MCP
agent · Acme Q3
Run
Which model under $1 per million tokens is best for coding right now?
S
openroutermcp_list_models
88ms
OpenRouter agent
Top pick: deepseek/deepseek-v4 at $0.40/M prompt, coding index 71, 164K context. Runner-up: qwen/qwen3-coder at $0.35/M, coding index 68.
Sources: 312 models, 2 filters applied
openroutermcp
312 models
18:29
Message Claude...

Tools your routing agent reaches for on OpenRouter, scoped per user.

CALL ANY TOOL
Handle LLM routing end to end: search the model catalog, compare benchmarks and provider endpoints, send messages, and trace spend per generation.
openroutermcp_list_models
Search model catalog
List the live OpenRouter model catalog with pricing, context length, modalities, and benchmark scores. Server-side search, sort, and filters (price, context, coding index, providers) narrow the list before it reaches the agent.
Parameters
Name
Type
Required
Description
request
object
Optional
Search, sort, and filter parameters for the model catalog. Omit entirely to list all models with default ordering.
openroutermcp_send_message
Send a message
openroutermcp_list_model_endpoints
Compare provider endpoints
openroutermcp_list_benchmarks
Compare benchmarks
openroutermcp_list_daily_model_rankings
List model rankings
openroutermcp_get_generation
Inspect generation spend
openroutermcp_get_credits
Check credit balance
Build your Agent
Same auth pattern across LangChain, OpenAI, Anthropic, and Google ADK.
Python · LlamaIndex
import { ScalekitClient } from "@scalekit-sdk/node";
import { createReactAgent } from "@langchain/langgraph/prebuilt";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

// OpenRouter tools scoped to this user
const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["openroutermcp"], toolNames: [
    "openroutermcp_list_models",
    "openroutermcp_send_message",
    "openroutermcp_get_generation"] },
  pageSize: 100,
});

const agent = createReactAgent({ llm, tools });
await agent.invoke({ messages: [{ role: "user", content: "Which coding model is cheapest right now?" }] });
import OpenAI from "openai";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const openai = new OpenAI();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["openroutermcp"] }, pageSize: 100,
});

const res = await openai.chat.completions.create({
  model: "gpt-5",
  messages: [{ role: "user", content: "What are the top trending models this week?" }],
  tools,
});

// Execute the tool call with the user's vaulted OpenRouter credential
await sk.tools.executeTool(res.choices[0].message.tool_calls[0], "user_123");
import Anthropic from "@anthropic-ai/sdk";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);
const anthropic = new Anthropic();

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["openroutermcp"] }, pageSize: 100,
});

const msg = await anthropic.messages.create({
  model: "claude-sonnet-5",
  max_tokens: 1024,
  messages: [{ role: "user", content: "How many credits are left on the account?" }],
  tools,
});

// Tool call runs with the user's vaulted OpenRouter credential
await sk.tools.executeTool(msg.content, "user_123");
import { Agent } from "@google/adk/agents";
import { ScalekitClient } from "@scalekit-sdk/node";

const sk = new ScalekitClient(env.SCALEKIT_ENV_URL, env.SCALEKIT_CLIENT_ID, env.SCALEKIT_CLIENT_SECRET);

const { tools } = await sk.tools.listScopedTools("user_123", {
  filter: { connectionNames: ["openroutermcp"] }, pageSize: 100,
});

const agent = new Agent({
  name: "openrouter_routing_agent",
  model: "gemini-2.5-pro",
  instruction: "Pick and route LLM models for the signed-in user.",
  tools,
});

await agent.run("Which providers serve DeepSeek V4 and at what latency?");
Try these prompts
Copy any prompt into your agent. Each maps directly to an OpenRouter tool. Click to copy, paste into your agent, done.
Pick a model
Copy the prompt
Copied
Which models under $1 per million tokens score highest on coding benchmarks?
Copy the prompt
Copied
Find the cheapest model with at least 200K context.
Copy the prompt
Copied
What are the top trending models by token volume this week?
Route and compare providers
Copy the prompt
Copied
Which providers serve DeepSeek V4 and at what latency?
Copy the prompt
Copied
Compare price and throughput across every endpoint for Llama 4.
Copy the prompt
Copied
Send the same eval prompt to two models and compare the answers.
Track spend
Copy the prompt
Copied
How many credits are left on my account?
Copy the prompt
Copied
Inspect the cost and serving provider for my last generation.
Copy the prompt
Copied
Which task types drive most of our OpenRouter usage?
SEE HOW AUTH WORKS
Your users connect once. Their OpenRouter credentials stay vaulted, every call is scope-checked, and every action is logged.
1
Authorize
Your user connects
OpenRouter MCP
once. We tie it to their identity and the meetings they approved — no shared bot account, no org-wide access
Who:
user ‘A’
when:
Once per user
access:
Limited to user
2
Store
Their
OpenRouter MCP
token lives in a vault scoped to them. User A's meetings are never reachable by an agent acting for user B, even on the same connection
vault:
encrypted
scope:
per-user
tokens:
auto-refreshed
3
Resolve
When your agent calls a
OpenRouter MCP
tool, we fetch the right token server-side. It never touches your agent, never appears in the LLM context, never shows up in your logs
speed:
~40ms
check:
before every call
seen by:
nobody
4
Audit
Every
OpenRouter MCP
tool call is logged — who triggered it, which meeting was fetched, what came back. 90 days of history, tied to the user who authorized it
history:
90 days
export:
SIEM-ready
logged:
every call
Test other agents
See the same per-user auth pattern across other AI connectors.
ENGINEERING
Slack workflow agent (LangGraph)
LangGraph agent that drives multi-step Slack workflows: triggers, approvals, and follow-up actions per user identity.
ENGINEERING
Auto-release notes agent
Group merged GitHub PRs by feature, fix, or chore and publish release notes per tag. No manual changelog grooming.
Why Scalekit
Secure your agent's access. Connectors ship in minutes
Other connector libraries treat auth as a demo afterthought. Scalekit starts with identity, scope enforcement, and audit. Connectors follow.
01.
Shared tokens break per-user analytics
A shared OpenRouter key looks fine in a demo. In production every generation bills one account, and you cannot tell whose prompt spent the credits or picked the model. Scalekit resolves the credential of the actual user who triggered the agent, never a shared bot.
// shared key
spend → bot_service_account

// scalekit
spend → user_abc ✓
02.
Authentication is not authorization
03.
Multi-tenancy is architectural
04.
OpenRouter today. Ten connectors tomorrow.
“Our agents act across Salesforce, Gong, Google Drive, and more, on behalf of every customer. Scalekit behind the scenes meant we can keep adding tools without ever rebuilding how credentials or tool calling work.”
Venu Madhav Kattagoni
Head of Engineering / Von
FAQs
Frequently Asked Questions
Does the agent access OpenRouter as the user or through a shared key?
As the user. Scalekit resolves the credential of the person who triggered the agent at request time, so every model call and credit spent in your audit trail is attributed to a real user, not a shared service account.
Where is the OpenRouter token stored?
In an AES-256 encrypted vault with per-tenant namespacing. Tokens are resolved at request time, never enter LLM context, refresh automatically, and can be revoked from one dashboard.
Can I limit what the agent does in OpenRouter?
Yes. Filter by tool name in listScopedTools to expose only what you want, for example catalog search and benchmarks without send_message or generate_image. Scalekit also enforces scope checks before every API call.
What happens when a user revokes access?
The credential is invalidated at the next tool call. The call fails closed, other users' connections are unaffected, and the revocation is logged in the audit chain.
Who gets billed when the agent sends a message or generates an image?
The authenticated user. send_message and generate_image bill the OpenRouter account of the person whose credential Scalekit resolved, so spend maps to real users. Pair get_generation with the audit chain to trace the cost, tokens, and provider of any call.
Start in your coding agent
Up and running in one command
Install the Scalekit skill in your editor of choice. Connector, auth, tools, prompt, all wired up
Claude Code REPL
/plugin marketplace add scalekit-inc/claude-code-authstack
/plugin install agentkit@scalekit-auth-stack
Cursor Code REPL
# ~/.cursor/mcp.json
{
""mcpServers"": {
""openroutermcp"": {
""url"": ""https://mcp.scalekit.com/openroutermcp"",
""headers"": { ""Authorization"": ""Bearer $SCALEKIT_TOKEN"" }
}
}
}
Codex Code REPL
# ~/.codex/config.toml
[mcp_servers.openroutermcp]
url = ""https://mcp.scalekit.com/openroutermcp""
auth_env = ""SCALEKIT_TOKEN""
Copilot Code REPL
# .vscode/mcp.json
{
""servers"": {
""openroutermcp"": {
""url"": ""https://mcp.scalekit.com/openroutermcp"",
""type"": ""http""
}
}
}