GPT-Realtime-2: Was ist das & GPT-Realtime-2 API nutzen

OpenAI hat am 6. November 2026 eine neue Generation von Sprachmodellen veröffentlicht, und die wichtigste Neuerung ist GPT-Realtime-2: das erste Sprach-zu-Sprach-Modell mit GPT-5-Klasse-Reasoning, einem 128.000-Token-Kontextfenster und konfigurierbarem Reasoning-Aufwand, der die Latenz gegenüber der Antwortqualität skaliert. Es läuft auf der bestehenden Realtime-API-Oberfläche, wenn Sie also `gpt-realtime` bereits integriert haben, ist die Migration eine Änderung des Modellstrings und ein paar neuer Tool-Felder.

Dieser Leitfaden behandelt, was GPT-Realtime-2 ist, was sich gegenüber dem Vorgängermodell geändert hat, die vollständige Preisübersicht und wie man es sowohl über WebSocket als auch über SIP aufrufen kann. Wir fügen auch ein funktionierendes Setup in Apidog hinzu, damit Sie Realtime-Sitzungen wiedergeben können, ohne jedes Mal Audio neu aufzeichnen zu müssen.

Für den Kontext zu OpenAIs breiterer Modelllinie 2026 siehe Was ist GPT-5.5. Für das multimodale Geschwistermodell siehe Wie man die GPT-Image-2 API verwendet.

TL;DR

• GPT-Realtime-2 ist OpenAIs Flaggschiff unter den Sprach-zu-Sprach-Modellen mit GPT-5-Klasse-Reasoning, 128k Kontext und 32k maximalen Ausgabetoken.
• Die Audiopreise betragen **32 $ pro 1 Mio. Eingabetoken** und **64 $ pro 1 Mio. Ausgabetoken**, mit zwischengespeicherten Eingaben zu 0,40 $/1 Mio.
• Zwei neue Stimmen, **Cedar** und **Marin**, sind exklusiv für die Realtime API verfügbar; die acht bestehenden Stimmen wurden qualitativ überarbeitet.
• Fünf Reasoning-Stufen: `minimal`, `low`, `medium`, `high`, `xhigh`. Standard ist `low` für geringe Latenz.
• Verbinden Sie sich über WebSocket unter `wss://api.openai.com/v1/realtime?model=gpt-realtime-2`, oder nehmen Sie eingehende Anrufe über SIP entgegen.
• Begleitende Veröffentlichungen: **GPT-Realtime-Translate** (Live-Übersetzung, 70 Eingabesprachen, 0,034 $/Min) und **GPT-Realtime-Whisper** (Streaming STT, 0,017 $/Min).
• Verwenden Sie Apidog, um die WebSocket-Sitzung zu skripten, Frames zu erfassen und Audioereignisse zwischen den Läufen zu vergleichen.

Was ist GPT-Realtime-2?

GPT-Realtime-2 ist ein einziges Sprach-zu-Sprach-Modell. Sie streamen Audio hinein, streamen Audio heraus, und das Modell übernimmt Transkription, Reasoning, Tool-Auswahl und Sprachgenerierung in einem Durchgang. Es gibt keine STT-dann-LLM-dann-TTS-Pipeline; dieses ältere Muster wurde letztes Jahr durch `gpt-realtime` ersetzt, und v2 schärft dieselbe Oberfläche mit einem stärkeren Reasoning-Kern.

Das Modell akzeptiert Text, Audio und Bilder als Eingabe und gibt Text und Audio als Ausgabe aus. Bildeingabe ist hier die neue Modalität: Sie können ein Foto oder einen Screenshot in eine Live-Konversation einfügen und den Agenten bitten, zu beschreiben, was auf dem Bildschirm des Benutzers zu sehen ist, und dann weiterreden. Das ermöglicht den Aufbau von Sprach-Copiloten, die sehen, was der Benutzer sieht, was eine Klasse von Agenten ist, die das frühere Modell nicht End-to-End ausführen konnte.

