A Information to OpenRouter for AI Growth

Constructing with AI in the present day can really feel messy. You may use one API for textual content, one other for photographs, and a distinct one for one thing else. Each mannequin comes with its personal setup, API key, and billing. This slows you down and makes issues more durable than they have to be. What when you may use all these fashions via one easy API. That’s the place OpenRouter helps. It offers you one place to entry fashions from suppliers like OpenAI, Google, Anthropic and extra. On this information, you’ll learn to use OpenRouter step-by-step, out of your first API name to constructing actual purposes. 

What’s OpenRouter? 

OpenRouter allows you to entry many AI fashions utilizing a single API. You don’t have to arrange every supplier individually. You join as soon as, use one API key, and write one set of code. OpenRouter handles the remainder, like authentication, request formatting, and billing. This makes it straightforward to strive completely different fashions. You’ll be able to change between fashions like GPT-5, Claude 4.6, Gemini 3.1 Professional, or Llama 4 by altering only one parameter in your code. This helps you select the precise mannequin primarily based on value, velocity or options like reasoning and picture understanding.

How OpenRouter Works?

OpenRouter acts as a bridge between your software and completely different AI suppliers. Your app sends a request to the OpenRouter API, and it converts that request into a regular format that any mannequin can perceive. 

A cutting-edge routing engine is then concerned. It can discover the perfect supplier of your request in response to a set of rule you could set. To present an instance, it may be set to present choice to essentially the most cheap supplier, the one with the shortest latency, or merely these with a specific knowledge privateness requirement similar to Zero Knowledge Retention (ZDR).

The platform retains observe of the efficiency and uptime of all of the suppliers and as such, is ready to make clever, real-time routing selections. In case your most popular supplier will not be functioning correctly, the OpenRouter fails over to a known-good one robotically and improves the steadiness of your software. 

Getting Began: Your First API Name 

OpenRouter can also be straightforward to arrange since it’s a hosted service, i.e. there is no such thing as a software program to be put in. It may be prepared in a matter of minutes:

Step 1: Create an Account and Get Credit:

First, enroll at OpenRouter.ai. To make use of the paid fashions, you’ll need to buy some credit.

Step 2: Generate an API Key

Navigate to the “Keys” part in your account dashboard. Click on “Create Key,” give it a reputation, and replica the important thing securely. For greatest apply, use separate keys for various environments (e.g., dev, prod) and set spending limits to manage prices.

Step 3: Configure Your Setting

Retailer your API key in an setting variable to keep away from exposing it in your code.

Step 4: Native Setup utilizing an Setting Variable:

For macOS or Linux:

export OPENROUTER_API_KEY="your-secret-key-here"

For Home windows (PowerShell):

setx OPENROUTER_API_KEY "your-secret-key-here"

Making a Request on OpenRouter

Since OpenRouter has an API that’s suitable with OpenAI, you should utilize official OpenAI shopper libraries to make requests. This renders the method of migration of an already accomplished OpenAI mission extremely straightforward.

Python Instance utilizing the OpenAI SDK 

# First, guarantee you have got the library put in:
# pip set up openai

import os
from openai import OpenAI

# Initialize the shopper, pointing it to OpenRouter's API
shopper = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ.get("OPENROUTER_API_KEY"),
)

# Ship a chat completion request to a particular mannequin
response = shopper.chat.completions.create(
    mannequin="openai/gpt-4.1-nano",
    messages=[
        {
            "role": "user",
            "content": "Explain AI model routing in one sentence."
        },
    ],
)

print(response.decisions[0].message.content material)

Output:

Exploring Fashions and Superior Routing 

OpenRouter exhibits its true energy past easy requests. Its platform helps dynamic and clever AI mannequin routing.

Programmatically Discovering Fashions 

As fashions are constantly added or up to date, you aren’t imagined to hardcode mannequin names in considered one of your manufacturing apps, as a substitute openrouter has a /fashions endpoint that returns the listing of all out there fashions with advised pricing, context limits and capabilities. 

import os
import requests

# Fetch the listing of accessible fashions
response = requests.get(
    "https://openrouter.ai/api/v1/fashions",
    headers={
        "Authorization": f"Bearer {os.environ.get('OPENROUTER_API_KEY')}"
    },
)

if response.status_code == 200:
    fashions = response.json()["data"]

    # Filter for fashions that assist instrument use
    tool_use_models = [
        m for m in models
        if "tools" in (m.get("supported_parameters") or [])
    ]

    print(f"Discovered {len(fashions)} complete fashions.")
    print(f"Discovered {len(tool_use_models)} fashions that assist instrument use.")
