Cerebras Inference on OpenRouter

OpenRouter provides a unified API that gives you access to multiple AI providers, including Cerebras, through a single interface. This means you can use familiar tools and SDKs to access Cerebras’s ultra-fast inference without changing your existing code structure. For a complete list of Cerebras Inference powered models available on OpenRouter, visit the OpenRouter site.

Prerequisites

Before you begin, ensure you have:

OpenRouter API Key - Create a free account and get your API key at OpenRouter
Python 3.10 or higher (for Python examples) or Node.js 20+ (for JavaScript examples)

Quick Start

Install Dependencies

Choose your preferred method:

pip install requests

npm install @langchain/openai dotenv

Set Your API Key

Create a .env file in your project directory:

OPENROUTER_API_KEY=your_openrouter_key_here

Or set it as an environment variable:

export OPENROUTER_API_KEY="your_openrouter_key_here"

Make Your First API Call

Choose your preferred method to query GPT-OSS 120B on Cerebras:

import os
import requests

# Set your OpenRouter API key
api_key = os.getenv("OPENROUTER_API_KEY")

url = "https://openrouter.ai/api/v1/chat/completions"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}

# Define the request payload
data = {
    "model": "openai/gpt-oss-120b",
    "provider": {
        "only": ["Cerebras"]
    },
    "messages": [
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "What is the capital of France?"}
    ]
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Print the response
print(response.json())

import 'dotenv/config';
import { ChatOpenAI } from "@langchain/openai";
import { HumanMessage, SystemMessage } from "@langchain/core/messages";

// Initialize ChatOpenAI with OpenRouter
const llm = new ChatOpenAI({
  modelName: "openai/gpt-oss-120b",
  apiKey: process.env.OPENROUTER_API_KEY,
  timeout: 10000, // 10 second timeout
  configuration: {
    baseURL: "https://openrouter.ai/api/v1",
    defaultHeaders: {
      "HTTP-Referer": "https://cerebras.ai",
      "X-Title": "Cerebras"
    }
  },
  modelKwargs: {
    provider: {
      order: ["Cerebras"]
    }
  }
});

// Create messages
const messages = [
  new SystemMessage("You are a helpful assistant."),
  new HumanMessage("What is the capital of France?")
];

// Get response
try {
  const response = await llm.invoke(messages);
  console.log(response.content);
} catch (error) {
  console.error('Error:', error.message);
  // Note: If you see a 402 error, add credits at https://openrouter.ai/settings/credits
}

Advanced Examples

You did it, your first API call is complete! Now, let’s explore how to make your model smarter at handling tasks and more precise in how it formats its responses via structured outputs and tool calling. See the examples below for how to use both.

import os
import requests
import json

api_key = os.getenv("OPENROUTER_API_KEY")
url = "https://openrouter.ai/api/v1/chat/completions"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json"
}

# Define the JSON schema for the expected output
movie_schema = {
    "type": "object",
    "properties": {
        "title": {"type": "string"},
        "director": {"type": "string"},
        "year": {"type": "integer"}
    },
    "required": ["title", "director", "year"],
    "additionalProperties": False
}

data = {
    "model": "openai/gpt-oss-120b",
    "provider": {
        "only": ["Cerebras"]
    },
    "messages": [
        {"role": "system", "content": "You are a helpful assistant that generates movie recommendations."},
        {"role": "user", "content": "Suggest a sci-fi movie from the 1990s."}
    ],
    "response_format": {
        "type": "json_schema",
        "json_schema": {
            "name": "movie_schema",
            "strict": True,
            "schema": movie_schema
        }
    }
}

# Parse and display the result
response = requests.post(url, headers=headers, json=data)
result = response.json()
if 'choices' in result:
    movie_data = json.loads(result['choices'][0]['message']['content'])
    print(json.dumps(movie_data, indent=2))
else:
    print(f"Error: {result}")

import os
import requests
import json

api_key = os.getenv("OPENROUTER_API_KEY")

url = "https://openrouter.ai/api/v1/chat/completions"

