Disclosure: I work on APIGOTO, the gateway used in this tutorial. This is our own product. APIGOTO is an independent service and is not affiliated with, endorsed by, or partnered with Anthropic, OpenAI or Google. Claude, GPT and Gemini are trademarks of their respective owners.

If you've built anything with LLMs in the last year, you probably have a .env file that looks like this:

OPENAI_API_KEY=...
ANTHROPIC_API_KEY=...
GEMINI_API_KEY=...
DEEPSEEK_API_KEY=...

Four keys, three or four SDKs, separate billing dashboards, and slightly different request formats. Want to compare Claude against GPT on the same prompt? That's an adapter layer you now have to maintain.

This post shows a simpler pattern: keep the OpenAI SDK you already use, change only base_url and api_key, and pick the model family by name. I'll use APIGOTO as the gateway because that's what I work on, but the pattern works with any OpenAI-compatible gateway, so the code here is useful even if you never use ours.

The idea in one diagram

your app ──(OpenAI SDK)──▶ https://api.china-aiapi.com/v1 ──▶ Claude / GPT / Gemini /
                                  │                          DeepSeek / Qwen / Kimi / GLM ...
                                  └─ routing, failover, usage logs

Your code speaks one protocol (OpenAI Chat Completions). The gateway translates and forwards to the upstream provider that serves the model you asked for.

Step 1: Get a key

1. Sign up at www.china-aiapi.com. New accounts get free credits to test with; amounts, eligibility and limits are listed on the site.

2. Create an API key in the console.

3. Open the model list in the console and copy the exact model IDs you want. Model IDs differ between gateways, so don't guess them. The IDs below (claude-sonnet-5-5, gpt-6-sol, gemini-3.1-pro-preview, deepseek-v4-pro) were on APIGOTO's public model list when this was written; the catalog changes, so check it before you run the code.

export APIGOTO_API_KEY="sk-..."   # never commit this

Step 2: Python, only base_url changes

pip install openai

import os
from openai import OpenAI

client = OpenAI(
    base_url="https://api.china-aiapi.com/v1",   # the only change vs. calling OpenAI directly
    api_key=os.environ["APIGOTO_API_KEY"],
)

# Model IDs from APIGOTO's public model list (check the console for the current catalog)
MODELS = {
    "claude": "claude-sonnet-5-5",
    "gpt": "gpt-6-sol",
    "gemini": "gemini-3.1-pro-preview",
    "deepseek": "deepseek-v4-pro",
}

prompt = "Explain idempotency keys in two sentences."

for family, model in MODELS.items():
    resp = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": prompt}],
        max_tokens=200,
    )
    print(f"--- {family} ({model}) ---")
    print(resp.choices[0].message.content)
    print("tokens:", resp.usage.total_tokens if resp.usage else "n/a")

That's the whole integration. No Anthropic SDK, no Google SDK, no adapter.

Streaming works the same way

stream = client.chat.completions.create(
    model=MODELS["claude"],
    messages=[{"role": "user", "content": "Write a haiku about retries."}],
    stream=True,
)
for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
print()

Step 3: Node.js, same story

npm install openai

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.china-aiapi.com/v1", // the only change
  apiKey: process.env.APIGOTO_API_KEY,
});

// Model IDs from APIGOTO's public model list (check the console for the current catalog)
const models = ["claude-sonnet-5-5", "gpt-6-sol", "gemini-3.1-pro-preview", "deepseek-v4-pro"];

for (const model of models) {
  const resp = await client.chat.completions.create({
    model,
    messages: [{ role: "user", content: "Give me one tip for writing good commit messages." }],
    max_tokens: 150,
  });
  console.log(`--- ${model} ---\n${resp.choices[0].message.content}\n`);
}

Run it with node compare.mjs. If you already have an app on the OpenAI SDK, the migration is usually a two-line diff: baseURL and apiKey.

cURL, for completeness

curl https://api.china-aiapi.com/v1/chat/completions \
  -H "Authorization: Bearer $APIGOTO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model": "gemini-3.1-pro-preview", "messages": [{"role": "user", "content": "ping"}]}'

What happens when an upstream fails?

This is where a gateway does more than proxy requests. In APIGOTO, a request is routed by:

exact model → exact protocol → linked priority → provider priority → health score

The same model can be served by more than one upstream provider. If one fails, the gateway retries on another credential, up to 3 automatic credential retries per request. That's a hard limit, and it's worth knowing about: if every upstream for a model is down, you'll still get an error, so keep your own timeout and retry logic in place.

We also publish a provider status page that shows hourly health scores for each upstream over the last 24 hours, with 502/403/429 errors broken out. It also has a model consistency check: it compares the model name the upstream actually returns with the one you asked for, which helps answer the obvious question, "is this gateway quietly swapping in a cheaper model?" The scoring formula is on the page. Treat it as a snapshot of recent behavior, not an uptime promise.

Bring your own key (BYOK)

If you already have provider keys (say, a company OpenAI account), you can attach them and still get unified usage stats and spending limits. BYOK calls carry no platform fee. Check the site for the current BYOK rules.

Usage logs

Each request in the console's call log shows the model, input/output tokens, cache hits, latency and error details. When a teammate asks why the bill went up on Tuesday, you can find the answer there.

A desktop option: RouterCode

If you'd rather not touch config files, the RouterCode desktop client (Windows and macOS; check the site for current versions) runs a local gateway and can configure supported coding tools to use it. Those tools are independent products; RouterCode just points them at the gateway.

Trade-offs, honestly

• One more hop. A gateway adds a network hop. For typical chat and agent workloads it's small next to model latency, but measure it for your own workload.

• Feature parity varies. Provider-specific features (some tool-calling details, certain multimodal options) may not map 1:1 onto the OpenAI format. Test the features you depend on.

• You're trusting a middle layer with prompts and keys. Read the privacy policy and terms before sending sensitive data, whichever gateway you pick.

• Pricing varies by model. See the model pricing page; I'm not quoting numbers here because they change.

Wrap-up

The "one SDK, change base_url" pattern lets you compare models in an afternoon and switch providers without a rewrite. If you want to try it with APIGOTO, free signup credits are available at www.china-aiapi.com.

I'd like feedback, especially on routing behavior and on what the status page should show. Leave a comment and I'll reply.

APIGOTO is an independent service, not affiliated with Anthropic, OpenAI or Google. Model availability and pricing are as listed on the site at the time you read this.

When I prototype an AI tool, I now standardize the API layer before tuning the agent prompt.

What I check first

• one API entry point for the prototype;
• keys kept outside public posts and repositories;
• the model IDs currently available to my account;
• a minimal request and response-format smoke test;
• quota, usage and call records in one place;
• a clean separation between agent logic and provider details.

I use APIGOTO as the LLM API gateway in this workflow. The point is not to make an unverified promise about a fixed model count. If I see a message such as “200 models with free tokens”, I verify the live account or campaign page first: eligibility, limits, validity, rate limits and model availability can change.

Why this order helps

It separates debugging into three layers:

1. Agent layer — prompts, tools, memory and workflow.
2. API layer — endpoint, key, model ID and request format.
3. Operations layer — usage, quota, errors and fallback decisions.

That makes it much easier to tell whether a failure is in the agent or in the integration.

Start here: https://www.apigoto.com/

This is a personal developer workflow note, not an official statement from Codex, Claude, Hermes, OpenClaw or any model provider.