Spezifikationen auf einen Blick:

Was sich gegenüber gpt-realtime geändert hat

Die Benchmark-Gewinne sind real, nicht kosmetisch. Gegenüber `gpt-realtime-1.5` erzielt das v2-Modell:

• **Big Bench Audio (Audio-Intelligenz):** 81,4 % → 96,6 %, ein Sprung von 15,2 Punkten.
• **Audio MultiChallenge (Anweisungsbefolgung):** 34,7 % → 48,5 %, ein Sprung von 13,8 Punkten.

Diese Werte wurden bei `high` und `xhigh` Reasoning erzielt. Die Produktion verwendet standardmäßig `low` für geringe Latenz, sodass die alltägliche Qualität zwischen den beiden Extremen liegt. Das Modell hat auch vier Verhaltensweisen gelernt, die hervorzuheben sind:

• **Preambeln.** Das Modell kann kurze Füllphrasen wie „Lassen Sie mich das überprüfen“ sagen, bevor es eine echte Antwort gibt, was die Reasoning-Latenz vor dem Benutzer verbirgt.
• **Parallele Tool-Aufrufe mit Audio-Erzählung.** Das Modell kann mehrere Funktionsaufrufe gleichzeitig auslösen und den Fortschritt erzählen, während sie aufgelöst werden, anstatt zwei Sekunden lang stumm zu bleiben.
• **Stärkere Wiederherstellung.** Mehrdeutige oder teilweise fehlgeschlagene Durchläufe werden elegant behandelt, anstatt zum Anfang zurückzukehren.
• **Domänen-Tonsteuerung.** Spezialisierte Terminologie bleibt über eine lange Sitzung konsistent, und das Modell passt die Lieferweise (formell, leger, langsam) an, wenn Sie dies innerhalb der Sitzung anfordern.

Der Kontext wuchs von 32k auf 128k Token, was die Änderung ist, die es Ihnen ermöglicht, lange Sprach-Sitzungen aufzubauen; Anwendungsfälle in den Bereichen Bankwesen, Support und Nachhilfe sind die offensichtlichen Gewinner.

Preise

GPT-Realtime-2 wird pro Token abgerechnet, mit separaten Tarifen für Text-, Audio- und Bildeingaben.

Zwischengespeicherte Eingaben senken die Kosten für wiederholten Kontext um das **80-fache**, daher sollte jeder Agent mit einem stabilen Systemprompt oder einem wiederverwendeten Dokument den Cache warm halten. Zum Vergleich mit dem Rest der OpenAI-Linie siehe GPT-5.5-Preise.

Die Begleitmodelle sind anders bepreist, da sie pro Minute abgerechnet werden:

• **GPT-Realtime-Translate:** 0,034 $ pro Minute. Verarbeitet 70 Eingabesprachen und 13 Ausgabesprachen, mit einer um 12,5 % niedrigeren Wortfehlerrate als jedes andere in Hindi, Tamil und Telugu getestete Modell.
• **GPT-Realtime-Whisper:** 0,017 $ pro Minute. Streaming-Sprach-zu-Text, entwickelt für Live-Untertitel und kontinuierliche Transkription; schneller als die Ausführung von Batch-Whisper auf einem rollierenden Puffer.

Wählen Sie GPT-Realtime-2, wenn Sie Reasoning und Spracherzeugung zusammen benötigen, GPT-Realtime-Translate für die mehrsprachige Live-Interpretation und GPT-Realtime-Whisper, wenn Sie nur das Transkript benötigen.

Endpunkte und Authentifizierung

GPT-Realtime-2 wird über mehrere Endpunkte bereitgestellt, je nachdem, was Sie tun möchten:

POST https://api.openai.com/v1/chat/completions
POST https://api.openai.com/v1/responses
WSS  wss://api.openai.com/v1/realtime?model=gpt-realtime-2
WSS  wss://api.openai.com/v1/realtime?call_id={call_id}   # für SIP
POST https://api.openai.com/v1/realtime/translations
POST https://api.openai.com/v1/realtime/transcription_sessions

