How to Access 200+ AI Models with a Single API Key

Step-by-step tutorial: get a Celedog API key, point the OpenAI SDK at celedog.io/v1, and call any of 200+ models with one parameter change. Includes Python / Node / curl examples and switching-between-models walkthrough.

You don't need a dozen SDKs, a dozen API keys, and a dozen billing accounts to use a dozen AI models. One OpenAI-compatible key and a single base-URL change unlock 200+ models across 20+ providers. This tutorial shows exactly how, with copy-paste examples in Python, Node and curl, and a walkthrough of switching between models on the fly.

The idea in one sentence

Because the OpenAI Chat Completions API has become the de-facto standard, a gateway that speaks it lets your existing OpenAI code reach any model by changing one string — the model parameter — instead of integrating each provider separately.

Step 1 — get a key

Create a Celedog account and generate an API key in the dashboard. It looks like sk-... and works as a Bearer token, exactly like an OpenAI key. New accounts get free signup credit, so you can run every example below at zero cost.

Step 2 — point the SDK at Celedog

You keep the official OpenAI SDK. Change only the base URL and key.

Python

from openai import OpenAI

client = OpenAI(
    base_url="https://celedog.io/v1",
    api_key="sk-...",
)

resp = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Explain AI gateways in one sentence."}],
)
print(resp.choices[0].message.content)

Node / TypeScript

import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://celedog.io/v1",
  apiKey: "sk-...",
});

const resp = await client.chat.completions.create({
  model: "claude-4.6-sonnet",
  messages: [{ role: "user", content: "Explain AI gateways in one sentence." }],
});
console.log(resp.choices[0].message.content);

curl

curl https://celedog.io/v1/chat/completions \
  -H "Authorization: Bearer sk-..." \
  -H "Content-Type: application/json" \
  -d '{
    "model": "deepseek-v4-flash",
    "messages": [{"role": "user", "content": "Explain AI gateways in one sentence."}]
  }'

Step 3 — switch models by changing one parameter

This is the whole payoff. The same request body reaches a completely different provider by changing only model:

Task	`model` value	Provider
General chat	`gpt-4o`	OpenAI
Agentic coding	`claude-4.6-sonnet`	Anthropic
Long-context multimodal	`gemini-2.5-pro`	Google
High-volume cheap	`deepseek-v4-flash`	DeepSeek
Let the gateway choose	`celedog/auto-cheapest`	Auto-routed

No new SDK, no new auth, no new billing account — just a different string.

Step 4 — a practical multi-model pattern

A common real-world setup uses a cheap model for the bulk of requests and escalates to a stronger one only when needed:

def answer(question, hard=False):
    model = "claude-4.6-sonnet" if hard else "deepseek-v4-flash"
    resp = client.chat.completions.create(
        model=model,
        messages=[{"role": "user", "content": question}],
    )
    return resp.choices[0].message.content

Because every model shares one client, one key and one wallet, routing logic like this is trivial — no per-provider plumbing.

Streaming, tools and the rest

Everything else in the OpenAI SDK works as you expect: set stream=True for token streaming, pass tools for function calling, and use the same response_format for JSON mode. The gateway normalises these across providers so your code stays uniform even when the underlying model is from Anthropic or Google.

One wallet, one bill

Every call above draws from a single Celedog wallet at the model's published per-token rate, displayed in your currency (USD / CNY / IDR). Instead of reconciling invoices from OpenAI, Anthropic, Google and DeepSeek, you get one statement and per-request logs showing exactly which model cost what.

The fastest way to add a model to your product in 2026 is to change a string. That is the entire promise of a single-API gateway.