else:
    print(f"Error fetching fashions: {response.textual content}"

Output:

Clever Routing and Fallbacks 

You’ll be able to handle the best way OpenRouter chooses a supplier and may set backups in case of a request failure. That is the important resilience of manufacturing methods. 

• Routing: Ship a supplier object into your request to rank fashions by latency or worth, or serve insurance policies similar to zdr (Zero Knowledge Retention). 
• Fallbacks: When the previous fails, OpenRouter robotically makes an attempt the next within the listing. Solely the profitable try can be charged. 

Here’s a Python instance demonstrating a fallback chain:

# The first mannequin is 'openai/gpt-4.1-nano'
# If it fails, OpenRouter will strive 'anthropic/claude-3.5-sonnet',
# then 'google/gemini-2.5-pro'

response = shopper.chat.completions.create(
    mannequin="openai/gpt-4.1-nano",
    extra_body={
        "fashions": [
            "anthropic/claude-3.5-sonnet",
            "google/gemini-2.5-pro"
        ]
    },
    messages=[
        {
            "role": "user",
            "content": "Write a short poem about space."
        }
    ],
)

print(f"Mannequin used: {response.mannequin}")
print(response.decisions[0].message.content material)

Output:

Mastering Superior Capabilities

The identical chat completions API can be utilized to ship photographs to any imaginative and prescient succesful mannequin to research them. All that’s wanted is so as to add the picture as a URL, or a base64-encoded string to your messages array. 

Structured Outputs (JSON Mode)

Want a dependable JSON output? You’ll be able to instruct any suitable mannequin to return a response that conforms to a particular JSON schema.The OpenRouter even has an elective Response Therapeutic plugin that can be utilized to restore malformed JSON attributable to fashions which have points with strict formatting.

# Requesting a structured JSON output

response = shopper.chat.completions.create(
    mannequin="openai/gpt-4.1-nano",
    messages=[
        {
            "role": "user",
            "content": "Extract the name and age from this text: 'John is 30 years old.' in JSON format."
        }
    ],
    response_format={
        "kind": "json_object",
        "json_schema": {
            "title": "user_schema",
            "schema": {
                "kind": "object",
                "properties": {
                    "title": {"kind": "string"},
                    "age": {"kind": "integer"}
                },
                "required": ["name", "age"],
            },
        },
    },
)

print(response.decisions[0].message.content material)

Output:

Multimodal Inputs: Working with Photos 

You should use the identical chat completions API to ship photographs to any vision-capable mannequin for evaluation. Merely add the picture as a URL or a base64-encoded string to your messages array.

# Sending a picture URL for evaluation

response = shopper.chat.completions.create(
    mannequin="openai/gpt-4.1-nano",
    messages=[
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "What is in this image?"
                },
                {
                    "type": "image_url",
                    "image_url": {
                        "url": "https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRmqgVW-371UD3RgE3HwhF11LYbGcVfn9eiTYqiw6a8fK51Es4SYBK0fNVyCnJzQit6YKo9ze3vg1tYoWlwqp3qgiOmRxkTg1bxPwZK3A&s=10"
                    }
                },
            ],
        }
    ],
)

print(response.decisions[0].message.content material)

Output:

A Price-Conscious, Multi-Supplier Agent

The precise energy of OpenRouter lies within the growth of superior, reasonably priced, and excessive availability purposes. As an illustration, we will develop a practical agent that may dynamically select the perfect mannequin to accomplish a particular job with assistance from a tiered strategy to cheap-to-smart technique. 

The very first thing that this agent will do is to try to reply to a question supplied by a consumer utilizing a quick and low cost mannequin. In case that mannequin will not be ok (e.g. in case the duty includes deep reasoning) it will upwardly redirect the question to a extra highly effective, premium mannequin. It is a typical development in terms of manufacturing purposes which should strike a steadiness between efficiency, worth, and high quality. 

The “Low-cost-to-Sensible” Logic

Our agent will comply with these steps: 

• Obtain a consumer’s immediate. 
• Ship the immediate to a low value mannequin at first. 
• Look at the response to decide whether or not the mannequin was in a position to reply to the request. One straightforward technique of doing that is to request the mannequin to offer a confidence rating with its output. 
• When the boldness is low, the agent will robotically repeat the identical immediate with a high-end mannequin which leads to an excellent reply to a posh job. 

This strategy ensures you aren’t overpaying for easy requests whereas nonetheless having the ability of top-tier fashions on demand. 

Python Implementation

Right here’s how one can implement this logic in Python. We’ll use structured outputs to ask the mannequin for its confidence degree, which makes parsing the response dependable. 

