DEV Community

Cover image for GPT-Realtime-2: Was ist das & GPT-Realtime-2 API nutzen
Emre Demir
Emre Demir

Posted on • Originally published at apidog.com

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

OpenAI hat am 6. November 2026 eine neue Generation von Sprachmodellen veröffentlicht. Die wichtigste Neuerung ist gpt-realtime-2: ein Sprach-zu-Sprach-Modell mit GPT-5-Klasse-Reasoning, 128.000 Token Kontextfenster und konfigurierbarem Reasoning-Aufwand. Wenn Sie bereits gpt-realtime integriert haben, ist die Migration im Kern ein Modellstring-Wechsel plus einige neue Sitzungs- und Tool-Felder.

Teste Apidog noch heute

Dieser Leitfaden zeigt, was GPT-Realtime-2 ist, was sich gegenüber dem Vorgängermodell geändert hat, wie die Preise aussehen und wie Sie das Modell per WebSocket oder SIP anbinden. Zusätzlich richten wir ein testbares Setup in Apidog ein, damit Sie Realtime-Sitzungen reproduzierbar wiedergeben können, ohne Audio jedes Mal neu aufzunehmen.

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 Flaggschiffmodell für Sprach-zu-Sprach-Anwendungen mit GPT-5-Klasse-Reasoning, 128k Kontext und 32k maximalen Ausgabetoken.
  • Audiopreise: 32 $ pro 1 Mio. Eingabetoken und 64 $ pro 1 Mio. Ausgabetoken. Zwischengespeicherte Eingaben kosten 0,40 $ pro 1 Mio. Token.
  • Neue Stimmen: Cedar und Marin, exklusiv für die Realtime API. Acht bestehende Stimmen wurden überarbeitet.
  • Reasoning-Stufen: minimal, low, medium, high, xhigh. Standard ist low.
  • WebSocket-Endpunkt: wss://api.openai.com/v1/realtime?model=gpt-realtime-2.
  • SIP wird für eingehende Telefonanrufe unterstützt.
  • Begleitmodelle: GPT-Realtime-Translate für Live-Übersetzung und GPT-Realtime-Whisper für Streaming-STT.
  • Nutzen Sie Apidog, um WebSocket-Sitzungen zu skripten, Frames zu erfassen und Läufe zu vergleichen.

Was ist GPT-Realtime-2?

GPT-Realtime-2 ist ein End-to-End-Sprach-zu-Sprach-Modell. Sie streamen Audio hinein, erhalten Audio zurück, und das Modell übernimmt Transkription, Reasoning, Tool-Auswahl und Sprachgenerierung in einem Durchlauf.

Das ersetzt die klassische Pipeline:

Speech-to-Text → LLM → Text-to-Speech
Enter fullscreen mode Exit fullscreen mode

durch eine direkte Realtime-Sitzung:

Audio/Text/Bild → GPT-Realtime-2 → Audio/Text
Enter fullscreen mode Exit fullscreen mode

Abbildung 1: GPT-Realtime-2 ist ein End-to-End-Sprach-zu-Sprach-Modell.

Das Modell akzeptiert Text, Audio und Bilder als Eingabe und gibt Text sowie Audio aus. Neu ist die Bildeingabe: Sie können während einer Live-Konversation etwa einen Screenshot oder ein Foto übergeben und den Agenten laut dazu befragen.

Typische Anwendungsfälle:

  • Voice-Support-Agenten mit Tool-Zugriff
  • Sprach-Copiloten, die Screenshots oder Fotos analysieren
  • Telefonagenten über SIP
  • Live-Übersetzungs- und Assistenzsysteme
  • Barrierefreiheits- und Screen-Reader-ähnliche Anwendungen

Spezifikationen

Attribut Wert
Modell-ID gpt-realtime-2
Kontextfenster 128.000 Token
Max. Ausgabe 32.000 Token
Eingabe-Modalitäten Text, Audio, Bild
Ausgabe-Modalitäten Text, Audio
Wissensgrenze 30.09.2024
Reasoning-Stufen minimal, low, medium, high, xhigh
Funktionsaufruf Ja
Remote MCP-Server Ja
Bildeingabe Ja
SIP-Telefonanruf Ja

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

Gegenüber gpt-realtime-1.5 verbessert gpt-realtime-2 laut den veröffentlichten Benchmarks vor allem Audio-Intelligenz und Anweisungsbefolgung:

  • Big Bench Audio: 81,4 % → 96,6 %
  • Audio MultiChallenge: 34,7 % → 48,5 %

