DEV Community: RouterBase

Call GLM-5.2 from the OpenAI Python SDK with RouterBase

RouterBase — Mon, 20 Jul 2026 08:30:30 +0000

GLM-5.2 is live on RouterBase. If you already use the OpenAI Python SDK, you do not need another client library. Keep the SDK, change the base URL, and use the exact live model ID.

Prerequisites

Python 3.9 or later
A RouterBase API key stored as ROUTERBASE_API_KEY
The current openai package

pip install openai

Make the call

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ROUTERBASE_API_KEY"],
    base_url="https://routerbase.com/v1",
)

response = client.chat.completions.create(
    model="zai/glm-5-2/chat",
    messages=[
        {
            "role": "system",
            "content": "You are a careful software engineering assistant.",
        },
        {
            "role": "user",
            "content": "Give me a five-point review checklist for a risky database migration.",
        },
    ],
    max_tokens=800,
)

print(response.choices[0].message.content)

The two RouterBase-specific values are:

base_url = https://routerbase.com/v1
model = zai/glm-5-2/chat

Do not shorten the model name to glm-5.2. RouterBase's live model page currently exposes the full ID zai/glm-5-2/chat, and exact IDs prevent an integration from silently pointing at the wrong route.

Before sending a million-token prompt

Z.ai documents a 1M-token context window for GLM-5.2. That is a ceiling, not a recommended starting prompt.

Start with a smaller baseline, then increase context while recording:

Time to first token and total wall-clock time.
Whether the answer uses the right evidence from the prompt.
Tool-call failures and retry behavior.
Whether tool state survives a long, multi-step run.
Cost per successful task, not only cost per token.

A longer context window reduces some chunking pressure, but it does not replace retrieval tests, observability, or a fallback path.

Scope and limitations

This quickstart verifies the current RouterBase base URL and model ID. It does not claim a benchmark ranking, a latency target, or a fixed price. Those values can change, so check the live model page before a production rollout.

Switch AI Models Without Rewriting Your OpenAI SDK Integration

RouterBase — Thu, 16 Jul 2026 02:17:58 +0000

If your application already uses the OpenAI Python SDK, you can keep the same client and point it at RouterBase by changing the base URL.

This gives the application one request interface while model selection stays configurable.

Prerequisites

Python 3.9 or newer
The current openai package
A RouterBase API key stored in an environment variable

Install the SDK:

pip install --upgrade openai

Set the key in your shell:

export ROUTERBASE_API_KEY="sk-rb-..."

Do not place an API key in browser code, mobile binaries, or a public repository.

Create the client

import os
from openai import OpenAI

client = OpenAI(
    api_key=os.environ["ROUTERBASE_API_KEY"],
    base_url="https://routerbase.com/v1",
)

The important line is base_url. The SDK remains the same; requests go through the RouterBase OpenAI-compatible endpoint.

Make a chat request

Choose a model ID from the current RouterBase model catalog and keep it in configuration instead of hard-coding it throughout the application.

import os

model_id = os.environ.get(
    "ROUTERBASE_MODEL",
    "google/gemini-2.5-flash",
)

response = client.chat.completions.create(
    model=model_id,
    messages=[
        {
            "role": "user",
            "content": "Explain idempotency in one paragraph.",
        }
    ],
)

print(response.choices[0].message.content)

To test a different compatible chat model, change ROUTERBASE_MODEL and run the same request again.

Add a small evaluation before switching

A successful API response is not enough to justify moving production traffic. Test candidate models against the same tasks and rubric.

candidates = [
    "google/gemini-2.5-flash",
    # Add other current RouterBase chat model IDs here.
]

prompt = "Return a JSON object with keys: summary and risk."

for candidate in candidates:
    result = client.chat.completions.create(
        model=candidate,
        messages=[{"role": "user", "content": prompt}],
    )
    print(candidate, result.choices[0].message.content)

In a real evaluation, record correctness, latency, retry rate, and the cost of a successful task.

Important caveats

An OpenAI-compatible endpoint does not mean every model has identical behavior.

Before switching models, verify:

tool and function calling behavior;
structured output requirements;
supported input modalities;
context and output limits;
streaming behavior;
model-specific parameters.

Keep the integration stable, but keep the evaluation model-specific.

RouterBase provides one OpenAI-compatible API for GPT, Claude, Gemini, and 200+ AI models. Check the live catalog before using a model ID in production.

One OpenAI-compatible endpoint for 200+ AI models

RouterBase — Tue, 02 Jun 2026 11:47:11 +0000

If you build with multiple LLM providers, you've probably written a separate integration for each one — OpenAI, Anthropic, Google, Meta. Different SDKs, different auth, different billing.

RouterBase is an AI API gateway that collapses this into a single OpenAI-compatible endpoint. You connect once and route requests to 200+ models across providers. Switching models is a string change, not a code rewrite.

What it does

One endpoint, 200+ models — chat, reasoning, vision, embeddings
Drop-in OpenAI compatibility — point your existing client at a new base URL
Smart routing — pick a provider by price, latency, or availability, with automatic fallback
Unified usage tracking — one dashboard and one bill across every provider

There's a free tier with usage-based pricing, so cost scales with what you actually use.

Docs and signup: https://routerbase.com