Für Sprachagenten ist der WebSocket-Endpunkt der richtige. Die Authentifizierung erfolgt nach dem gleichen Bearer-Token-Muster, das OpenAI überall verwendet:

Authorization: Bearer $OPENAI_API_KEY
OpenAI-Beta: realtime=v1

Setzen Sie `OPENAI_API_KEY` einmal und verwenden Sie es wieder.

export OPENAI_API_KEY="sk-proj-..."

Verbindung über WebSocket

Ein minimaler Node.js-Client sieht so aus:

import WebSocket from "ws";

const ws = new WebSocket(
  "wss://api.openai.com/v1/realtime?model=gpt-realtime-2",
  {
    headers: {
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
      "OpenAI-Beta": "realtime=v1",
    },
  }
);

ws.on("open", () => {
  ws.send(JSON.stringify({
    type: "session.update",
    session: {
      voice: "cedar",
      instructions: "You are a friendly support agent for a fintech app.",
      input_audio_format: "pcm16",
      output_audio_format: "pcm16",
      turn_detection: { type: "server_vad" },
      reasoning: { effort: "low" },
    },
  }));
});

ws.on("message", (raw) => {
  const event = JSON.parse(raw.toString());
  if (event.type === "response.audio.delta") {
    // base64 PCM16 Audio-Chunk; an Lautsprecher oder Browser weiterleiten
    process.stdout.write(Buffer.from(event.delta, "base64"));
  }
});

Die Sitzung ist ereignisgesteuert. Sie senden `input_audio_buffer.append`-Frames, während der Benutzer spricht, und der Server sendet `response.audio.delta`-Ereignisse zurück, wenn er antwortet. PCM16 bei 24 kHz ist der sichere Standard; G.711 mu-law und A-law werden ebenfalls unterstützt, was wichtig ist, wenn Sie eine Brücke zu Telefonsystemen schlagen.

Für das Python-Äquivalent bietet das `openai`-SDK >= 2.1.0 einen `realtime`-Client mit denselben Ereignisnamen. Wenn Sie die Realtime-Oberfläche mit der Responses API vergleichen möchten, siehe Wie man die GPT-5.5 API verwendet.

Stimmen

Zwei neue Stimmen werden mit dieser Version ausgeliefert:

• **Cedar**: Warme, mitteltiefe männliche Stimme. Standard für allgemeine Agenten.
• **Marin**: Helle, klare weibliche Stimme. Gut für Übersetzungen und Ansagen.

Beide sind exklusiv für die Realtime API. Die vorherigen acht Stimmen (`alloy`, `ash`, `ballad`, `coral`, `echo`, `sage`, `shimmer`, `verse`) sind weiterhin verfügbar und wurden neu abgestimmt, um den neuen Audio-Stack des Modells zu nutzen, sodass sie merklich weniger robotisch klingen als in v1.

Wechseln Sie die Stimme während der Sitzung, indem Sie ein weiteres `session.update` mit dem neuen `voice`-Feld senden. Es gibt keine zusätzliche Latenz durch einen Stimmenwechsel.

Bildeingabe

Sie können jedem Benutzerbeitrag ein Bild anhängen. Das Modell sieht es so, wie GPT-4o Vision ein Foto sieht, nur können Sie jetzt laut Nachfragen stellen und es antwortet laut:

ws.send(JSON.stringify({
  type: "conversation.item.create",
  item: {
    type: "message",
    role: "user",
    content: [
      { type: "input_image", image_url: "https://example.com/screenshot.png" },
      { type: "input_text", text: "What does this error mean?" },
    ],
  },
}));
ws.send(JSON.stringify({ type: "response.create" }));

Häufige Muster, die wir in frühen Produktions-Builds sehen:

