Ein API-Key. 124 Modelle. Drei Wire-Formate.

• POST /v1/chat/completions: OpenAI Chat Completions. Streaming per SSE mit data: [DONE] am Ende, stream_options.include_usage, Tool Calling. Das Format, das fast jeder OpenAI-kompatible Client spricht.
• POST /v1/responses: die OpenAI Responses API, das Format von Codex CLI. Streaming und Tools. Zustandslos: store ist false, previous_response_id wird mit 400 abgelehnt. Schick also in jedem Turn den vollständigen Input.
• POST /v1/messages: die Anthropic Messages API. Streaming und Tool Use. Damit reden Claude Code und die Anthropic-SDKs.
• POST /v1/messages/count_tokens: kostenlos. Eine lokale Schätzung ohne Modellaufruf, die nicht auf dein Rate-Limit pro Minute zählt. Claude Code ruft das ständig auf, um seinen Kontext zu bemessen.
• GET /v1/models: jedes Modell, das dein Key gerade aufrufen darf, mit Kontextlänge, Tool-Support und Preisen. Ein Response-Body, den die OpenAI- und die Anthropic-SDKs gleichermaßen parsen.

Authentifizierung geht auf zwei Arten, an jedem Endpoint. Authorization: Bearer sk-unb-... für OpenAI-Clients und für Claude Code mit ANTHROPIC_AUTH_TOKEN. x-api-key: sk-unb-... für die Anthropic-SDKs. Keys beginnen mit sk-unb-, werden genau einmal angezeigt und nur als Hash gespeichert. Du erstellst sie unter Einstellungen > API-Keys, bis zu 20 aktive Keys pro Konto.

curl

Der schnellste Beweis, dass dein Key funktioniert. Eine schlichte Chat Completion, nichts zu installieren.

curl https://unbottled.ai/api/de-GLOBAL/v1/chat/completions \
  -H "Authorization: Bearer sk-unb-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "kimi-k3.1-pro",
    "messages": [
      { "role": "system", "content": "You answer in one sentence." },
      { "role": "user", "content": "Why is the sky blue?" }
    ]
  }'

OpenAI Python SDK

Setz base_url und api_key am Client und ruf wie gewohnt chat.completions.create auf. Jedes Modell aus GET /v1/models passt ins model-Feld, Claude und Gemini eingeschlossen.

from openai import OpenAI

client = OpenAI(
    base_url="https://unbottled.ai/api/de-GLOBAL/v1",
    api_key="sk-unb-YOUR_KEY",
)

reply = client.chat.completions.create(
    model="kimi-k3.1-pro",
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
)
print(reply.choices[0].message.content)

Derselbe Client spricht auch die Responses API: client.responses.create. Denk daran, dass sie hier zustandslos ist. Übergib in jedem Turn die gesamte Unterhaltung als input.

reply = client.responses.create(
    model="kimi-k3.1-pro",
    input="Why is the sky blue?",
)
print(reply.output_text)

Anthropic Python SDK

Setz base_url ohne /v1 und deinen Key als api_key, dann messages.create. Reasoning-Modelle stellen einen thinking-Block an den Anfang. Das Beispiel gibt deshalb den text-Block aus, nicht den ersten Block.

import anthropic

client = anthropic.Anthropic(
    base_url="https://unbottled.ai/api/de-GLOBAL",
    api_key="sk-unb-YOUR_KEY",
)

reply = client.messages.create(
    model="kimi-k3.1-pro",
    max_tokens=1024,
    messages=[{"role": "user", "content": "Why is the sky blue?"}],
)
# Reasoning models put a thinking block first: print the text block.
print(next(block.text for block in reply.content if block.type == "text"))

Größe vor dem Senden prüfen? count_tokens liefert kostenlos eine Schätzung, ganz ohne Modellaufruf.

curl https://unbottled.ai/api/de-GLOBAL/v1/messages/count_tokens \
  -H "x-api-key: sk-unb-YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "claude-sonnet-4-5-20250929",
    "messages": [{ "role": "user", "content": "Why is the sky blue?" }]
  }'

