Wähle deine API aus, um die Schritte zum Verbindungsaufbau und die zugehörigen Sitzungsereignisse anzuzeigen.
Einen Browser mit GPT-Live verbinden
Für Audioverbindungen zu GPT-Live in Browser-, Mobil- und Serveranwendungen empfehlen wir WebRTC. Diese Anleitung zeigt den Ablauf anhand eines Browserbeispiels. Die ausgehandelten Medienspuren übertragen das Mikrofonsignal und die generierte Sprache. Über einen Datenkanal laufen JSON-Ereignisse für Transkripte, Sitzungsaktualisierungen und delegierte Aufgaben.
Dein Browser erstellt ein Angebot nach dem Session Description Protocol (SDP). Dein Anwendungsserver sendet das Angebot mit POST /v1/live/sessions und dem API-Schlüssel deines Projekts an OpenAI und erhält eine SDP-Antwort. Bewahre den Schlüssel und die Sitzungskonfiguration auf deinem vertrauenswürdigen Server auf.
Voraussetzungen
Du brauchst Folgendes:
- Einen Projekt-API-Schlüssel mit Zugriff auf GPT-Live.
- Eine Serverlaufzeit für das gewählte SDK-Beispiel. Für das Node.js-Beispiel brauchst du Node.js 22.6 oder neuer.
- Einen Browser mit Mikrofonberechtigung, in dem du die Anwendung über HTTPS oder localhost aufrufst.
Das Beispiel delegiert Aufgaben an Responses und nutzt dafür gpt-5.6-terra und die gehostete Websuche. Informationen zu Backend-Anweisungen und Tools deiner Anwendung findest du im Leitfaden Delegation und Tools. Wie sich die Nutzung von Sprachfunktionen und Backend auf die Kosten auswirkt, erfährst du im Leitfaden Kosten optimieren.
So läuft der Verbindungsaufbau ab
- Fordere als Reaktion auf eine Nutzeraktion Zugriff auf das Mikrofon an und füge die Mikrofonspuren einer Peer-Verbindung hinzu.
- Erstelle den Datenkanal und registriere die Ereignislistener, bevor du das SDP-Angebot erstellst.
- Setze die lokale Sitzungsbeschreibung. Warte, bis WebRTC die ICE-Kandidaten gesammelt hat, und sende dann das Angebot an deinen Server.
- Lass deinen Server per POST ein JSON-Objekt mit
sessionundtransport: { type: "webrtc", sdp: ... }an OpenAI senden. - Übernimm die zurückgegebene SDP-Antwort als Sitzungsbeschreibung der Gegenstelle. Warte, bis
session.startedauf dem Datenkanal eintrifft, bevor du Anwendungsbefehle sendest.
Die HTTP-Anfrage startet die Sitzung. Sende session.start nicht über den Datenkanal. Die Zeichenfolge oai-events bezeichnet im Beispiel den Datenkanal.
Wenn du mit POST /v1/live/sessions eine WebRTC-Sitzung erstellst, werden bei der Initialisierung 15 Sekunden Sprachnutzung berechnet. Sobald die Sitzung läuft, wird dieser Betrag auf die zeitabhängigen Gebühren angerechnet. Zur Laufzeit der Sitzung kommen also keine zusätzlichen 15 Sekunden hinzu. Einzelheiten zur Abrechnung findest du im Abschnitt Gebühren für die WebRTC-Initialisierung.
Anwendungsserver erstellen
Speichere das Serverbeispiel in einem neuen Verzeichnis und setze OPENAI_API_KEY in der Serverumgebung. Verwende für TypeScript Node.js 22.6 oder neuer und speichere das Beispiel als server.ts. Führe zuerst npm install openai express und danach npm pkg set type=module aus. Installiere für Python openai. Der Beispielserver lauscht auf 127.0.0.1, akzeptiert Sitzungsanfragen von http://localhost:3000 und liefert index.html aus dem Verzeichnis aus, in dem du ihn startest.
Speichere das Go-Beispiel als main.go, initialisiere mit go mod init live-demo ein Modul und installiere github.com/openai/openai-go/v3@v3.85.1 mit go get. Führe go run . mit Go 1.26 oder neuer aus. Verwende für Java die Version 17 oder neuer, füge die Maven-Abhängigkeit com.openai:openai-java:4.95.0 hinzu und führe die Klasse LiveConnectionWebrtcExample aus. Installiere für Ruby 3.3 oder neuer openai in Version 0.110.0 und webrick mit den Befehlen gem install openai -v 0.110.0 und gem install webrick. Speichere das Beispiel als server.rb und führe ruby server.rb aus.
Wähle unten eine Sprache für den Server. Jede Variante liefert index.html aus und stellt denselben Endpunkt /api/session auf Port 3000 bereit. Verwende eine SDK-Version, die Live unterstützt, und führe jeweils nur eine Variante aus.
import express from "express";
import OpenAI from "openai";
import { readFile } from "node:fs/promises";
import { resolve } from "node:path";
const app = express();
const client = new OpenAI({ maxRetries: 0 });
const port = 3000;
const origin = `http://localhost:${port}`;
const indexPath = resolve("index.html");
app.use(express.json({ limit: "64kb" }));
app.get("/", async (_request, response) => {
response.type("html").send(await readFile(indexPath, "utf8"));
});
// Local-only demo. Add your application's authentication and authorization
// before exposing session creation to other users.
app.post("/api/session", async (request, response) => {
if (request.headers.origin !== origin) {
response.status(403).json({ error: "Unexpected request origin" });
return;
}
if (typeof request.body?.sdp !== "string" || !request.body.sdp.trim()) {
response.status(400).json({ error: "An SDP offer is required" });
return;
}
if (!process.env.OPENAI_API_KEY) {
response.status(503).json({ error: "Set OPENAI_API_KEY on the server" });
return;
}
try {
const result = await client.live.create({
session: {
model: "gpt-live-1",
instructions:
"Be concise. Delegate requests needing current information to the backend, which can search the web.",
delegation: {
type: "responses",
responses: {
model: "gpt-5.6-terra",
instructions:
"Use web search when current facts are needed. Return concise, grounded results for a spoken conversation.",
tools: [{ type: "web_search" }],
tool_choice: "auto",
},
},
},
transport: {
type: "webrtc",
sdp: request.body.sdp,
},
});
// Preserve the SDK's typed session ID and SDP answer.
response.status(201).json(result);
} catch (error) {
if (!(error instanceof OpenAI.APIError)) throw error;
console.error("Live session creation failed", error.status);
response
.status(error.status ?? 502)
.json({ error: "Live session creation failed" });
}
});
app.listen(port, "127.0.0.1", () => console.log(`Open ${origin}`));Bevor du den Server für andere zugänglich machst, schütze /api/session mit der Authentifizierung und Autorisierung deiner Anwendung. Begrenze die Anzahl der Anfragen und verwende HTTPS. Die Prüfung der Herkunft einer Anfrage in diesem lokalen Beispiel authentifiziert die anfragende Person nicht.
Browserclient erstellen
Erstelle index.html in dem Verzeichnis, in dem du den Server startest:
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>GPT-Live connection</title>
</head>
<body>
<script type="module">
// Paste the compiled contents of browser.js here.
</script>
</body>
</html>Speichere den folgenden TypeScript-Code als browser.ts. Er fügt Bedienelemente zum Starten und Beenden des Gesprächs hinzu, bindet das Mikrofon und die Audiowiedergabe an und verarbeitet Sitzungsereignisse. /api/session ist eine Route auf deinem Anwendungsserver.
const start = document.createElement("button");
start.textContent = "Start conversation";
const stop = document.createElement("button");
stop.textContent = "End conversation";
stop.disabled = true;
const status = document.createElement("p");
const audio = new Audio();
audio.autoplay = true;
audio.controls = true;
document.body.append(start, stop, status, audio);
let peer: RTCPeerConnection;
let events: RTCDataChannel | undefined;
let microphone: MediaStream;
let closeTimeout: ReturnType<typeof setTimeout> | undefined;
let ready = false;
let finalized = false;
function cleanup() {
clearTimeout(closeTimeout);
microphone?.getTracks().forEach((track) => track.stop());
const closingEvents = events;
events = undefined;
closingEvents?.close();
peer?.close();
audio.srcObject = null;
ready = false;
start.disabled = false;
stop.disabled = true;
}
start.addEventListener("click", async () => {
start.disabled = true;
finalized = false;
status.textContent = "Connecting…";
try {
const connection = new RTCPeerConnection();
peer = connection;
connection.addEventListener("track", (event) => {
audio.srcObject = new MediaStream([event.track]);
audio.play().catch(() => {
status.textContent =
"Select play on the audio controls to hear the assistant.";
});
});
microphone = await navigator.mediaDevices.getUserMedia({ audio: true });
for (const track of microphone.getAudioTracks()) {
connection.addTrack(track, microphone);
}
// Create the event channel before creating the SDP offer.
events = connection.createDataChannel("oai-events");
events.addEventListener("message", ({ data }) => {
const event = JSON.parse(data);
if (event.type === "session.started") {
ready = true;
stop.disabled = false;
status.textContent = "Connected: " + event.session.id;
} else if (event.type === "session.closed") {
finalized = true;
console.log("Final session usage", event.usage);
status.textContent = "Conversation ended.";
cleanup();
} else {
// Save transcript and nested Responses events as needed by your app.
console.log(event);
}
});
events.addEventListener("close", (event) => {
if (event.target !== events) return;
if (!finalized) {
status.textContent = "Disconnected without final session usage.";
cleanup();
}
});
const offer = await connection.createOffer();
await connection.setLocalDescription(offer);
if (connection.iceGatheringState !== "complete") {
await new Promise((resolve, reject) => {
const timeout = setTimeout(() => {
connection.removeEventListener("icegatheringstatechange", onState);
reject(new Error("Timed out while gathering ICE candidates"));
}, 10_000);
function onState() {
if (connection.iceGatheringState !== "complete") return;
clearTimeout(timeout);
connection.removeEventListener("icegatheringstatechange", onState);
resolve(undefined);
}
connection.addEventListener("icegatheringstatechange", onState);
onState();
});
}
const sdp = connection.localDescription?.sdp;
if (!sdp) throw new Error("Missing local SDP offer");
const response = await fetch("/api/session", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ sdp }),
});
if (!response.ok) throw new Error(await response.text());
const result = await response.json();
console.log("Created session", result.session.id);
await connection.setRemoteDescription({
type: "answer",
sdp: result.transport.sdp,
});
// The HTTP request started this session. Do not send session.start here.
} catch (error) {
status.textContent =
error instanceof Error ? error.message : String(error);
cleanup();
}
});
stop.addEventListener("click", () => {
if (!ready || !events || events.readyState !== "open") return;
stop.disabled = true;
status.textContent = "Finishing the conversation…";
// The session.closed handler is already registered. Keep media and events
// alive while pending work drains; only clean up after the final event.
events.send(JSON.stringify({ type: "session.close" }));
closeTimeout = setTimeout(() => {
status.textContent = "Incomplete finalization: no session.closed event.";
cleanup();
}, 15_000);
});Kompiliere browser.ts mit den folgenden Befehlen. Ersetze anschließend den Platzhalter im Modulskript durch den Inhalt der erzeugten Datei browser.js.
npm install --save-dev esbuild
npx esbuild browser.ts --format=esm --outfile=browser.jsStarte die gewählte Servervariante (node --experimental-strip-types server.ts oder python server.py), öffne http://localhost:3000 und wähle „Start conversation“. Sobald der Status „Connected“ erscheint, stelle eine Frage, für deren Beantwortung aktuelle Informationen nötig sind. So testest du die gehostete Websuche. Falls dein Browser die automatische Wiedergabe blockiert, starte sie über die Audiosteuerung.
Sitzungsantwort auslesen
Bei einer erfolgreichen Anfrage erhältst du den HTTP-Statuscode 201 und ein JSON-Objekt mit der Sitzungs-ID und der SDP-Antwort:
{
"session": { "id": "live_123" },
"transport": { "type": "webrtc", "sdp": "<SDP answer>" }
}Lies result.session.id aus und übergib result.transport.sdp an setRemoteDescription. Interpretiere die Bestandteile der Sitzungs-ID nicht und behalte die gesamte ID einschließlich ihres Präfixes unverändert bei.
Wie du die Latenz beim Verbindungsaufbau verringerst, erfährst du im Leitfaden WebRTC mit WARP.
Medien übertragen und Ereignisse verarbeiten
Sende das Mikrofonsignal und empfange die generierte Sprache über die Medienspuren. WebRTC handelt das Audioformat über SDP aus. Lass deshalb audio.format in der Sitzungskonfiguration weg. Sende session.input_audio.append nicht über den Datenkanal. Dort erhältst du auch keine Ereignisse vom Typ session.output_audio.delta.
Verwende den Datenkanal für inkrementelle Transkriptänderungen, Sitzungsbefehle und verschachtelte response.event-Nachrichten. Wie du Transkripte und Ereignisse im Lebenszyklus einer Sitzung verarbeitest, erfährst du im Leitfaden Sitzungen verwalten. Falls dein Server eine eigene Verbindung für Ereignisse benötigt, lies den Leitfaden Serverseitige Steuerung.
Sende zum Beenden des Gesprächs session.close und empfange weiterhin Ereignisse, bis session.closed eintrifft. Schließe erst dann die Peer-Verbindung und beende die Mikrofonspuren. Das Beispiel registriert den Listener für das Abschlussereignis, bevor es den Befehl sendet. Falls die Verbindung vorher abbricht oder das Zeitlimit überschritten wird, sind die endgültigen Nutzungsdaten unbestätigt. Wie du diese Daten verarbeitest, erfährst du im Abschnitt Nutzungsdaten erfassen und Sitzungen geordnet beenden.
WebRTC bietet leistungsfähige Standardschnittstellen für die Entwicklung von Echtzeitanwendungen. Mit der OpenAI Realtime API kannst du über eine WebRTC-Peer-Verbindung auf Realtime-Modelle zugreifen.
Für browserbasierte Speech-to-Speech-Anwendungen empfehlen wir als Einstieg den Leitfaden Sprachagenten. Er stellt die Hilfsfunktionen und APIs vor, mit denen das Agents SDK die Verwaltung von Realtime-Sitzungen vereinfacht. Die WebRTC-Schnittstelle ist leistungsfähig und flexibel, arbeitet aber auf einer niedrigeren Abstraktionsebene als das Agents SDK.
Wenn du von einem Client wie einem Webbrowser oder Mobilgerät aus eine Verbindung zu einem Realtime-Modell herstellst, empfehlen wir WebRTC anstelle von WebSockets. Damit erreichst du eine gleichmäßigere Leistung.
Weitere Hinweise zur Entwicklung von Benutzeroberflächen auf Basis von WebRTC findest du in der MDN-Dokumentation.
Überblick
Die Realtime API bietet zwei Möglichkeiten, eine Verbindung vom Browser aus herzustellen: die einheitliche Schnittstelle und kurzlebige API-Schlüssel (über die OpenAI REST API generiert). Mit der einheitlichen Schnittstelle vereinfachst du das Setup und beschleunigst den Verbindungsaufbau. Bei diesem Verfahren hängt die Initialisierung der Sitzung unmittelbar von deinem Anwendungsserver ab.
Verbindung über die einheitliche Schnittstelle herstellen
Wenn du einen Webbrowser als Client verwendest, läuft der Aufbau einer WebRTC-Verbindung über die einheitliche Schnittstelle so ab:
- Der Browser sendet eine Anfrage mit den SDP-Daten seiner WebRTC-Peer-Verbindung an einen Server, den du kontrollierst.
- Der Server führt die SDP-Daten und seine Sitzungskonfiguration in einem mehrteiligen Formular zusammen und sendet es an die OpenAI Realtime API. Er authentifiziert die Anfrage mit seinem Standard-API-Schlüssel.
Sitzung über die einheitliche Schnittstelle erstellen
Um über die einheitliche Schnittstelle eine Sitzung der Realtime API zu erstellen, brauchst du eine kleine serverseitige Anwendung, die eine Anfrage an /v1/realtime/calls sendet. Du kannst diese Funktion auch in eine bestehende Anwendung integrieren. Authentifiziere die Anfrage auf deinem Backend-Server mit einem Standard-API-Schlüssel.
Erstelle auf deinem Anwendungsserver eine Sitzung der Realtime API:
import express from "express";
const app = express();
// Parse raw SDP payloads posted from the browser
app.use(express.text({ type: ["application/sdp", "text/plain"] }));
const sessionConfig = JSON.stringify({
type: "realtime",
model: "gpt-realtime-2.1",
audio: { output: { voice: "marin" } },
});
// An endpoint which creates a Realtime API session.
app.post("/session", async (req, res) => {
const fd = new FormData();
fd.set("sdp", req.body);
fd.set("session", sessionConfig);
try {
const r = await fetch("https://api.openai.com/v1/realtime/calls", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
"OpenAI-Safety-Identifier": "hashed-user-id",
},
body: fd,
});
// Send back the SDP we received from the OpenAI REST API
const sdp = await r.text();
res.set(
"Content-Type",
r.ok ? "application/sdp" : (r.headers.get("Content-Type") ?? "text/plain")
);
const location = r.headers.get("Location");
if (location) res.set("Location", location);
res.status(r.status).send(sdp);
} catch (error) {
console.error("Session creation error:", error);
res.status(500).json({ error: "Failed to create session" });
}
});
app.listen(3000);Wenn deine Anwendung jeder Person, die sie nutzt, eine Sicherheitskennung zuweist, übermittle diese in der serverseitigen Anfrage im Header OpenAI-Safety-Identifier. Verwende einen stabilen Wert, der die Privatsphäre schützt, etwa den Hashwert einer internen Nutzer-ID. Setze den Header ausschließlich in deinem vertrauenswürdigen Backend.
Verbindung zum Server herstellen
Im Browser kannst du mit den standardisierten WebRTC-APIs über deinen Anwendungsserver eine Verbindung zur Realtime API herstellen. Der Client sendet seine SDP-Daten in einer POST-Anfrage an deinen Server.
// Create a peer connection
const pc = new RTCPeerConnection();
// Set up to play remote audio from the model
audioElement.current = document.createElement("audio");
audioElement.current.autoplay = true;
pc.ontrack = (e) => (audioElement.current.srcObject = e.streams[0]);
// Add local audio track for microphone input in the browser
const ms = await navigator.mediaDevices.getUserMedia({
audio: true,
});
pc.addTrack(ms.getTracks()[0]);
// Set up data channel for sending and receiving events
const dc = pc.createDataChannel("oai-events");
// Start the session using the Session Description Protocol (SDP)
const offer = await pc.createOffer();
await pc.setLocalDescription(offer);
const sdpResponse = await fetch("/session", {
method: "POST",
body: offer.sdp,
headers: {
"Content-Type": "application/sdp",
},
});
const answer = {
type: "answer",
sdp: await sdpResponse.text(),
};
await pc.setRemoteDescription(answer);Verbindung mit einem kurzlebigen Token herstellen
Wenn du einen Webbrowser als Client verwendest, läuft der Aufbau einer WebRTC-Verbindung mit einem kurzlebigen API-Schlüssel so ab:
- Der Browser fordert bei einem Server, den du kontrollierst, einen neuen kurzlebigen API-Schlüssel an.
- Dein Server fordert mit einem Standard-API-Schlüssel einen kurzlebigen Schlüssel von der OpenAI REST API an und gibt den neuen Schlüssel an den Browser zurück.
- Mit dem kurzlebigen Schlüssel authentifiziert der Browser die Sitzung direkt bei der OpenAI Realtime API und stellt eine WebRTC-Peer-Verbindung her.
Kurzlebiges Token erstellen
Um ein kurzlebiges Token für den Client zu erstellen, brauchst du eine kleine serverseitige Anwendung, die bei der OpenAI REST API einen kurzlebigen Schlüssel anfordert. Du kannst diese Funktion auch in eine bestehende Anwendung integrieren. Authentifiziere die Anfrage auf deinem Backend-Server mit einem Standard-API-Schlüssel.
Erstelle auf deinem Anwendungsserver mit der REST API einen kurzlebigen API-Schlüssel:
import express from "express";
const app = express();
const sessionConfig = JSON.stringify({
session: {
type: "realtime",
model: "gpt-realtime-2.1",
audio: {
output: {
voice: "marin",
},
},
},
});
// An endpoint which would work with the client code above - it returns
// the contents of a REST API request to this protected endpoint
app.get("/token", async (req, res) => {
res.set("Cache-Control", "no-store");
try {
const response = await fetch(
"https://api.openai.com/v1/realtime/client_secrets",
{
method: "POST",
headers: {
Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
"Content-Type": "application/json",
"OpenAI-Safety-Identifier": "hashed-user-id",
},
body: sessionConfig,
}
);
const data = await response.json();
res.status(response.status).json(data);
} catch (error) {
console.error("Token generation error:", error);
res.status(500).json({ error: "Failed to generate token" });
}
});
app.listen(3000);Einen solchen Serverendpunkt kannst du auf jeder Plattform erstellen, die HTTP-Anfragen senden und empfangen kann. Verwende Standard-API-Schlüssel von OpenAI ausschließlich auf dem Server, niemals im Browser.
Wenn du kurzlebige Token verwendest, setze OpenAI-Safety-Identifier in der serverseitigen Anfrage, die das Client-Secret erstellt. Die Realtime API bindet die Kennung an das erzeugte Token. Wenn der Browser später mit diesem Token die Verbindung herstellt, braucht er die Sicherheitskennung daher nicht zu senden.
Verbindung zum Server herstellen
Im Browser kannst du mit den standardisierten WebRTC-APIs und einem kurzlebigen Token eine Verbindung zur Realtime API herstellen. Der Client ruft zuerst ein Token von deinem Serverendpunkt ab. Anschließend sendet er seine SDP-Daten zusammen mit dem Token in einer POST-Anfrage an die Realtime API.
// Get a session token for OpenAI Realtime API
const tokenResponse = await fetch("/token");
const data = await tokenResponse.json();
const EPHEMERAL_KEY = data.value;
// Create a peer connection
const pc = new RTCPeerConnection();
// Set up to play remote audio from the model
audioElement.current = document.createElement("audio");
audioElement.current.autoplay = true;
pc.ontrack = (e) => (audioElement.current.srcObject = e.streams[0]);
// Add local audio track for microphone input in the browser
const ms = await navigator.mediaDevices.getUserMedia({
audio: true,
});
pc.addTrack(ms.getTracks()[0]);
// Set up data channel for sending and receiving events
const dc = pc.createDataChannel("oai-events");
// Start the session using the Session Description Protocol (SDP)
const offer = await pc.createOffer();
await pc.setLocalDescription(offer);
const sdpResponse = await fetch("https://api.openai.com/v1/realtime/calls", {
method: "POST",
body: offer.sdp,
headers: {
Authorization: `Bearer ${EPHEMERAL_KEY}`,
"Content-Type": "application/sdp",
},
});
const answer = {
type: "answer",
sdp: await sdpResponse.text(),
};
await pc.setRemoteDescription(answer);Verbindungslatenz mit WARP verringern
Das WebRTC Abridged Roundtrip Protocol (WARP) verkürzt die Zeit, die eine Sprachsitzung der Realtime API zum Starten braucht. Du kannst die Optimierungen einzeln aktivieren oder sie für den vollständigen WARP-Handshake kombinieren.
Im Leitfaden WebRTC mit WARP erfährst du, wie du native Clients einrichtest, welche Browser WARP unterstützen, wie du am Origin Trial teilnimmst und wie der Verbindungsaufbau über die einheitliche Schnittstelle abläuft.
Ereignisse senden und empfangen
Zur Verwaltung von Sitzungen der Realtime API dienen clientseitige Ereignisse, die dein Client sendet, und serverseitige Ereignisse, mit denen die Realtime API über den Lebenszyklus der Sitzung informiert.
Wenn du über WebRTC eine Verbindung zu einem Realtime-Modell herstellst, brauchst du die Audioereignisse des Modells nicht so detailliert zu verarbeiten wie bei WebSockets. Das übernimmt das Objekt für die WebRTC-Peer-Verbindung, sofern du es wie oben beschrieben konfigurierst.
Für das Senden und Empfangen anderer Client- und Serverereignisse kannst du den Datenkanal der WebRTC-Peer-Verbindung verwenden.
// Reuse dc from the preceding browser connection example.
// Listen for server events
dc.addEventListener("message", (e) => {
const event = JSON.parse(e.data);
console.log(event);
});
// Send client events
const event = {
type: "conversation.item.create",
item: {
type: "message",
role: "user",
content: [
{
type: "input_text",
text: "hello there!",
},
],
},
};
const sendGreeting = () => dc.send(JSON.stringify(event));
if (dc.readyState === "open") {
sendGreeting();
} else if (dc.readyState === "connecting") {
dc.addEventListener("open", sendGreeting, { once: true });
} else {
throw new Error("The data channel has closed before greeting was sent.");
}Mehr zur Verwaltung von Realtime-Gesprächen erfährst du im Leitfaden zu Realtime-Gesprächen.
Probiere die Realtime API mit WebRTC in dieser schlanken Beispiel-App aus.