• **Sprachgesteuerte QA.** Der Tester richtet eine Telefonkamera auf eine fehlerhafte Benutzeroberfläche; der Agent beschreibt, was er sieht, und diktiert den Fehlerbericht.
• **Vor-Ort-Support.** Der Techniker teilt ein Foto einer Verkabelungstafel; der Agent führt durch die Diagnose.
• **Barrierefreiheit.** Live-Bildschirmleser-ähnliche Erzählung des aktuellen Bildschirms eines Benutzers während eines Support-Anrufs.

Für einen tieferen Einblick in OpenAIs Bild-Stack siehe Wie man die GPT-Image-2 API verwendet.

Funktionsaufruf und MCP

GPT-Realtime-2 unterstützt sowohl Standard-Funktionstools als auch Remote-MCP-Server in derselben Sitzung.

Standard-Funktionsaufrufe funktionieren wie Chat Completions: Sie deklarieren Tools in der Sitzungskonfiguration, das Modell sendet ein `response.function_call_arguments.delta`-Ereignis, Sie führen es aus, Sie antworten mit `conversation.item.create` vom Typ `function_call_output`. Das neue Verhalten sind parallele Aufrufe; das Modell kann zwei oder drei gleichzeitig auslösen und dabei „Überprüfung Ihres Kontostands und Ihrer letzten drei Transaktionen“ erzählen, während sie aufgelöst werden.

Remote-MCP-Server sind die größere Änderung. Konfigurieren Sie eine MCP-URL und eine Whitelist von Tools in der Sitzung, und die Realtime API selbst führt die Aufrufe aus; Ihr Code muss niemals den Umweg über die Funktionsaufruf-Ereignisschleife nehmen. Das hält Sprachagenten reaktionsschnell, wenn sie aus einem Tool-Katalog von fünfzig statt fünf Endpunkten ziehen.

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    tools: [{
      type: "mcp",
      server_url: "https://mcp.example.com/sse",
      allowed_tools: ["lookup_account", "list_transactions"],
    }],
  },
}));

Wenn Sie MCP-Server testen, bevor Sie sie in einen Sprachagenten integrieren, deckt der MCP-Server-Test in Apidog das von uns intern verwendete Request-Replay-Setup ab.

SIP-Telefonanrufe

Echtzeit-Sprachagenten können echte Telefonanrufe entgegennehmen. Leiten Sie Ihren SIP-Trunk an OpenAIs SIP-Gateway, und eingehende Anrufe öffnen eine WebSocket-Sitzung unter `wss://api.openai.com/v1/realtime?call_id={call_id}`. Das Modell akzeptiert G.711 mu-law und A-law direkt, sodass Sie in Ihrer Bridge keine Transkodierung vornehmen müssen.

Dies ist der Teil, der GPT-Realtime-2 zu einem glaubwürdigen Callcenter-Modell und nicht zu einer Browser-Demo macht. Es passt natürlich zu parallelen Tool-Aufrufen und MCP, da die meisten Telefonagenten hauptsächlich Tool-Dispatch betreiben.

Reasoning-Stufen

Die fünf Reasoning-Stufen verhalten sich wie eine einzige Drosselung für Latenz versus Antwortqualität:

Standard ist `low`. Erhöhen Sie nur, wenn Sie Qualitätseinbußen bei `low` feststellen; die Latenzkosten bei `high` und `xhigh` sind so real, dass Benutzer den Unterschied bei Anrufen bemerken.

Testen der Realtime API in Apidog

WebSocket-APIs sind im Terminal schwer zu debuggen, da die Konversation einen Zustand hat. Apidog bietet erstklassige WebSocket-Unterstützung, sodass Sie:

1. Die WebSocket-URL mit dem vorausgefüllten `OpenAI-Beta`-Header speichern.
2. Eine Sequenz von JSON-Nachrichten (session.update, input_audio_buffer.append, response.create) als Skript bereitstellen.
3. Das Skript gegen eine einzelne Verbindung wiedergeben und jedes Serverereignis in einem Baum erfassen.
4. Zwei Durchläufe nebeneinander vergleichen; nützlich, wenn Sie den Reasoning-Aufwand ändern und die Token-Anzahl der Audioausgabe vergleichen möchten.

