---
title: "Von der OpenAI API migrieren: Code-Diffs und Tests | BroadRouter"
description: "Die Code-Änderungen für den Wechsel von OpenAI zu einer OpenAI-kompatiblen API: Client, Responses zu Chat Completions, Tools, Streaming, Embeddings, Smoke-Test."
url: https://broadrouter.com/de/blog/migrate-from-openai-api-code-walkthrough/
lang: de
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

Mit KI-Unterstützung aus dem Englischen übersetzt. [Englisches Original lesen](https://broadrouter.com/blog/migrate-from-openai-api-code-walkthrough/) (aktualisiert am 2026-11-15).

# Weg von der OpenAI API: Migration mit Code in Python, Node, cURL

Vom Team von BroadNet Inference · 6 Min. Lesezeit · Veröffentlicht 2026-11-15

Ändern Sie Basis-URL, API-Schlüssel und Modell-ID des Clients. Für Aufrufe von Chat Completions reicht das. Code für die Responses API müssen Sie auf Chat Completions umschreiben: input wird zu messages, output\_text zu choices\[0\].message.content, und Tools verlieren eine Verschachtelungsebene. Behalten Sie Embeddings auf einem eigenen Client, falls der neue Anbieter keine hat, und führen Sie vor dem Umleiten des Traffics einen Smoke-Test durch.

## Das Wichtigste in Kürze

-   Für Code mit Chat Completions besteht der Wechsel aus drei Werten: base\_url, api\_key und model. Beide offiziellen SDKs lesen außerdem OPENAI\_BASE\_URL und OPENAI\_API\_KEY aus der Umgebung.
-   Wenn Sie OPENAI\_BASE\_URL setzen, wandert jeder Aufruf mit, auch Embeddings. Hat der neue Anbieter keinen Embeddings-Endpoint, geben Sie den Embeddings einen eigenen Client.
-   Code für die Responses API muss umgeschrieben werden: input zu messages, instructions zu einer System-Nachricht, text.format zu response\_format und flache Tool-Definitionen zu verschachtelten.
-   BroadNet Inference dokumentiert /v1/chat/completions, /v1/audio/transcriptions und GET /v1/models, aber keinen Endpoint für Embeddings, Dateien oder Batches. Die Dokumentation listet Tools und strukturierte Ausgabe für GLM 5.3 und Qwen3.8 27B.
-   Testen Sie vor dem Wechsel: einfacher Chat, Nutzungsdaten beim Streaming, ein Reasoning-Budget und ein ungültiger Schlüssel, dazu ein Tool-Aufruf, wenn Sie Tools nutzen.

**Auf dieser Seite**

1.  Was ändert sich an der Einrichtung des Clients?
2.  Was, wenn mein Code die Responses API nutzt?
3.  Wie ändern sich Tool-Aufrufe?
4.  Was ist mit strukturierter Ausgabe?
5.  Was passiert mit Embeddings?
6.  Wie ändert sich Streaming-Code?
7.  Ändern sich Fehlerbehandlung und Retries?
8.  Welche Parameter verhalten sich anders?
9.  Wie testen Sie den Wechsel?
10.  Was bricht am häufigsten?
11.  Wo BroadNet Inference hineinpasst

Eine App von OpenAI zu einem OpenAI-kompatiblen Anbieter umzuziehen ist eine kleine Code-Änderung, wenn Sie Chat Completions nutzen, und ein Umschreiben, wenn Sie die Responses API nutzen. Dieser Beitrag zeigt die exakten Diffs in Python, Node und cURL, was mit Responses, Tools, strukturierter Ausgabe und Embeddings zu tun ist, und einen Smoke-Test, den Sie ausführen, bevor Sie Traffic umleiten. Die Beispiele nutzen BroadNet Inference unter `https://inference.broadnet.ai/v1`; dieselben Schritte gelten für jeden Anbieter.

Dies ist das Code-Gegenstück zur [Checkliste für die Migration](https://broadrouter.com/de/blog/openai-compatible-api-migration-checklist/), die Rate Limits, Fehler und die Planung der Umstellung behandelt. Die Basis-URLs anderer Anbieter finden Sie unter [OpenAI-kompatible Basis-URLs, geprüft](https://broadrouter.com/de/blog/openai-compatible-api-base-urls/).

## Was ändert sich an der Einrichtung des Clients?

Drei Werte: Basis-URL, API-Schlüssel und Modell-ID.

**Python**

```python
import os
from openai import OpenAI

# before: client = OpenAI()  # reads OPENAI_API_KEY, calls api.openai.com
client = OpenAI(
    base_url="https://inference.broadnet.ai/v1",
    api_key=os.environ["BROADNET_API_KEY"],
)
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",          # was e.g. "gpt-..."
    messages=[{"role": "user", "content": "Reply with one short sentence."}],
)
print(r.choices[0].message.content)
```

**Node**

```javascript
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "https://inference.broadnet.ai/v1",
  apiKey: process.env.BROADNET_API_KEY,
});
const r = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Reply with one short sentence." }],
});
console.log(r.choices[0].message.content);
```

**cURL**

```bash
curl https://inference.broadnet.ai/v1/chat/completions \
  -H "Authorization: Bearer $BROADNET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"broadnet/gemma-4-26b-a4b","messages":[{"role":"user","content":"Reply with one short sentence."}]}'
```

Achten Sie auf den Pfad: Die Basis-URL endet bereits auf `/v1`, das SDK hängt `/chat/completions` an. Ein doppeltes `/v1` ist der häufigste erste Fehler.

### Kann ich wechseln, ohne den Code anzufassen?

Ja, bei Code mit Chat Completions. Das Python SDK liest `OPENAI_BASE_URL`, wenn keine `base_url` übergeben wird, und der Node-Client setzt `baseURL` standardmäßig auf `process.env['OPENAI_BASE_URL']`. Beide lesen `OPENAI_API_KEY`. Zwei Umgebungsvariablen zu setzen verschiebt jeden Aufruf.

Genau das ist auch das Risiko. **Jeder Aufruf** wandert mit, auch Embeddings, Moderation, Datei-Uploads und alles andere, was der neue Anbieter womöglich nicht hat. Nutzen Sie den Wechsel über die Umgebung nur, wenn Ihre App ausschließlich Chat-Aufrufe macht.

## Was, wenn mein Code die Responses API nutzt?

Die READMEs der SDKs von OpenAI nennen die Responses API inzwischen die primäre API; das Python-README bezeichnet Chat Completions als „the previous standard (supported indefinitely)“ (Übersetzung: „den bisherigen Standard (unbefristet unterstützt)“). Viele kompatible Anbieter implementieren nur Chat Completions. BroadNet dokumentiert `POST /v1/chat/completions` und `POST /v1/audio/transcriptions`; Aufrufe der Responses API müssen also umgeschrieben werden. Die Zuordnung:

| Responses API | Chat Completions |
| --- | --- |
| `client.responses.create(...)` | `client.chat.completions.create(...)` |
| `instructions="..."` | Erste Nachricht `{"role": "system", "content": "..."}` |
| `input="..."` oder eine Liste von Items | `messages=[...]` |
| `response.output_text` | `response.choices[0].message.content` |
| `max_output_tokens` | `max_tokens` (Dokumentation von BroadNet) oder `max_completion_tokens` |
| `text={"format": {...}}` | `response_format={...}` |
| `previous_response_id`, Konversationen | Den vollständigen Nachrichtenverlauf selbst erneut senden |
| Tool `{"type": "function", "name": ...}` | Tool `{"type": "function", "function": {"name": ...}}` |
| Output-Item `function_call`, Antwort mit `function_call_output` und `call_id` | `message.tool_calls`, Antwort mit Rolle `tool` und `tool_call_id` |
| Eingebaute Tools (Websuche, Dateisuche) | Nicht verfügbar; betreiben Sie Ihr eigenes Tool |

Vorher und nachher für einen einfachen Aufruf:

```python
# Before: Responses API
r = client.responses.create(model="gpt-...", instructions="Be brief.", input="What is RAG?")
text = r.output_text

# After: Chat Completions
r = client.chat.completions.create(
    model="broadnet/gemma-4-26b-a4b",
    messages=[{"role": "system", "content": "Be brief."},
              {"role": "user", "content": "What is RAG?"}],
)
text = r.choices[0].message.content
```

Die größte strukturelle Änderung ist der Zustand. Responses kann den Gesprächszustand mit `previous_response_id` bei OpenAI halten. Chat Completions hat keinen serverseitigen Zustand; Ihr Code speichert also die Nachrichtenliste und sendet sie in jeder Runde vollständig. Planen Sie das ein: Der gesamte Verlauf zählt bei jedem Aufruf als Input-Tokens.

## Wie ändern sich Tool-Aufrufe?

Bei Chat Completions verschachtelt eine Tool-Definition die Funktion unter einem Schlüssel `function`, und die Antwort geht als `tool`\-Nachricht zurück:

```python
import json

tools = [{
    "type": "function",
    "function": {
        "name": "get_order",
        "description": "Look up an order by ID.",
        "parameters": {"type": "object",
                       "properties": {"order_id": {"type": "string"}},
                       "required": ["order_id"]},
    },
}]
messages = [{"role": "user", "content": "Where is order A-1042?"}]
r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
msg = r.choices[0].message
if msg.tool_calls:
    messages.append(msg)                                   # keep the assistant turn
    for call in msg.tool_calls:
        args = json.loads(call.function.arguments)         # a JSON string: parse and validate it
        messages.append({"role": "tool", "tool_call_id": call.id,
                         "content": json.dumps(lookup_order(args["order_id"]))})
    r = client.chat.completions.create(model="broadnet/glm-5.3", messages=messages, tools=tools)
```

Das Modell ist wichtiger als das Format. Die Dokumentation von BroadNet listet Tools nur für [GLM 5.3](https://broadrouter.com/de/models/glm-5.3/) und [Qwen3.8 27B](https://broadrouter.com/de/models/qwen3.8-27b/). Richten Sie keine Tool-Schleife auf ein Modell, dessen Dokumentation keine Tools nennt, und validieren Sie die Argumente, bevor Sie etwas ausführen. [Tool Calling mit offenen Modellen](https://broadrouter.com/de/blog/tool-calling-open-models/) enthält eine vollständige validierende Schleife.

## Was ist mit strukturierter Ausgabe?

`client.chat.completions.parse(..., response_format=MyPydanticModel)` und `zodResponseFormat` in Node senden beide `response_format` mit einem JSON Schema. Sie funktionieren nur, wenn der Anbieter dieses Format für dieses Modell akzeptiert. BroadNet listet strukturierte Ausgabe für GLM 5.3 und Qwen3.8 27B, nennt aber den Anfrageparameter nicht. Führen Sie den Test in vier Schritten aus [JSON Mode vs. json\_schema](https://broadrouter.com/de/blog/structured-output-json-schema/) einmal pro Modell durch, und validieren Sie das geparste Ergebnis weiterhin, egal was der Anbieter verspricht.

## Was passiert mit Embeddings?

Ändern Sie die Basis-URL an einem gemeinsam genutzten Client und hat der Anbieter keinen Embeddings-Endpoint, scheitert jeder Aufruf von `client.embeddings.create`. BroadNet verkauft keine [Embeddings](https://broadrouter.com/de/glossary/embeddings/). Behalten Sie zwei Clients:

```python
chat = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
embed = OpenAI(api_key=os.environ["OPENAI_API_KEY"])   # or any embeddings provider

vec = embed.embeddings.create(model="text-embedding-3-small", input=query).data[0].embedding
answer = chat.chat.completions.create(model="broadnet/glm-5.3", messages=build_prompt(query, search(vec)))
```

Mischen Sie nie Vektoren zweier Embedding-Modelle in einem Index. Wechseln Sie auch den Embeddings-Anbieter, erzeugen Sie die Embeddings für den gesamten Korpus neu. Der [Kostenrechner für Embeddings](https://broadrouter.com/tools/embedding-cost-calculator/) berechnet, was das kostet.

Dasselbe gilt für alles andere, was nicht Chat ist: Bildgenerierung, Text-to-Speech, Moderation, die Batch API und Dateispeicher. BroadNet bietet nichts davon an. Speech-to-Text zieht dagegen mit um: `client.audio.transcriptions.create` funktioniert mit `/v1/audio/transcriptions`, mit WAV oder MP3 und einem Feld `language` ([Leitfaden zu Speech-to-Text für Arabisch](https://broadrouter.com/de/guides/arabic-speech-to-text-api/)).

## Wie ändert sich Streaming-Code?

Die Responses API streamt typisierte Events wie `response.output_text.delta` und `response.completed`. Chat Completions streamt Chunks, und der Text steht in `choices[0].delta.content`. Nutzungsdaten werden nur gesendet, wenn Sie sie anfordern, und kommen dann in einem letzten Chunk mit leerer `choices`\-Liste.

```javascript
// Before (Responses): for await (const e of stream) if (e.type === "response.output_text.delta") out(e.delta);
const stream = await client.chat.completions.create({
  model: "broadnet/gemma-4-26b-a4b",
  messages: [{ role: "user", content: "Count from one to three." }],
  stream: true,
  stream_options: { include_usage: true },
});
for await (const chunk of stream) {
  const text = chunk.choices[0]?.delta?.content;
  if (text) process.stdout.write(text);
  if (chunk.usage) console.log("\ntokens:", chunk.usage.total_tokens);   // last chunk
}
```

Zwei Gewohnheiten halten Streaming-Code nach dem Wechsel sicher. Sichern Sie `choices[0]` ab, denn der Chunk mit den Nutzungsdaten hat keine Choices. Und behandeln Sie einen Stream, der vor der letzten Zeile `data: [DONE]` endet, als unvollständig; laut der Dokumentation von BroadNet sollten Sie dann die `X-Request-ID` festhalten und entscheiden, ob eine neue Anfrage unbedenklich ist. [Chat Completions streamen](https://broadrouter.com/de/guides/streaming-chat-completions/) zeigt das vollständige Muster in Python.

## Ändern sich Fehlerbehandlung und Retries?

Die Fehlerklassen des SDK bleiben gleich: `AuthenticationError` für 401, `RateLimitError` für 429, `APIStatusError` für den Rest. Was sich ändert, ist, was jeder Status beim neuen Anbieter bedeutet. Bei BroadNet kann ein 401 ein aufgebrauchtes Pay-as-you-go-Kontingent bedeuten, nicht nur einen falschen Schlüssel, und 402 bedeutet unzureichendes Guthaben für einen Kauf. Keiner von beiden löst sich durch einen Retry. Ein 429 kann vom Rate-, Parallelitäts-, Token-Rate- oder Ausgabenlimit stammen. Wiederholen Sie 429 und 5xx mit Backoff, und beheben Sie alles andere. Der [Leitfaden zu Fehlern und Retries](https://broadrouter.com/de/guides/errors-and-retries/) enthält die vollständige Tabelle.

Das SDK wiederholt Verbindungsfehler, 408, 409, 429 und 5xx standardmäßig zweimal. Wenn Sie eine eigene Retry-Schleife ergänzen, setzen Sie `max_retries=0` am Client, damit sich beide nicht addieren.

## Welche Parameter verhalten sich anders?

| Parameter | Was Sie prüfen sollten |
| --- | --- |
| `max_tokens` / `max_completion_tokens` | OpenAI kündigt `max_tokens` ab; die Dokumentation von BroadNet nutzt es. Bei Reasoning-Modellen schließt es das Denken ein, kleine Werte liefern also leere Antworten ([warum](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/)) |
| `reasoning_effort` | BroadNet dokumentiert `low`; testen Sie andere Werte, bevor Sie sich darauf verlassen |
| `stream_options: {"include_usage": true}` | Von BroadNet dokumentiert; Nutzungsdaten kommen im letzten Chunk |
| `n`, `logprobs`, `seed`, `logit_bias` | Nicht in der Dokumentation von BroadNet; testen oder entfernen |
| `store`, `metadata` | Speicher-Features von OpenAI; entfernen |
| Inhaltsteile `image_url` | Nur bei Modellen, die mit Bildern gelistet sind: DeepSeek V4.1 Flash, Qwen3.8 27B, Gemma 4 VL 26B |

## Wie testen Sie den Wechsel?

Führen Sie einen kurzen Smoke-Test gegen den neuen Anbieter durch, bevor Traffic umzieht. Dieser prüft einfachen Chat, Nutzungsdaten beim Streaming, das Reasoning-Budget und die Authentifizierung. Ergänzen Sie einen Fall mit Tool-Aufruf, wenn Sie Tools nutzen.

```python
import os, openai
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"], max_retries=0)
FAST, REASONING = "broadnet/gemma-4-26b-a4b", "broadnet/qwen3.8-27b"
msg = [{"role": "user", "content": "Reply with the word ok."}]

# 1. Plain chat returns text and usage
r = client.chat.completions.create(model=FAST, messages=msg)
assert r.choices[0].message.content and r.usage.prompt_tokens > 0

# 2. Streaming reports usage in the last chunk
chunks = list(client.chat.completions.create(model=FAST, messages=msg, stream=True,
                                             stream_options={"include_usage": True}))
assert chunks[-1].usage is not None

# 3. A reasoning model needs room: a tiny budget can come back empty
r = client.chat.completions.create(model=REASONING, messages=msg, max_tokens=2000)
assert r.choices[0].finish_reason == "stop" and r.choices[0].message.content

# 4. A bad key raises AuthenticationError (401), which you should not retry
bad = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key="invalid", max_retries=0)
try:
    bad.chat.completions.create(model=FAST, messages=msg)
    raise AssertionError("expected 401")
except openai.AuthenticationError:
    pass
print("smoke test passed")
```

Vergleichen Sie danach die Qualität, nicht nur das Format. Spielen Sie eine Stichprobe echter Prompts bei beiden Anbietern ab und bewerten Sie die Antworten; [ein LLM vor dem Wechsel evaluieren](https://broadrouter.com/de/blog/evaluate-llm-before-switching/) zeigt, wie. Das [Migrationstool von OpenAI zu BroadNet](https://broadrouter.com/tools/openai-to-broadnet-migration/) hilft Ihnen, ein Snippet umzuschreiben, und listet, welche Features es nutzt.

## Was bricht am häufigsten?

-   **Eine globale Basis-URL**, die auch Embeddings- und Datei-Aufrufe verschiebt.
-   **Helfer nur für Responses** wie `output_text`, die im Code stehen bleiben, der jetzt Chat Completions aufruft.
-   **Modell-IDs.** Namen nach dem Muster `gpt-...` gibt es anderswo nicht. Bei BroadNet sehen sie aus wie `broadnet/glm-5.3`.
-   **Leere Antworten** von Reasoning-Modellen bei kleinem `max_tokens`.
-   **Rate Limits.** Ein Pay-as-you-go-Schlüssel von BroadNet erlaubt 30 Anfragen pro Minute und 4 gleichzeitig. Massenjobs brauchen eine Warteschlange ([429-Fehler behandeln](https://broadrouter.com/de/blog/handle-llm-api-429-rate-limits/)).

## Wo BroadNet Inference hineinpasst

BroadNet Inference passt zu Apps, deren Nutzung von OpenAI aus Chat und Transkription besteht: Assistenten, Extraktion, Zusammenfassung, Übersetzung und arabische Sprache. Es passt auch zu Apps, die für Agenten Flatrate-Pläne für [DeepSeek V4.1 Flash](https://broadrouter.com/de/models/deepseek-v4.1-flash/) wollen. Es ist das falsche Ziel, wenn Sie auf den serverseitigen Zustand der Responses API, eingebaute Tools, Embeddings, Bildgenerierung, Text-to-Speech, Echtzeit-Sprache oder die Batch API angewiesen sind. Verlegen Sie diese zu Anbietern, die sie anbieten, oder lassen Sie sie bei OpenAI und verschieben Sie nur die Chat-Aufrufe. Gemma 4 VL 26B und beide Transkriptionsmodelle laufen mit dem Startguthaben von $5; GLM 5.3, Qwen3.8 27B und DeepSeek V4.1 Flash erfordern zuerst eine Aufladung.

Kostenlose Tools zum Thema (auf Englisch)

-   [OpenAI to BroadNet migration helper](https://broadrouter.com/tools/openai-to-broadnet-migration/) Paste OpenAI SDK code; get base URL, key and model edits, a diff and the checks that remain.
-   [max\_tokens calculator for reasoning models](https://broadrouter.com/tools/reasoning-token-budget/) Answer length + reasoning budget + margin = a max\_tokens that does not cut the answer off.
-   [JSON schema generator for LLM structured output](https://broadrouter.com/tools/json-schema-generator/) Sample JSON to strict schema, Pydantic, Zod and a ready request.
-   [LLM JSON output validator](https://broadrouter.com/tools/llm-json-output-validator/) Parse errors by line and column, safe repairs, cut-off detection and JSON Schema checks for model output.

[Kostenlose Tools (auf Englisch)](https://broadrouter.com/tools/)

## Begriffe in diesem Artikel

[Tool Calling (Function Calling)](https://broadrouter.com/de/glossary/tool-calling/)

Tool Calling, auch Function Calling genannt, ist eine Funktion von LLM-APIs, bei der das Modell eine strukturierte Anfrage zurückgibt, eine vom Entwickler definierte Funktion mit JSON-Argumenten auszuführen. Die Anwendung führt die Funktion aus und sendet das Ergebnis zurück; das Modell selbst führt nie Code aus.

[Chat Completions API](https://broadrouter.com/de/glossary/chat-completions-api/)

Die Chat Completions API ist der HTTP-Endpoint von OpenAI, POST /v1/chat/completions, der einen Modellnamen und eine Liste von Nachrichten mit Rollen entgegennimmt und die nächste Nachricht des Modells zurückgibt. Ihr Format für Anfrage und Antwort wurde zum gemeinsamen Standard, den OpenAI-kompatible Anbieter und SDKs übernehmen.

[Embeddings](https://broadrouter.com/de/glossary/embeddings/)

Embeddings sind Listen von Gleitkommazahlen (Vektoren), die ein Modell erzeugt, um einen Text, ein Bild oder einen anderen Input darzustellen. Inputs mit ähnlicher Bedeutung erhalten nah beieinanderliegende Vektoren; über den Abstand lassen sich Suchergebnisse ranken, Dokumente clustern oder verwandte Elemente finden.

[Basis-URL (Base URL)](https://broadrouter.com/de/glossary/base-url/)

Eine Basis-URL ist die feste Stammadresse einer API, etwa https://api.example.com/v1, die ein Client vor jeden Endpoint-Pfad wie /chat/completions setzt. In OpenAI-kompatiblen SDKs lenkt eine geänderte Basis-URL, zusammen mit API-Schlüssel und Modell-ID, denselben Code zu einem anderen Anbieter.

[Rate Limit (Ratenbegrenzung)](https://broadrouter.com/de/glossary/rate-limit/)

Ein Rate Limit ist eine Obergrenze, die eine API festlegt, wie stark ein Client sie in einem Zeitfenster nutzen darf, etwa Anfragen pro Minute oder Tokens pro Minute. Anfragen über dem Limit werden abgelehnt, meist mit HTTP 429 Too Many Requests, bis die Nutzung wieder darunter liegt.

[Speech-to-Text (Spracherkennung)](https://broadrouter.com/de/glossary/speech-to-text/)

Speech-to-Text, auch automatische Spracherkennung (ASR), ist eine Technik, die gesprochenes Audio in geschriebenen Text umwandelt. Eine Speech-to-Text API nimmt eine Audiodatei oder einen Stream entgegen und liefert ein Transkript, meist abgerechnet pro Audiominute. Die Genauigkeit wird mit der Wortfehlerrate gemessen und hängt von Akzent, Dialekt und Aufnahmequalität ab.

[Batch API](https://broadrouter.com/de/glossary/batch-api/)

Eine Batch API ist ein asynchroner LLM-Endpoint, der viele Anfragen auf einmal annimmt, meist als Datei, sie innerhalb eines festgelegten Zeitfensters statt sofort verarbeitet und die Ergebnisse gesammelt zurückgibt. Anbieter wie OpenAI und Anthropic berechnen Batch-Anfragen mit Rabatt gegenüber ihren Standard-APIs.

[JSON Schema](https://broadrouter.com/de/glossary/json-schema/)

JSON Schema ist ein in JSON geschriebenes Vokabular, mit dem Sie die Struktur von JSON-Daten beschreiben und validieren: Typen, Pflichtfelder, erlaubte Werte und Verschachtelung. Die aktuelle Version ist 2020-12. LLM-APIs definieren damit Tool-Parameter und die genaue Struktur, der eine strukturierte Ausgabe folgen muss.

## Häufige Fragen

### Brauche ich ein anderes SDK, um eine OpenAI-kompatible API zu nutzen?

Nein. Behalten Sie das offizielle Paket openai und übergeben Sie eine andere base\_url (Python) bzw. baseURL (Node) sowie den Schlüssel des neuen Anbieters. Anfrage- und Antwortobjekte bleiben für die Endpoints, die der Anbieter unterstützt, gleich.

### Unterstützt eine OpenAI-kompatible API auch die Responses API?

Manche ja; viele unterstützen nur Chat Completions. Prüfen Sie die Liste der Endpoints des Anbieters. BroadNet Inference dokumentiert /v1/chat/completions und /v1/audio/transcriptions; Code für die Responses API müssen Sie also auf Chat Completions umschreiben.

### Was passiert mit meinen Embeddings, wenn ich wechsle?

Sie brechen, wenn der neue Anbieter keinen Embeddings-Endpoint hat und Sie die Basis-URL global geändert haben. BroadNet verkauft keine Embeddings; lassen Sie also einen Embeddings-Client auf Ihren Embeddings-Anbieter zeigen. Mischen Sie nie Vektoren zweier Embedding-Modelle in einem Index.

### Sollte ich max\_tokens oder max\_completion\_tokens senden?

OpenAI führt max\_tokens als abgekündigt zugunsten von max\_completion\_tokens. Viele kompatible Anbieter dokumentieren stattdessen max\_tokens, und auch die Dokumentation von BroadNet nutzt max\_tokens. Senden Sie, was der Anbieter dokumentiert, und prüfen Sie im Smoke-Test, dass das Limit greift.

### Funktionieren die Helfer von OpenAI für strukturierte Ausgabe weiterhin?

Nur, wenn der Anbieter für das genutzte Modell response\_format mit json\_schema akzeptiert. BroadNet listet strukturierte Ausgabe für GLM 5.3 und Qwen3.8 27B, nennt aber den Anfrageparameter nicht; testen Sie es also, und validieren Sie das geparste Ergebnis weiterhin.

## Weiterlesen

-   [Wechsel zu einer OpenAI-kompatiblen API: die Migrations-Checkliste](https://broadrouter.com/de/blog/openai-compatible-api-migration-checklist/)
-   [Basis-URLs OpenAI-kompatibler APIs: 14 Anbieter geprüft](https://broadrouter.com/de/blog/openai-compatible-api-base-urls/)
-   [Tool Calling mit offenen Modellen: Schemas, parallele Aufrufe, Retries](https://broadrouter.com/de/blog/tool-calling-open-models/)
-   [JSON Mode vs. json\_schema: strukturierte Ausgabe, die hält](https://broadrouter.com/de/blog/structured-output-json-schema/)
-   [Wie Sie ein LLM vor dem Anbieterwechsel evaluieren](https://broadrouter.com/de/blog/evaluate-llm-before-switching/)
-   [GPU-Hardware und Serving von BroadNet, wie BroadNet sie beschreibt](https://broadrouter.com/de/blog/broadnet-gpu-fleet-and-serving/)
-   [LLM-Antworten cachen, Kosten senken: ein Exact-Match-Cache in Python](https://broadrouter.com/de/blog/cache-llm-responses-cut-cost/)
-   [Anleitung: OpenAI Python SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-python-sdk/)
-   [Anleitung: OpenAI Node.js SDK mit BroadNet Inference nutzen](https://broadrouter.com/de/guides/openai-node-sdk/)
-   [Anleitung: Schnellstart mit curl: erste Anfrage an BroadNet Inference](https://broadrouter.com/de/guides/curl-quickstart/)
-   [Anleitung: Warum ein Reasoning-Modell eine leere Antwort liefert](https://broadrouter.com/de/guides/reasoning-tokens-empty-response/)

Testen Sie es mit Ihrem echten Workload. Neue Konten starten mit USD 5 Guthaben für Gemma und Transkription. DeepSeek, GLM und Qwen3.8 erfordern eine Aufladung.

[Loslegen](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-migrate-from-openai-api-code-walkthrough&utm_content=page-cta) ·

**Quellen**

-   [API-Referenz von BroadNet Inference: Endpoints, Modell-IDs, Fähigkeiten, Nutzungsdaten beim Streaming, Fehler (geprüft am 2026-11-15) (auf Englisch)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=de-blog-migrate-from-openai-api-code-walkthrough&utm_content=sources)
-   [README von openai-python: Responses ist die primäre API, Chat Completions wird unbefristet unterstützt, Retries (geprüft am 2026-11-15)](https://github.com/openai/openai-python)
-   [Client-Quellcode von openai-node: baseURL hat OPENAI\_BASE\_URL als Standard (geprüft am 2026-11-15)](https://github.com/openai/openai-node/blob/master/src/client.ts)
-   [OpenAI, Migration zur Responses API: Unterschiede bei strukturierter Ausgabe, Tools und Speicherung (geprüft am 2026-11-15)](https://developers.openai.com/api/docs/guides/migrate-to-responses)
-   [Leitfaden zu Function Calling von OpenAI: Tool-Formate in beiden APIs (geprüft am 2026-11-15)](https://developers.openai.com/api/docs/guides/function-calling)
-   [Referenz zu Chat Completions von OpenAI: max\_tokens zugunsten von max\_completion\_tokens abgekündigt (geprüft am 2026-11-15)](https://developers.openai.com/api/reference/resources/chat/subresources/completions/methods/create)