from openai import OpenAI
import os
import json

# Initialize the shopper for OpenRouter
shopper = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key=os.environ.get("OPENROUTER_API_KEY"),
)


def run_cheap_to_smart_agent(immediate: str):
    """
    Runs a immediate first via an inexpensive mannequin, then escalates to a
    smarter mannequin if confidence is low.
    """

    cheap_model = "mistralai/mistral-7b-instruct"
    smart_model = "openai/gpt-4.1-nano"

    # Outline the specified JSON construction for the response
    json_schema = {
        "kind": "object",
        "properties": {
            "reply": {"kind": "string"},
            "confidence": {
                "kind": "integer",
                "description": "A rating from 1-100 indicating confidence within the reply.",
            },
        },
        "required": ["answer", "confidence"],
    }

    # First, strive a budget mannequin
    print(f"--- Making an attempt with low cost mannequin: {cheap_model} ---")

    strive:
        response = shopper.chat.completions.create(
            mannequin=cheap_model,
            messages=[
                {
                    "role": "user",
                    "content": f"Answer the following prompt and provide a confidence score from 1-100. Prompt: {prompt}",
                }
            ],
            response_format={
                "kind": "json_object",
                "json_schema": {
                    "title": "agent_response",
                    "schema": json_schema,
                },
            },
        )

        # Parse the JSON response
        outcome = json.hundreds(response.decisions[0].message.content material)
        reply = outcome.get("reply")
        confidence = outcome.get("confidence", 0)

        print(f"Low-cost mannequin confidence: {confidence}")

        # If confidence is under a threshold (e.g., 70), escalate
        if confidence < 70:
            print(f"--- Confidence low. Escalating to sensible mannequin: {smart_model} ---")

            # Use an easier immediate for the sensible mannequin
            smart_response = shopper.chat.completions.create(
                mannequin=smart_model,
                messages=[
                    {
                        "role": "user",
                        "content": prompt,
                    }
                ],
            )

            final_answer = smart_response.decisions[0].message.content material
        else:
            final_answer = reply

    besides Exception as e:
        print(f"An error occurred with a budget mannequin: {e}")
        print(f"--- Falling again on to sensible mannequin: {smart_model} ---")

        smart_response = shopper.chat.completions.create(
            mannequin=smart_model,
            messages=[
                {
                    "role": "user",
                    "content": prompt,
                }
            ],
        )

        final_answer = smart_response.decisions[0].message.content material

    return final_answer


# --- Check the Agent ---

# 1. A easy immediate that a budget mannequin can deal with
simple_prompt = "What's the capital of France?"
print(f"Remaining Reply for Easy Immediate:n{run_cheap_to_smart_agent(simple_prompt)}n")

# 2. A posh immediate that may seemingly require escalation
complex_prompt = "Present an in depth comparability of the transformer structure and recurrent neural networks, specializing in their respective benefits for sequence processing duties."
print(f"Remaining Reply for Complicated Immediate:n{run_cheap_to_smart_agent(complex_prompt)}")

Output:

This hands-on instance goes past a easy API name and showcases find out how to architect a extra clever, cost-effective system utilizing OpenRouter’s core strengths: mannequin selection and structured outputs. 

Monitoring and Observability

Understanding your software’s efficiency and prices is essential. OpenRouter supplies built-in instruments to assist. 

• Utilization Accounting: Each API response comprises detailed metadata about token utilization and value for that particular request, permitting for real-time expense monitoring. 
• Broadcast Function: With none additional code, you possibly can configure OpenRouter to robotically ship detailed traces of your API calls to observability platforms like Langfuse or Datadog. This supplies deep insights into latency, errors, and efficiency throughout all fashions and suppliers. 

Conclusion

The period of being tethered to a single AI supplier is over. Instruments like OpenRouter are basically altering the developer expertise by offering a layer of abstraction that unlocks unprecedented flexibility and resilience. By unifying the fragmented AI panorama, OpenRouter not solely saves you from the tedious work of managing a number of integrations but additionally empowers you to construct smarter, cheaper, and strong purposes. The way forward for AI growth will not be about choosing one winner; it’s about having seamless entry to all of them. With this information, you now have the map to navigate that future. 

Incessantly Requested Questions

Harsh Mishra is an AI/ML Engineer who spends extra time speaking to Giant Language Fashions than precise people. Keen about GenAI, NLP, and making machines smarter (in order that they don’t substitute him simply but). When not optimizing fashions, he’s in all probability optimizing his espresso consumption. 🚀☕