Diese Werte wurden mit high und xhigh Reasoning erzielt. Für Produktionsanwendungen ist low der Standard, weil es geringere Latenz bietet.

Wichtige Verhaltensänderungen:

  • Preambeln: Das Modell kann kurze Übergangssätze wie „Ich prüfe das kurz“ ausgeben, während es Reasoning oder Tool-Aufrufe vorbereitet.
  • Parallele Tool-Aufrufe: Mehrere Tools können gleichzeitig gestartet werden, während das Modell den Fortschritt per Audio erklärt.
  • Bessere Wiederherstellung: Mehrdeutige oder teilweise fehlgeschlagene Abläufe werden stabiler fortgesetzt.
  • Domänen-Tonsteuerung: Fachterminologie und gewünschter Sprachstil bleiben über längere Sitzungen konsistenter.

Abbildung 2: Reasoning ist der neue Engpass. GPT-Realtime-2 ist besser darin.

Das Kontextfenster wächst von 32k auf 128k Token. Das ist relevant für lange Support-, Banking-, Lern- oder Beratungs-Sitzungen, in denen das Modell über viele Minuten Kontext behalten muss.

Preise

GPT-Realtime-2 wird pro Token abgerechnet. Text, Audio und Bild haben separate Tarife.

Token-Typ Eingabe Zwischengespeicherte Eingabe Ausgabe
Text 4,00 $ / 1 Mio. 0,40 $ / 1 Mio. 24,00 $ / 1 Mio.
Audio 32,00 $ / 1 Mio. 0,40 $ / 1 Mio. 64,00 $ / 1 Mio.
Bild 5,00 $ / 1 Mio. 0,50 $ / 1 Mio. n. z.

Zwischengespeicherte Eingaben sind besonders wichtig, wenn Ihr Agent mit einem stabilen Systemprompt, festen Richtlinien oder wiederverwendbaren Dokumenten arbeitet. Halten Sie diesen Kontext cache-freundlich, um wiederholte Eingaben günstiger zu machen.

Zum Vergleich mit der restlichen OpenAI-Modelllinie siehe GPT-5.5-Preise.

Die Begleitmodelle werden pro Minute abgerechnet:

  • GPT-Realtime-Translate: 0,034 $ pro Minute. Unterstützt 70 Eingabesprachen und 13 Ausgabesprachen.
  • GPT-Realtime-Whisper: 0,017 $ pro Minute. Streaming-Sprach-zu-Text für Live-Untertitel und kontinuierliche Transkription.

Faustregel:

  • Verwenden Sie GPT-Realtime-2, wenn Reasoning und Sprachausgabe zusammen benötigt werden.
  • Verwenden Sie GPT-Realtime-Translate für Live-Übersetzung.
  • Verwenden Sie GPT-Realtime-Whisper, wenn Sie nur ein Transkript benötigen.

Endpunkte und Authentifizierung

GPT-Realtime-2 ist über mehrere Endpunkte erreichbar:

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}
POST https://api.openai.com/v1/realtime/translations
POST https://api.openai.com/v1/realtime/transcription_sessions
Enter fullscreen mode Exit fullscreen mode

Für Sprachagenten ist der WebSocket-Endpunkt relevant:

wss://api.openai.com/v1/realtime?model=gpt-realtime-2
Enter fullscreen mode Exit fullscreen mode

Authentifizierung:

Authorization: Bearer $OPENAI_API_KEY
OpenAI-Beta: realtime=v1
Enter fullscreen mode Exit fullscreen mode

Setzen Sie Ihren API-Key als Umgebungsvariable:

export OPENAI_API_KEY="sk-proj-..."
Enter fullscreen mode Exit fullscreen mode

Verbindung über WebSocket

Ein minimaler Node.js-Client:

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.
    // In der Praxis an Lautsprecher, Browser oder Telefon-Bridge weiterleiten.
    process.stdout.write(Buffer.from(event.delta, "base64"));
  }
});
Enter fullscreen mode Exit fullscreen mode

Die Realtime API ist ereignisgesteuert:

  1. Client öffnet WebSocket.
  2. Client sendet session.update.
  3. Client streamt Audio mit input_audio_buffer.append.
  4. Server erkennt Gesprächsgrenzen per VAD.
  5. Server sendet Audio mit response.audio.delta.
  6. Client spielt Audio ab oder leitet es weiter.

