OpenRouter Proxy

This Apify Actor proxies the OpenRouter API over an OpenAI-compatible interface, billed to your Apify account on a pay-per-event basis.

What this Actor does

• Proxy access: Forwards API requests to OpenRouter's models
• OpenRouter SDK compatible: Works with the official @openrouter/sdk (TypeScript) and any OpenAI-compatible HTTP client
• Billing: Charges your Apify account at OpenRouter's rates (see Pricing)
• Supports: chat completions, embeddings, streaming, and image generation via modalities
• Multiple API formats: OpenAI (/chat/completions), Anthropic (/messages), and OpenAI Responses (/responses)
• Standby mode: Runs in Standby mode with a static URL, like a standard web server

Supported endpoints

Method	Endpoint	Description
POST	/api/v1/chat/completions	Chat completions (OpenAI format)
POST	/api/v1/systemone	System One (Jev, TypeSafe SDKs)
POST	/api/v1/messages	Messages (Anthropic format)
POST	/api/v1/responses	Responses (OpenAI Responses API)
POST	/api/v1/embeddings	Text embeddings
GET	/api/v1/models	List available models
GET	/api/v1/models/count	Model count
GET	/api/v1/models/user	User model preferences
GET	/api/v1/models/{author}/{slug}/endpoints	Model endpoints
GET	/api/v1/embeddings/models	Embedding models
GET	/api/v1/providers	Available providers
GET	/api/v1/endpoints/zdr	Zero-data-retention endpoints
GET	/api/v1/generation	Generation details

For full API documentation, see the OpenRouter API docs.

System One (Jev)

TypeSafe's Jev is a System One model: it returns typed decisions, not generated text, and does not use /api/v1/chat/completions. OpenRouter serves it on /api/v1/systemone, the route the TypeSafe SDKs append to their base URL, so @typesafe-ai/sdk / typesafe_sdk work by pointing baseURL at this Actor.

Send model, questions, and state; the response contains typed answers and usage.cost. The proxy uses that cost for the same pay-per-event billing as other inference endpoints. See the TypeSafe SDK guide for question types and request examples.

System One returns usage without an opt-in and has no max_tokens parameter. The proxy leaves these requests unchanged, including for FREE users; its existing billing and spending-limit handling still applies.

Pricing

This Actor uses a pay-per-event pricing model on the Apify platform. You pay for the tokens used by the OpenRouter API. Free tier users pay 10x more than paying users. Chat and Responses requests have a 2,048-output-token cap; System One has no output-token limit parameter.

Pricing structure

• Event: openrouter-api-usage
• Paying users: Pay the exact OpenRouter cost (rounded up to nearest $0.00001)

Pricing examples

OpenRouter cost	Calculation	Charged events	You pay	Markup factor
$0.00001212	0.00001212 / 0.00001	2	$0.00002	1.65x
$0.0001	0.0001 / 0.00001	10	$0.0001	1x (exact)
$0.001	0.001 / 0.00001	100	$0.001	1x (exact)
$0.01	0.01 / 0.00001	1,000	$0.01	1x (exact)

Quick start

The proxy only accepts calls from inside the Apify platform (caller type APIFY_ACTOR). The examples below use the official OpenRouter TypeScript SDK; any OpenAI-compatible HTTP client also works — point it at the same base URL and pass your Apify token as the bearer.

1. Install @openrouter/sdk

$npm install @openrouter/sdk

2. Basic usage

Point the SDK at the proxy with serverURL, and pass your Apify token as apiKey — the SDK sends it as Authorization: Bearer <token>, which is what the proxy expects.

import { OpenRouter } from '@openrouter/sdk';

const client = new OpenRouter({
    serverURL: 'https://openrouter.apify.actor/api/v1',
    apiKey: process.env.APIFY_TOKEN, // Apify token is loaded automatically in runtime
});

const result = await client.chat.send({
    chatRequest: {
        model: 'openrouter/auto',
        messages: [
            {
                role: 'user',
                content: 'What is the meaning of life?',
            },
        ],
    },
});

console.log(result.choices[0].message.content);

3. Streaming responses

Set stream: true inside chatRequest. The SDK returns an async iterable of SSE chunks; the final chunk carries the usage object the proxy uses for billing.

const stream = await client.chat.send({
    chatRequest: {
        model: 'openrouter/auto',
        messages: [
            {
                role: 'user',
                content: 'Write a short story about a robot.',
            },
        ],
        stream: true,
    },
});

for await (const chunk of stream) {
    process.stdout.write(chunk.choices[0]?.delta?.content ?? '');
}

4. Image generation

OpenRouter generates images through chat completions on image-capable models, using the modalities parameter:

const result = await client.chat.send({
    chatRequest: {
        model: 'google/gemini-2.5-flash-image', // Image-capable model
        messages: [
            {
                role: 'user',
                content: 'Generate an image of a cute baby sea otter',
            },
        ],
        modalities: ['text', 'image'], // Enable image generation
    },
});

// Generated image data lives on the assistant message
console.log(result.choices[0].message);

Note: OpenRouter does not expose an OpenAI-style /images/generations endpoint. Image generation goes through compatible chat-completion models. Check available image-capable models on OpenRouter's models page.

Using a different client

The proxy is OpenAI-compatible, so any client that lets you set the base URL and the Authorization header works — point it at https://openrouter.apify.actor/api/v1 and pass Authorization: Bearer <APIFY_TOKEN>. The OpenAI SDK can be wired up this way, but it currently rejects some of the SSE events OpenRouter emits on streamed responses; prefer @openrouter/sdk above.

Raw fetch works too:

const res = await fetch('https://openrouter.apify.actor/api/v1/chat/completions', {
    method: 'POST',
    headers: {
        'content-type': 'application/json',
        Authorization: `Bearer ${process.env.APIFY_TOKEN}`,
    },
    body: JSON.stringify({
        model: 'openrouter/auto',
        messages: [{ role: 'user', content: 'Hello' }],
    }),
});

Available models

Every model OpenRouter serves is reachable through this proxy. For the full list, see OpenRouter's models page or call GET /api/v1/models.

Authentication

The Actor uses your Apify token for authentication. In Actor environments on the Apify platform, APIFY_TOKEN is automatically available.

Support

For issues related to this Actor, please open an issue or contact the Actor developer on Apify Store.