Laden Sie Apidog herunter, erstellen Sie eine neue WebSocket-Anfrage und fügen Sie Ihr Bearer-Token unter **Auth** ein. Die Sammlungsstruktur spiegelt das wider, was Sie für HTTP beibehalten: Umgebungen für `OPENAI_API_KEY`, Variablen für `voice`, Skripte, die bei jeder Verbindung ausgeführt werden.

Zum Vergleich mit einem anderen schnellen multimodalen Modell siehe Wie man die Gemini 3 Flash Preview API verwendet.

FAQ

Welche Modell-ID soll ich übergeben? `gpt-realtime-2`. Das frühere Modell ist weiterhin als `gpt-realtime` verfügbar, falls Sie ein Rollback durchführen müssen. Für die Lite-Version ist auch `gpt-realtime-2-mini` live.

Kann ich Audio-Eingabe streamen, während Audio-Ausgabe noch abgespielt wird? Ja. Die Realtime API verwendet standardmäßig serverseitige Stimmerkennungsfunktion (VAD), sodass das Modell aufhört zu sprechen, wenn der Benutzer beginnt. Sie können VAD deaktivieren und die Gesprächsgrenzen vom Client aus steuern.

Umfasst der 128k-Kontext Audio-Token? Ja. Audio wird tokenisiert; eine Sekunde Audio entspricht je nach Format etwa 50 Token. Ein langer Supportanruf verbraucht Kontext schneller als ein langer Textchat, prüfen Sie also die Nutzung, bevor Sie annehmen, dass das 128k-Fenster großzügig ist.

Wird Fine-Tuning unterstützt? Noch nicht. Laut Modellkarte unterstützt GPT-Realtime-2 noch kein Fine-Tuning, keine vorhergesagten Ausgaben oder Textstreaming bei Chat Completions. Der Realtime-Endpunkt streamt Audio von Natur aus.

Wie vergleicht sich dies mit GPT-5.5 mit angehängter TTS? Sie verlieren das End-to-End-Sprach-Reasoning. Ein sprachbewusstes Modell kann Tonfall, Zögern und Betonung erkennen; ein Textmodell mit TTS kann dies nicht. Für Agenten, die auf _wie_ der Benutzer spricht reagieren müssen, ist GPT-Realtime-2 das richtige Werkzeug. Für reines Text-Reasoning siehe Wie man die GPT-5.5 API verwendet.

Welche Ratenbegrenzungen gelten? Tier 1 beginnt bei 40.000 Token pro Minute und skaliert auf 15 Millionen TPM bei Tier 5. Ratenbegrenzungen gelten pro Modell, sodass bestehende GPT-5-Kontingente nicht übertragen werden.

Zusammenfassung

GPT-Realtime-2 schließt die Lücke zwischen Sprachagenten und Textagenten. Der 128k-Kontext, das GPT-5-Klasse-Reasoning, die Bildeingabe, die native MCP- und SIP-Unterstützung ermöglichen es, einen einzigen Sprachagenten zu bauen, der einen Telefonanruf beantwortet, einen Screenshot ansieht, ein Remote-Tool entsendet und sich mitten im Satz von einem Fehler erholt, alles ohne den WebSocket zu verlassen. Die Preisgestaltung ist ehrlich mit 32 $ / 64 $ pro Million Audio-Token, und zwischengespeicherte Eingaben senken die Kosten bei stabilen Systemprompts.

Der schnellste Weg zur Produktion ist, die WebSocket-Sitzung in Apidog zu skripten, eine Tool-Liste festzulegen und mit `low` Reasoning zu beginnen. Erhöhen Sie die Stufe nur, wenn Sie eine Qualitätslücke messen können.