OpenAI-API für Entwickler: Kompatiblen Endpunkt nutzen

Die Kurzversion

Die meisten Anleitungen zur openai api für Entwickler gehen von einem Anbieter und einer Rechnung aus. Das Übertragungsformat ist jedoch einfach JSON über HTTPS, und viele Client-Code, Frameworks und Tools können mit jedem Server kommunizieren, der es implementiert. Diese Website hostet einen solchen Server. Du behältst dein SDK, änderst die Basis-URL, tauschst einen Schlüssel von dieser Website ein und stellst das Modell auf uncensored.

Das ist die gesamte Migration für eine typische App. Hier ist die Checkliste, und der Rest der Seite füllt jeden Schritt aus.

1. Erstelle ein Konto und beanspruche das Testguthaben auf der API-Schlüssel-Seite.
2. Setze die Base URL auf https://api.openaigatewayapi.com/v1.
3. Sende den Schlüssel als Authorization: Bearer <key>. Die SDKs machen dies für dich, wenn du api_key übergibst.
4. Verwende uncensored als Modell-ID in jeder Anfrage.
5. Behandle HTTP 429 mit einer kurzen Wiederholung, wie am Ende gezeigt.

Es gibt zwei Endpunkte: POST /v1/chat/completions und GET /v1/models. Der Dienst ist nur Text. Es gibt keine Bild- oder Audioerzeugung, keine Embeddings und kein Feintuning, also wenn deine App diese aufruft, benötigen sie einen anderen Anbieter.

Überprüfe die Verbindung mit curl

Bevor du deine Anwendung berührst, bestätige, dass der Schlüssel funktioniert. Der Endpunkt für Modelle ist der günstigste Test, da er keine Token generiert.

Copyexport API_KEY="paste-your-key-here"

curl https://api.openaigatewayapi.com/v1/models \
  -H "Authorization: Bearer $API_KEY" | grep -o uncensored

Der grep druckt die Modell-ID uncensored, wenn die Liste sie enthält; entferne den grep, um die vollständige JSON-Liste zu sehen. Wenn du eine 401 erhältst, ist der Schlüssel falsch oder fehlt das Bearer-Präfix. Sende jetzt eine echte Anfrage:

Copycurl https://api.openaigatewayapi.com/v1/chat/completions \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "model": "uncensored",
    "messages": [
      {"role": "system", "content": "You are a concise technical assistant."},
      {"role": "user", "content": "Explain idempotency keys in two sentences."}
    ],
    "temperature": 0.4
  }'

Die Antwort enthält die üblichen choices- und usage-Objekte. Sie enthält außerdem Header, die du protokollieren solltest: X-Request-Id für Support-Anfragen, X-Balance-USD für dein verbleibendes Guthaben und die beiden X-RateLimit-Limit-*-Header, die deine Anfrage- und Parallelitätslimits anzeigen.

Python mit dem offiziellen openai-Paket

In Python berührst du nur den Client-Konstruktor. Alles danach ist der Code, den du bereits hast.

Copyfrom openai import OpenAI

client = OpenAI(
    base_url="https://api.openaigatewayapi.com/v1",
    api_key="paste-your-key-here",
)

resp = client.chat.completions.create(
    model="uncensored",
    messages=[
        {"role": "system", "content": "You write short, accurate release notes."},
        {"role": "user", "content": "Summarise: added retry logic, fixed timeout bug."},
    ],
    temperature=0.5,
    max_tokens=200,
)

print(resp.choices[0].message.content)
print(resp.usage.prompt_tokens, resp.usage.completion_tokens)

Lese den Schlüssel in echtem Code aus einer Umgebungsvariable. Das Beispiel hartkodiert ihn nur, um den Ausschnitt kurz zu halten. max_tokens ist hier optional; wenn du ihn weglässt, kann die Vervollständigung den Rest des 100.000-Token-Fensters nutzen (Prompt plus Vervollständigung zusammen). Das Setzen ist eine günstige Möglichkeit, die Kosten bei einer unkontrollierten Generierung zu begrenzen.

Streaming

Streaming nutzt Server-Sent Events und denselben stream=True-Flag, den du kennst. Nutzungszahlen kommen am Ende des Streams, sodass der letzte Block eine leere choices-Liste haben kann.

Copyfrom openai import OpenAI

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

stream = client.chat.completions.create(
    model="uncensored",
    messages=[{"role": "user", "content": "List five edge cases for a date parser."}],
    stream=True,
)

for chunk in stream:
    if chunk.choices and chunk.choices[0].delta.content:
        print(chunk.choices[0].delta.content, end="", flush=True)
    if getattr(chunk, "usage", None):
        print("\ntokens:", chunk.usage.total_tokens)