PCM16 bei 24 kHz ist ein sicherer Standard. Für Telefonie sind auch G.711 mu-law und A-law relevant.

Wenn Sie die Realtime-Oberfläche mit der Responses API vergleichen möchten, siehe Wie man die GPT-5.5 API verwendet.

Stimmen

Mit dieser Version gibt es zwei neue Stimmen:

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

Beide sind exklusiv für die Realtime API.

Bestehende Stimmen bleiben verfügbar:

alloy
ash
ballad
coral
echo
sage
shimmer
verse
Enter fullscreen mode Exit fullscreen mode

Sie können die Stimme während einer laufenden Sitzung wechseln:

ws.send(JSON.stringify({
  type: "session.update",
  session: {
    voice: "marin",
  },
}));
Enter fullscreen mode Exit fullscreen mode

Bildeingabe

Sie können einem Benutzerbeitrag ein Bild hinzufügen. Das Modell kann das Bild in der laufenden Sprachsitzung berücksichtigen.

Beispiel:

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" }));
Enter fullscreen mode Exit fullscreen mode

Praktische Muster:

  • Sprachgesteuerte QA: Tester zeigt eine fehlerhafte UI per Kamera; der Agent beschreibt den Fehler und formuliert einen Bugreport.
  • Vor-Ort-Support: Techniker teilt ein Foto einer Verkabelung; der Agent führt durch die Diagnose.
  • Barrierefreiheit: Der Agent beschreibt den aktuellen Bildschirm während eines Support-Anrufs.

Mehr zum Bild-Stack: Wie man die GPT-Image-2 API verwendet.

Funktionsaufruf und MCP

GPT-Realtime-2 unterstützt klassische Funktionstools und Remote-MCP-Server in derselben Sitzung.

Standard-Funktionsaufrufe

Der Ablauf ähnelt Chat Completions:

  1. Tools in der Sitzung deklarieren.
  2. Modell sendet Funktionsargumente als Events.
  3. Anwendung führt die Funktion aus.
  4. Anwendung sendet das Ergebnis als function_call_output zurück.

Konzeptionell:

session.update → tools deklarieren
response.function_call_arguments.delta → Argumente empfangen
Tool ausführen
conversation.item.create → function_call_output senden
Enter fullscreen mode Exit fullscreen mode

Neu ist, dass das Modell mehrere Tool-Aufrufe parallel auslösen kann. Das ist nützlich für Sprachagenten, die beispielsweise gleichzeitig Kontostand, letzte Transaktionen und Supportstatus abrufen.

Remote MCP-Server

Bei Remote MCP konfigurieren Sie einen MCP-Server direkt in der Sitzung. Die Realtime API kann dann erlaubte Tools über diesen Server verwenden.

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

Das reduziert die eigene Event-Loop-Logik, wenn Ihr Agent viele Tools anbinden muss.

Wenn Sie MCP-Server vor der Integration testen möchten, siehe MCP-Server-Test in Apidog.

SIP-Telefonanrufe

GPT-Realtime-2 kann über SIP in Telefonie-Workflows eingebunden werden.

Grundidee:

  1. SIP-Trunk an OpenAIs SIP-Gateway weiterleiten.
  2. Eingehender Anruf erzeugt eine Realtime-Sitzung.
  3. Anwendung verbindet sich per WebSocket mit: 
wss://api.openai.com/v1/realtime?call_id={call_id}
Enter fullscreen mode Exit fullscreen mode

Das Modell akzeptiert G.711 mu-law und A-law direkt. Dadurch müssen Telefonie-Bridges nicht zwingend transkodieren.

Das ist besonders relevant für Callcenter-Agenten, die während eines Gesprächs Tools ausführen, Daten nachschlagen oder MCP-Server verwenden.

Reasoning-Stufen

Die Reasoning-Stufe steuert den Kompromiss zwischen Latenz und Antwortqualität.

Stufe Anwendungsfall Ungefähre Latenzkosten
minimal Einfache Ja/Nein-Antworten Keine
low Standard; Support und Chat Gering
medium Disambiguierung, komplexerer Tool-Dispatch Moderat
high Mehrstufiges Reasoning, Code-Review per Sprache Hoch
xhigh Benchmarks, schwierige analytische Fragen Höchste

Standard ist:

reasoning: { effort: "low" }
Enter fullscreen mode Exit fullscreen mode

Starten Sie in Produktion mit low. Erhöhen Sie die Stufe nur, wenn Sie konkret messen, dass die Antwortqualität nicht ausreicht.