Modelle auflisten

GET /v1/models ist die maßgebliche Quelle. Hier siehst du genau, welche IDs dein Key aufrufen darf, mit Kontextlänge, Tool-Support und Preis pro Token.

curl https://unbottled.ai/api/de-GLOBAL/v1/models \
  -H "Authorization: Bearer sk-unb-YOUR_KEY"

• Unsere IDs, so wie GET /v1/models sie listet: claude-sonnet-5.5, gpt-6.1-sol, glm-5.3. Nimm diese, wenn du neu anfängst.
• Anbieter-Schreibweisen gehen auch. Anthropic-IDs mit Datumsstempel (claude-sonnet-4-5-20250929 wird zu claude-sonnet-4.5), Versionsnummern mit Bindestrich, das Suffix -latest, das Kontext-Suffix [1m] und IDs mit Punkt wie gpt-5.5.
• Provider-Präfixe wie anthropic/... oder openai/..., damit IDs im OpenRouter-Stil aus einer bestehenden Config weiterlaufen.
• Nur auf /v1/messages: Eine Claude-ID, die dein Konto nicht aufrufen kann, etwa die eingebauten IDs, die Claude Code für seine Hintergrundaufrufe schickt, fällt auf das neueste Claude derselben Familie (Opus, Sonnet oder Haiku) zurück, das du aufrufen darfst. Claude Code läuft damit ohne zusätzliche Umgebungsvariablen. Jede andere unbekannte ID liefert 404 model_not_found.

Jedes Snippet nutzt standardmäßig glm-5.3. Es hat echte Läufe mit Claude Code und Codex CLI bestanden, ruft Tools zuverlässig auf und kostet pro Output-Token wenig. Läuft alles, tauschst du es gegen jede beliebige ID.

ANTHROPIC_BASE_URL="https://unbottled.ai/api/de-GLOBAL" \
ANTHROPIC_AUTH_TOKEN="sk-unb-YOUR_KEY" \
ANTHROPIC_MODEL="glm-5.3" \
ANTHROPIC_DEFAULT_OPUS_MODEL="glm-5.3" \
ANTHROPIC_DEFAULT_SONNET_MODEL="glm-5.3" \
ANTHROPIC_DEFAULT_HAIKU_MODEL="glm-5.3-flash" \
CLAUDE_CODE_SUBAGENT_MODEL="glm-5.3" \
CLAUDE_CODE_MAX_CONTEXT_TOKENS="1048576" \
CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC="1" \
claude

Das ist die ganze Antwort auf die Frage, wie Claude Code mit anderen Modellen läuft. ANTHROPIC_BASE_URL zeigt auf uns, ANTHROPIC_AUTH_TOKEN trägt deinen Key, die Modellvariablen entscheiden, was läuft. Ersetze die Modell-ID durch eine beliebige ID aus GET /v1/models: GPT, Gemini, Kimi, DeepSeek oder ein unzensiertes Modell. CLAUDE_CODE_MAX_CONTEXT_TOKENS steht auf dem echten Kontextfenster des Modells, damit Claude Code an der richtigen Stelle kompaktiert.

UNBOTTLED_API_KEY="sk-unb-YOUR_KEY" codex \
  -c 'model_providers.unbottled={name="unbottled.ai",base_url="https://unbottled.ai/api/de-GLOBAL/v1",env_key="UNBOTTLED_API_KEY",wire_api="responses"}' \
  -c model_provider=unbottled \
  -m glm-5.3

Codex CLI bekommt einen eigenen Model-Provider mit wire_api auf responses. Es spricht mit uns die Responses API, genau wie mit OpenAI. Das Modell wechselst du per -m.

OpenCode, Continue, Aider und Cline funktionieren ebenfalls, alle getestet. Ihre Setups, die dauerhaften Config-Dateien und die Stolperfallen, die wir gefunden haben, stehen im Coding-Tools-Guide.

Zwischen zwei Modellen hin- und hergerissen? Die Vergleichsseiten stellen sie direkt gegenüber.