Ein Detail ist wichtig für die Kapazitätsplanung. Eine gestreamte Anfrage hält ihren Parallelitätsplatz bis zum Stream-Ende, nicht bis zum ersten Token. Wenn ein Client einen Stream ohne Schließung verlässt, bleibt dieser Platz länger belegt, als du erwartest.

Node.js-Beispiel

Das Node-SDK benötigt dieselben zwei Einstellungen unter anderen Namen.

Copyimport OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://api.openaigatewayapi.com/v1",
  apiKey: process.env.GATEWAY_KEY,
});

const completion = await client.chat.completions.create({
  model: "uncensored",
  messages: [
    { role: "user", content: "Write a regex that matches ISO 8601 dates, and explain it." },
  ],
  temperature: 0.3,
});

console.log(completion.choices[0].message.content);

Wenn du ein Framework mit eigener OpenAI-Integration verwendest, suche nach einem Feld namens Base URL, API base oder Endpunkt in seinen Einstellungen. Das Einfügen derselben URL dort ist normalerweise alles, was nötig ist. Chat-Frontends, Agent-Frameworks und Editor-Plugins folgen meist diesem Muster. Sampling-Parameter wie temperature, top_p, stop, seed und die Häufigkeits- und Vorhandenseinsstrafen werden an das Modell weitergegeben.

Tool Calling und JSON-Modus

Zwei Funktionen entscheiden, ob ein Modell in eine echte Anwendung passt: das Aufrufen deiner Funktionen und das Zurückgeben von Daten, die du parsen kannst. Beide werden unterstützt.

Function Calling

Du deklarierst Tools mit tools, erzwingst optional eine Auswahl mit tool_choice und sendest Ergebnisse als Nachrichten mit role: "tool". Gestreamte Antworten liefern tool_calls stückweise, wie im Standardformat.

Copyimport json
from openai import OpenAI

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the status of an order by its ID.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is order A-1042?"}]
first = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
msg = first.choices[0].message

if msg.tool_calls:
    call = msg.tool_calls[0]
    args = json.loads(call.function.arguments)
    result = {"order_id": args["order_id"], "status": "shipped"}  # your real lookup here
    messages.append(msg)
    messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    final = client.chat.completions.create(model="uncensored", messages=messages, tools=tools)
    print(final.choices[0].message.content)

Validiere immer die Argumente, bevor du darauf reagierst. Das Modell erzeugt JSON, das in den meisten Fällen deinem Schema entspricht, aber nicht immer, also behandle call.function.arguments wie jeden anderen nicht vertrauenswürdigen Input.

JSON-Modus

Fordere für Extraktions- und Klassifizierungsaufgaben ein JSON-Objekt an und erwähne dies auch im Prompt. Die Erwähnung von JSON in den Anweisungen liefert bessere Ergebnisse als sich nur auf den Flag zu verlassen.

Copyfrom openai import OpenAI
import json

client = OpenAI(base_url="https://api.openaigatewayapi.com/v1", api_key="paste-your-key-here")

resp = client.chat.completions.create(
    model="uncensored",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Reply with JSON only: {\"sentiment\": string, \"topics\": [string]}."},
        {"role": "user", "content": "The docs are clear but the rate limits caught me off guard."},
    ],
)
data = json.loads(resp.choices[0].message.content)
print(data)

Limits, Fehler und Wiederholungen

Ein vollständiger Schlüssel erlaubt 8 parallele Anfragen und 300 Anfragen pro Minute. Der Test-Schlüssel erlaubt 2 parallele und 60 pro Minute. Der maximale Anforderungstext ist 8 MB. Überschreitest du ein Limit, erhältst du HTTP 429, und der Fehlercode sagt dir, welches Limit es war.

Fehlercode	Bedeutung	Was tun
rate_limited	Zu viele Anfragen pro Minute	Verlangsame den Produzenten oder verteile die Arbeit über die Minute
concurrency	Zu viele Anfragen gleichzeitig	Senke deine Worker-Anzahl auf 8 oder weniger, oder 2 auf einem Test-Schlüssel
429 mit Retry-After: 5	Vorübergehende Überlastung	Warte die angegebenen Sekunden und versuche es erneut

Die SDKs führen bereits einige Retries bei Fehlern durch. Füge deine eigene Behandlung für 429 hinzu, damit ein Burst keinen Batch-Job abstürzen lässt:

Copyimport time
from openai import OpenAI, RateLimitError

client = OpenAI(
    base_url="https://api.openaigatewayapi.com/v1",
    api_key="paste-your-key-here",
    max_retries=0,
)

def ask(prompt, attempts=5):
    for i in range(attempts):
        try:
            r = client.chat.completions.create(
                model="uncensored",
                messages=[{"role": "user", "content": prompt}],
            )
            return r.choices[0].message.content
        except RateLimitError as e:
            wait = float(e.response.headers.get("retry-after", 2 ** i))
            time.sleep(wait)
    raise RuntimeError("still rate limited after retries")

