> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://respan.ai/docs/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://respan.ai/docs/_mcp/server.

# Provider: OpenRouter

> **Note**
>
> This page is for **Respan LLM Gateway** users.

Use Respan Gateway to call OpenRouter models (`openrouter/openai/gpt-6-sol`, `openrouter/anthropic/claude-opus-5.5`, `openrouter/cohere/command-a-plus`, and hundreds of others) while keeping unified observability (logs, cost, latency, reliability) in Respan.

## Quick setup

#### Get a Respan API key

[Sign up](https://platform.respan.ai) and create a key on the [API keys page](https://platform.respan.ai/platform/gateway/api-keys).

#### Add credits (recommended)

[Top up credits](https://platform.respan.ai/platform/gateway/credits) to pay through Respan. No OpenRouter key required, Respan handles provider auth and billing.

Prefer to route through your own OpenRouter account? See [Use your own OpenRouter key](#use-your-own-openrouter-key-byok).

## Send your first request

Pick the integration that matches your stack. The base URL is `https://api.respan.ai/api` and the only key needed is your `RESPAN_API_KEY`.

#### OpenAI SDK

OpenRouter is OpenAI-compatible. Point the OpenAI SDK at the Respan gateway and call any OpenRouter model with the `openrouter/` prefix.

**`Python`**

```python Python
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_RESPAN_API_KEY",
    base_url="https://api.respan.ai/api",
)

response = client.chat.completions.create(
    model="openrouter/openai/gpt-6-sol",
    messages=[{"role": "user", "content": "Hello, OpenRouter!"}],
)
print(response.choices[0].message.content)
```

**`TypeScript`**

```typescript TypeScript
import OpenAI from "openai";

const client = new OpenAI({
  apiKey: process.env.RESPAN_API_KEY,
  baseURL: "https://api.respan.ai/api",
});

const response = await client.chat.completions.create({
  model: "openrouter/openai/gpt-6-sol",
  messages: [{ role: "user", content: "Hello, OpenRouter!" }],
});
console.log(response.choices[0].message.content);
```

#### Vercel AI SDK

Call `respan.chat(...)` explicitly to use the Gateway Chat Completions endpoint.

Use `@ai-sdk/openai` and point `createOpenAI` at the Respan gateway.

**`TypeScript`**

```typescript TypeScript
import { createOpenAI } from "@ai-sdk/openai";
import { generateText } from "ai";

const respan = createOpenAI({
  apiKey: process.env.RESPAN_API_KEY!,
  baseURL: "https://api.respan.ai/api",
});

const result = await generateText({
  model: respan.chat("openrouter/openai/gpt-6-sol"),
  prompt: "Hello, OpenRouter!",
});
console.log(result.text);
```

#### Respan API

Call the Respan REST API directly from any language.

**`Python`**

```python Python
import requests

response = requests.post(
    "https://api.respan.ai/api/chat/completions",
    headers={
        "Authorization": "Bearer YOUR_RESPAN_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "model": "openrouter/openai/gpt-6-sol",
        "messages": [{"role": "user", "content": "Hello, OpenRouter!"}],
    },
)
print(response.json()["choices"][0]["message"]["content"])
```

**`TypeScript`**

```typescript TypeScript
const response = await fetch("https://api.respan.ai/api/chat/completions", {
  method: "POST",
  headers: {
    Authorization: `Bearer ${process.env.RESPAN_API_KEY}`,
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    model: "openrouter/openai/gpt-6-sol",
    messages: [{ role: "user", content: "Hello, OpenRouter!" }],
  }),
});

const data = await response.json();
console.log(data.choices[0].message.content);
```

## More integrations

OpenRouter models work with every Respan gateway integration:

* [OpenAI SDK](/docs/integrations/openai-sdk)
* [OpenAI Agents SDK](/docs/integrations/openai-agents-sdk)
* [LangChain](/docs/integrations/langchain)
* [LangGraph](/docs/integrations/langgraph)
* [LlamaIndex](/docs/integrations/llama-index)
* [Pydantic AI](/docs/integrations/pydantic-ai)
* [Respan native (OTel)](/docs/documentation/features/gateway/gateway-quickstart)

## Switch models

Change the `model` parameter to call any supported model through the same client. Use the `openrouter/` prefix to disambiguate when routing across providers. Browse the full list on the [Models page](https://platform.respan.ai/platform/models).

```python
client.chat.completions.create(model="openrouter/openai/gpt-6-sol", messages=messages)
client.chat.completions.create(model="openrouter/anthropic/claude-opus-5.5", messages=messages)
client.chat.completions.create(model="openrouter/cohere/command-a-plus", messages=messages)
client.chat.completions.create(model="openai/gpt-6-sol", messages=messages)
client.chat.completions.create(model="anthropic/claude-opus-5-5", messages=messages)
```

## Use your own OpenRouter key (BYOK)

Credits are the default path. If you'd rather bill OpenRouter directly, attach your own provider key.

#### Global (UI)

#### Open Providers

Go to the [Providers page](https://platform.respan.ai/platform/gateway/api-keys?providers=1).

#### Add OpenRouter

Select **OpenRouter** and paste your `openrouter.api_key`. Grab one from the [OpenRouter keys page](https://openrouter.ai/keys).

#### Load balancing (Optional)

Add multiple credential sets and use **Load balancing weight** to distribute traffic across them.

#### Per-request (Code)

Pass `customer_credentials` on each [Gateway request](/docs/apis/gateway/create-chat-completion). Useful when serving end-user keys.

```json
{
  "customer_credentials": {
    "openrouter": {
      "api_key": "YOUR_OPENROUTER_API_KEY"
    }
  }
}
```

#### Native passthrough (Header)

The [OpenRouter passthrough](/docs/documentation/features/gateway/routing-and-passthrough#openrouter) takes your key in a header rather than the body, and is always BYOK. It relays the request to OpenRouter with no Respan schema in between, so OpenRouter body fields and response fields that Respan's OpenAI-compatible schema does not model still reach you.

```python
from openai import OpenAI

client = OpenAI(
    api_key="YOUR_RESPAN_API_KEY",
    base_url="https://api.respan.ai/api/openrouter/v1",
    default_headers={"x-openrouter-api-key": "YOUR_OPENROUTER_API_KEY"},
)
```

Use OpenRouter's own model slug here, without the `openrouter/` prefix.

### Override credentials per model (Optional)

Use [`credential_override`](/docs/documentation/admin/llm-provider-keys#per-model-credential-override) when one model on a request should use a different OpenRouter key than the default.

```json
{
  "customer_credentials": {
    "openrouter": { "api_key": "YOUR_OPENROUTER_API_KEY" }
  },
  "credential_override": {
    "openrouter/openai/gpt-6-sol": { "api_key": "ANOTHER_OPENROUTER_API_KEY" }
  }
}
```

## Log without proxying (Optional)

Already calling OpenRouter directly? Send logs to Respan asynchronously to track cost, latency, and performance for those external calls.

```python
import requests

requests.post(
    "https://api.respan.ai/api/request-logs/create/",
    headers={
        "Authorization": "Bearer YOUR_RESPAN_API_KEY",
        "Content-Type": "application/json",
    },
    json={
        "model": "openrouter/openai/gpt-6-sol",
        "prompt_messages": [{"role": "user", "content": "Hello, how are you?"}],
        "completion_message": {"role": "assistant", "content": "Hello from OpenRouter through Respan."},
        "cost": 0.001,
        "generation_time": 1.2,
        "customer_params": {"customer_identifier": "user_123"},
    },
)
```

See the [logging guide](/docs/apis/spans/create-span) for the full setup.