• Die meisten Modelle rechnen zum gelisteten Token-Preis plus unserem Aufschlag ab. Gecachte Input-Tokens laufen zum Cache-Preis des Modells. Modelle über OpenRouter rechnen die echten Kosten ab, die OpenRouter für den Aufruf berechnet hat, plus denselben Aufschlag.
• Jede Antwort meldet usage.credits_charged. Was ein Aufruf gekostet hat, musst du nie raten.
• Bevor ein Aufruf startet, wird dein Guthaben gegen eine Worst-Case-Schätzung geprüft. Reicht es nicht, kommt HTTP 402 insufficient_credits: Nichts läuft, nichts wird berechnet.
• Beim Streaming gilt: Verbindung schließen stoppt die Generierung. Du zahlst nur, was gelaufen ist. Dasselbe gilt, wenn der Provider mitten im Stream ausfällt.
• Chat und API rechnen identisch ab. OpenRouter verteilt ein Modell auf mehrere Hoster, und manche sind teurer als der günstigste, den wir listen. Bei diesen Modellen ist der gelistete Preis deshalb eine Schätzung, usage.credits_charged der echte Betrag. Meldet OpenRouter für einen Aufruf keine Kosten, gilt der gelistete Preis.
• Dasselbe Credit-Guthaben wie in der Chat-App, das dort auch Bild, Video, Musik, Sprache und Websuche abdeckt. Die API selbst braucht ein bezahltes Konto: ein aktives Abo oder mindestens ein gekauftes Credit-Paket. Gratis-Credits schalten sie nicht frei.

• Abo: 800 Credits im Monat für $8.00.
• Credit-Paket: 500 Credits für $5.00. Pakete verfallen nie. Bezahlung per Karte oder Krypto.

Direkt bei OpenAI, Anthropic oder Google

Neue First-Party-Features landen dort zuerst. Kein Aufschlag durch einen Zwischenhändler. Nur die Bedingungen eines Anbieters. Nutzt du ausschließlich die Modelle eines Anbieters, geh direkt.

Ein Aggregator wie OpenRouter

Viele Modelle, Bezahlung nach Verbrauch. Offen gesagt: Viele unserer Modelle laufen über OpenRouter. Brauchst du nur reines Routing, bist du dort richtig.

unbottled.ai

Ein Key für drei Wire-Formate: Chat Completions, Responses und Anthropic Messages samt count_tokens. Claude Code und Codex CLI verbinden sich ohne Proxy. Unzensierte Modelle stehen neben den Mainstream-Modellen, hinter einer einmaligen Bestätigung ab 18. Dasselbe Guthaben zahlt Chat-App und API, aus Abo-Credits oder Paketen. Und unbottled.ai ist Open Source und selbst hostbar.

• Zustandslos. Die Responses API läuft mit store auf false und lehnt previous_response_id ab. Schick in jedem Turn den vollständigen Verlauf. Das gilt für jeden Endpoint.
• Der Output ist auf 32768 Tokens pro Request begrenzt.
• Standardmäßig 60 Requests pro Minute und Key. Darüber kommt 429 mit Retry-After-Header. Agents, die viele Aufrufe abfeuern, bekommen ihren eigenen Key.
• count_tokens ist eine Schätzung, nicht der exakte Tokenizer des Providers. Gut, um Kontext zu bemessen, nicht für Abrechnungsmathematik.
• Tool Calls funktionieren nur bei Modellen, die sie unterstützen. Sonst kommt 400 tools_not_supported. GET /v1/models zeigt supports_tools für jedes Modell.
• Unzensierte Modelle brauchen eine einmalige Bestätigung ab 18 auf der Seite API-Keys. Ohne sie kommt 403 uncensored_consent_required, und nichts wird berechnet.

• Die API speichert keine Unterhaltung und legt keine Threads an. Bei uns bleibt nur der Abrechnungsdatensatz: welches Modell, wie viele Credits.
• Dein Prompt geht an den Provider, der das Modell betreibt. Für das, was er empfängt, gelten seine Bedingungen.
• In der Chat-App liegen Inkognito-Chats nur im lokalen Speicher deines Browsers, nicht auf unseren Servern.