Fehlgeschlagene oder abgelehnte Anfragen werden nicht berechnet, also verdoppelt eine Retry-Schleife deine Rechnung nicht. Ein Semaphore, das auf dein Parallelitätslimit skaliert ist, ist der sauberste Weg, in Async-Code unter der Grenze zu bleiben.

Eine bestehende App umziehen

Wenn du eine funktionierende App hast, hartkodiere die neuen Werte nicht. Setze die Basis-URL, den Schlüssel und den Modellnamen in Umgebungsvariablen, damit du zwischen Umgebungen wechseln kannst, ohne neu bereitzustellen. Das erlaubt dir auch, die gleiche Testsuite gegen zwei Backends zu laufen und die Ausgabe nebeneinander zu vergleichen.

Copyimport os
from openai import OpenAI

client = OpenAI(
    base_url=os.environ.get("LLM_BASE_URL", "https://api.openaigatewayapi.com/v1"),
    api_key=os.environ["LLM_API_KEY"],
)
MODEL = os.environ.get("LLM_MODEL", "uncensored")

def complete(messages, **kw):
    return client.chat.completions.create(model=MODEL, messages=messages, **kw)

Bearbeite dann eine kurze Migrationsroutine:

1. Führe deine bestehenden Prompts gegen den neuen Endpunkt aus und lies die Ausgaben selbst. Automatisierte Prüfungen erkennen Formatbrüche, nicht den Ton.
2. Stelle sicher, dass jeder Code, der JSON parst, auch mit gesetztem response_format funktioniert, und behalte einen Fallback, der zusätzlichen Text um das Objekt herum entfernt.
3. Miss die tatsächlichen Token-Anzahlen aus usage, weil ein anderes Modell Text anders tokenisiert und deine alten Schätzungen abweichen können.
4. Stelle deinen Worker-Pool auf 8 oder weniger ein, damit die Parallelitäts-Obergrenze unter Last nicht als Erstes versagt.
5. Stelle einen kleinen Anteil an Traffic bereit, beobachte die 429-Rate und die Fehler-Logs, und weite dann aus.

Teams vergessen oft den System-Prompt in diesem Prozess. Prompts, die geschrieben wurden, um ein ablehnungsanfälliges Modell zum Verhalten zu bewegen, enthalten oft Vorsichtsformeln, die hier unnötig sind und die Ausgabe verschmutzen können. Lies deine Prompts noch einmal durch und entferne das, was nichts mehr tut.

Was du vor dem Wechsel wissen solltest

Kompatibilität umfasst das Anfrage- und Antwortformat. Sie macht dies nicht zur offiziellen API eines Herstellers. Der Dienst betreibt ein Open-Weight-Modell, gehostet von einem unabhängigen Anbieter und optimiert, um ohne Inhaltsablehnungen für die rechtmäßige Erwachsenennutzung zu antworten. Es ist kein Router über Anbieter hinweg, also findest du dahinter keine Auswahl anderer Modelle. Sexuelle Inhalte mit Minderjährigen sind nicht erlaubt, und dieses Limit kann nicht geändert werden.

Plane unter Berücksichtigung von drei praktischen Unterschieden zu einer großen Multi-Modell-Plattform:

• Ein Modell. Die ID ist uncensored. Wenn dein Code Modelle nach Aufgabe wechselt, fasse das auf einen Wert zusammen.
• Nur Text. Entferne alle Bild-, Audio- oder Embedding-Aufrufe aus dem Pfad, der zu diesem Endpunkt führt.
• Prompt-Verhalten weicht ab. Ein anderes Modell liest Anweisungen anders, also führe deine Prompts und Tests nach dem Wechsel erneut aus. Schärf die System-Prompts, wo die Ausgabe abweicht.

Prompts werden nicht für das Training verwendet. Für die vollständige Parameterliste sieh dir die API-Dokumentation an. Wenn du Ausgaben schätzt, listet die Preisseite die Token-Raten auf: 0,15 $ pro 1M Input-Token und 0,50 $ pro 1M Output-Token, abgerechnet vom Prepaid-Guthaben ohne Abonnement. Aufladungen laufen von 20 $ bis 500 $ und Guthaben verfällt nie. Wenn du eine Proxy-Schicht vor mehreren Diensten abwägst, behandelt die Seite auf LLM-Gateways, wann dieser zusätzliche bewegliche Teil sich auszahlt.

Weitere Anleitungen

• OpenAI-Gateway-API in einfachen Worten erklärt
• OpenAI-Gateway-API-Preise: Echte Kostenbeispiele
• LLM-Gateway: Kosten vs. Komplexitätsanalyse