headers = {
    "Authorization": f"Bearer {api_key}",
    "Content-Type": "application/json",
    "HTTP-Referer": "https://cerebras.ai",
    "X-Title": "Cerebras"
}

# Define the calculator tool
tools = [
    {
        "type": "function",
        "function": {
            "name": "calculator",
            "description": "Performs mathematical calculations.",
            "parameters": {
                "type": "object",
                "properties": {
                    "expression": {
                        "type": "string",
                        "description": "A mathematical expression to evaluate, e.g., 'sqrt(16)'"
                    }
                },
                "required": ["expression"]
            }
        }
    }
]

# Define the message history
messages = [
    {"role": "system", "content": "You are a helpful assistant capable of performing mathematical calculations using the calculator tool."},
    {"role": "user", "content": "Is the square root of 16 equal to 4?"},
]

# Define the request payload
data = {
    "model": "openai/gpt-oss-120b",
    "provider": {
        "only": ["Cerebras"]
    },
    "messages": messages,
    "tools": tools,
    "tool_choice": "auto"
}

# Send the POST request
response = requests.post(url, headers=headers, json=data)

# Parse the response
result = response.json()

# Extract the tool call
if 'choices' not in result:
    print(f"Error: {result}")
else:
    assistant_message = result['choices'][0]['message']
    tool_calls = assistant_message.get('tool_calls', [])
    if tool_calls:
        # Preserve the assistant message that requested the tool call
        messages.append(assistant_message)

        for tool_call in tool_calls:
            function_name = tool_call['function']['name']
            arguments = json.loads(tool_call['function']['arguments'])
            expression = arguments.get('expression')

            # Simulate executing the calculator function
            try:
                # WARNING: Using eval can be dangerous. In production, use a safe math parser.
                calculation_result = eval(expression, {"__builtins__": None}, {"sqrt": lambda x: x ** 0.5})
                tool_response = f"The result of {expression} is {calculation_result}."
                
            except Exception as e:
                tool_response = f"Error evaluating expression: {e}"

            # Append the tool's response to the message history
            messages.append({
                "role": "tool",
                "tool_call_id": tool_call['id'],
                "content": tool_response
            })

            # Send the updated message history back to the model
            data = {
                "model": "openai/gpt-oss-120b",
                "provider": {
                    "only": ["Cerebras"]
                },
                "messages": messages
            }

            response = requests.post(url, headers=headers, json=data)
            final_result = response.json()
            if 'choices' in final_result:
                assistant_reply = final_result['choices'][0]['message']['content']
                print(assistant_reply)
            else:
                print(f"Error: {final_result}")
    else:
        print("No tool calls were made by the model.")

Available Models

OpenRouter provides access to all Cerebras models:

Model	Parameters	Best For
openai/gpt-oss-120b	120B	Production text, coding, and tool-use workloads
google/gemma-4-31b-it	31B	Preview multimodal workloads with text and image input
z-ai/glm-4.7	355B	Preview reasoning workloads until its scheduled deprecation on August 17, 2026

Visit the OpenRouter Cerebras provider page for the complete list of available models.

FAQ

What context length can I run?

This varies by model. See our provider page to view max context length for each model.

What additional latency can I expect when using Cerebras through OpenRouter?

A marginal amount of latency may appear as Cerebras Inference is only available via proxy, which has to be queried after your initial API request.

Can I send images through OpenRouter?

Yes. Select google/gemma-4-31b-it, pin the request to Cerebras with provider.only, and send the image as an image_url content part. The other listed models accept text input only.

Integrations

Agentic Frameworks

AI Development Kits

Coding Tools

Containerization

Observability & Evaluation

LLM Integration Tools

LLM Application Frameworks

Document Processing

Real-Time Audio

Multi-LLM Management

No-Code/Low-Code Platforms

Cerebras Inference on OpenRouter

Prerequisites

Quick Start

Available Models

FAQ

​Prerequisites

​Quick Start

​Available Models

​FAQ

Prerequisites

Quick Start

Available Models

FAQ