Testen der Realtime API in Apidog

WebSocket-APIs sind im Terminal schwer zu debuggen, weil Sitzungen zustandsbehaftet sind. Mit Apidog können Sie Realtime-Flows reproduzierbar testen.

Abbildung 3: Apidog unterstützt WebSocket-Wiedergabe, wodurch Entwickler die Realtime API debuggen können.

Praktisches Setup:

  1. Neue WebSocket-Anfrage erstellen.
  2. URL setzen: 
wss://api.openai.com/v1/realtime?model=gpt-realtime-2
Enter fullscreen mode Exit fullscreen mode
  1. Header hinzufügen: 
Authorization: Bearer {{OPENAI_API_KEY}}
OpenAI-Beta: realtime=v1
Enter fullscreen mode Exit fullscreen mode
  1. session.update als erste Nachricht speichern: 
{
  "type": "session.update",
  "session": {
    "voice": "cedar",
    "instructions": "You are a concise technical support agent.",
    "input_audio_format": "pcm16",
    "output_audio_format": "pcm16",
    "turn_detection": {
      "type": "server_vad"
    },
    "reasoning": {
      "effort": "low"
    }
  }
}
Enter fullscreen mode Exit fullscreen mode
  1. Danach Testnachrichten wie conversation.item.create, input_audio_buffer.append und response.create ausführen.
  2. Serverevents erfassen und zwischen Läufen vergleichen.

Laden Sie Apidog herunter, erstellen Sie eine WebSocket-Anfrage und speichern Sie API-Key, Voice und Modell als Umgebungsvariablen. So können Sie dieselbe Sitzung mit unterschiedlichen Reasoning-Stufen oder Stimmen wiederholen.

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

FAQ

Welche Modell-ID soll ich verwenden?

Verwenden Sie:

gpt-realtime-2
Enter fullscreen mode Exit fullscreen mode

Das frühere Modell ist weiterhin als gpt-realtime verfügbar, falls Sie ein Rollback benötigen. Für die Lite-Version ist auch gpt-realtime-2-mini live.

Kann ich Audio-Eingabe streamen, während Audio-Ausgabe abgespielt wird?

Ja. Die Realtime API nutzt standardmäßig serverseitige Voice Activity Detection. Das Modell kann aufhören zu sprechen, wenn der Benutzer beginnt. Sie können VAD deaktivieren und Gesprächsgrenzen clientseitig steuern.

Umfasst der 128k-Kontext Audio-Token?

Ja. Audio wird tokenisiert. Eine Sekunde Audio entspricht je nach Format etwa 50 Token. Lange Supportanrufe verbrauchen Kontext schneller als reine Textchats.

Wird Fine-Tuning unterstützt?

Noch nicht. Laut Modellkarte unterstützt GPT-Realtime-2 derzeit kein Fine-Tuning, keine vorhergesagten Ausgaben und kein Textstreaming bei Chat Completions. Der Realtime-Endpunkt streamt Audio nativ.

Wie unterscheidet sich GPT-Realtime-2 von GPT-5.5 mit TTS?

GPT-Realtime-2 verarbeitet Sprache End-to-End. Es kann Tonfall, Zögern und Betonung direkt berücksichtigen. Ein Textmodell mit separater TTS-Schicht verliert diese Signale.

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 bis 15 Millionen TPM bei Tier 5. Ratenbegrenzungen gelten pro Modell; bestehende GPT-5-Kontingente werden nicht übertragen.

Zusammenfassung

GPT-Realtime-2 macht Sprachagenten näher an vollwertigen Textagenten: 128k Kontext, GPT-5-Klasse-Reasoning, Bildeingabe, MCP und SIP laufen in einer Realtime-Sitzung zusammen.

Für die Implementierung:

  1. WebSocket mit gpt-realtime-2 öffnen.
  2. session.update mit Stimme, Audioformat, VAD und Reasoning senden.
  3. Audio per input_audio_buffer.append streamen.
  4. Antworten über response.audio.delta abspielen.
  5. Tools oder MCP nur dort hinzufügen, wo der Agent externe Daten benötigt.
  6. Mit low Reasoning starten und nur bei messbarer Qualitätslücke erhöhen.

Der schnellste Weg zum Debugging ist eine gespeicherte WebSocket-Sitzung in Apidog: Headers, Session-Setup, Tool-Konfiguration und Testnachrichten versionieren, wiedergeben und zwischen Läufen vergleichen.

Top comments (0)