Bei der Echtzeitübersetzung streamst du das Originalaudio in eine eigene Übersetzungssitzung. Noch während die Person spricht, erhältst du die Übersetzung als Audio und das zugehörige Transkript in einzelnen Abschnitten. Das eignet sich zum Live-Dolmetschen, für mehrsprachige Anrufe, Übertragungen, Besprechungen, Unterricht und Videoräume.
Verwende gpt-realtime-translate, wenn deine Anwendung übersetzen soll, was jemand sagt. Wenn du einen Assistenten brauchst, der Fragen beantwortet, Tools aufruft und ein Gespräch führt, verwende stattdessen gpt-realtime-2.1 mit einer regulären Realtime-Sitzung.
Was Übersetzungssitzungen unterscheidet
Realtime-Übersetzungssitzungen haben eine andere Architektur als Sitzungen mit Sprachagenten.
| Sitzung mit einem Sprachagenten | Übersetzungssitzung |
|---|---|
Verbindet sich mit /v1/realtime. |
Verbindet sich mit /v1/realtime/translations. |
| Das Modell übernimmt die Rolle eines Assistenten. | Das Modell dolmetscht. |
| Verwaltet den Gesprächsverlauf und den Lebenszyklus einzelner Antworten. | Übersetzt eingehende Audiodaten fortlaufend und streamt die Ausgabe. |
| Kann Tools aufrufen und eigene Gesprächsbeiträge erzeugen. | Gibt die Übersetzung als Audio und in fortlaufenden Transkriptabschnitten aus. |
Du kannst response.create aufrufen. |
Du rufst response.create nicht auf. |
Die Übersetzung beginnt, sobald Audiodaten im Stream eintreffen. Hänge fortlaufend Audiodaten an, auch während der Sprechpausen, und verarbeite Ausgabeereignisse, sobald sie eintreffen.
Transportprotokoll auswählen
Verwende WebRTC, wenn der Browser Audio aufnimmt oder wiedergibt. WebRTC sendet das Originalaudio als Medienspur und empfängt die übersetzte Sprache als Audiospur der Gegenstelle. So musst du PCM-Blöcke weder selbst auf eine andere Abtastrate umrechnen noch manuell abspielen.
Verwende WebSockets, wenn dein Server bereits rohe Audiodaten empfängt, etwa von Twilio Media Streams, einer SIP-Medienverbindung, einer Rundfunkzuspielung oder einem Media-Worker. Bei WebSockets sendest du Base64-kodierte PCM16-Audiodaten mit 24 kHz und spielst die zurückgegebenen Audioblöcke selbst ab.
WebRTC-Sitzung im Browser erstellen
Erstelle für Browser-Apps auf deinem Server ein kurzzeitig gültiges Client-Secret. Gib deinen regulären API-Schlüssel niemals im Browser preis.
app.post("/session", async (req, res) => {
const language = req.body.targetLanguage ?? "es";
const response = await fetch(
"https://api.openai.com/v1/realtime/translations/client_secrets",
{
method: "POST",
headers: {
Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
"Content-Type": "application/json",
"OpenAI-Safety-Identifier": "hashed-user-id",
},
body: JSON.stringify({
session: {
model: "gpt-realtime-translate",
audio: {
output: { language },
},
},
}),
}
);
res.status(response.status).json(await response.json());
});Nimm im Browser Audio auf, erstelle eine Peer-Verbindung und sende das SDP-Angebot per POST an den Endpunkt für Übersetzungsanrufe.
const { value: clientSecret } = await fetch("/session", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ targetLanguage: "es" }),
}).then((response) => response.json());
const sourceStream = await navigator.mediaDevices.getUserMedia({
audio: true,
});
const pc = new RTCPeerConnection();
pc.addTrack(sourceStream.getAudioTracks()[0], sourceStream);
const translatedAudio = new Audio();
translatedAudio.autoplay = true;
pc.ontrack = ({ streams }) => {
translatedAudio.srcObject = streams[0];
};
const events = pc.createDataChannel("oai-events");
events.onmessage = ({ data }) => {
const event = JSON.parse(data);
if (event.type === "session.output_transcript.delta") {
subtitles.textContent += event.delta;
}
};
const offer = await pc.createOffer();
await pc.setLocalDescription(offer);
const sdpResponse = await fetch(
"https://api.openai.com/v1/realtime/translations/calls",
{
method: "POST",
headers: {
Authorization: `Bearer ${clientSecret}`,
"Content-Type": "application/sdp",
},
body: offer.sdp,
}
);
if (!sdpResponse.ok) {
throw new Error(await sdpResponse.text());
}
await pc.setRemoteDescription({
type: "answer",
sdp: await sdpResponse.text(),
});WebSocket-Sitzung erstellen
Stelle eine Verbindung zum Endpunkt für Übersetzungen her und gib das Modell in der URL an.
Installiere vor dem Ausführen dieses Beispiels ws für Node.js, websocket-client und sounddevice für Python oder async-websocket für Ruby (gem install async-websocket). Füge für Java die Maven-Abhängigkeit com.openai:openai-java:4.75.1 hinzu.
Die Java-Beispiele zeigen den Verbindungsaufbau, die Sprachkonfiguration und die Audioeingabe jeweils separat. Sie decken den Übersetzungsablauf nur teilweise ab. Das Java-SDK unterstützt auch den Empfang von Ereignissen und das Beenden einer Sitzung. Für diese Schritte enthält dieser Leitfaden allerdings keine Java-Beispiele. Den vollständigen Ablauf kannst du unten anhand der Beispiele für Node.js oder Python nachvollziehen.
import WebSocket from "ws";
const ws = new WebSocket(
"wss://api.openai.com/v1/realtime/translations?model=gpt-realtime-translate",
{
headers: {
Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
"OpenAI-Safety-Identifier": "hashed-user-id",
},
}
);Füge in Ruby die folgenden Codeausschnitte zur Konfiguration und zum Anhängen von Audiodaten in den Block Async::WebSocket::Client.connect ein. Platziere sie nach der Prüfung, ob die Sitzung erstellt wurde, und vor dem Ende des Blocks. Halte die Verbindung offen, während du Audiodaten sendest und Übersetzungsereignisse empfängst.
Im Java-Beispiel zum Verbindungsaufbau wird der Socket am Ende des try-Blocks geschlossen. Die Java-Beispiele zur Konfiguration und Audioeingabe setzen eine offene TranslationConnection voraus. Halte die Verbindung offen, während du Audiodaten sendest und die Ausgabe empfängst. Beende die Sitzung und lies alle verbleibenden Ereignisse bis einschließlich session.closed, bevor du den Block verlässt. Wie das geht, erfährst du im Abschnitt WebSocket-Sitzung schließen.
Lege die Zielsprache fest, sobald der Socket geöffnet ist.
ws.on("open", () => {
ws.send(
JSON.stringify({
type: "session.update",
session: {
audio: {
output: {
language: "es",
},
},
},
})
);
});Hänge anschließend fortlaufend Audiodaten an.
ws.send(
JSON.stringify({
type: "session.input_audio_buffer.append",
audio: base64Pcm16,
})
);Empfange die übersetzten Audiodaten und Transkripte.
ws.on("message", (data) => {
const event = JSON.parse(data.toString());
if (event.type === "session.output_audio.delta") {
playPcm16(event.delta);
}
if (event.type === "session.output_transcript.delta") {
process.stdout.write(event.delta);
}
if (event.type === "session.input_transcript.delta") {
updateSourceTranscript(event.delta);
}
});Führe in Go listen parallel zum Senden der Audiodaten aus. Die Funktion schließt die Transportverbindung, nachdem sie session.closed empfangen hat.
WebSocket-Sitzung schließen
Wenn dein Eingabestream endet, sende ein session.close-Ereignis, bevor du den WebSocket schließt. Damit weist du den Dienst an, die noch ausstehenden Eingabeaudiodaten zu verarbeiten, die restlichen übersetzten Audiodaten und Transkriptabschnitte auszugeben und anschließend ein session.closed-Ereignis zu senden. Nur Übersetzungssitzungen unterstützen das Ereignis session.close.
Sobald du session.close gesendet hast, hänge keine weiteren Audiodaten an. Lies in deiner regulären Empfangsschleife weiter Ereignisse, bis session.closed eintrifft. Wenn du den Socket sofort schließt, kann ein Teil der Übersetzung verloren gehen, den die Sitzung noch ausgibt.
let translationSessionClosing = false;
let gotTranslationClosed = false;
let drainDeadline: ReturnType<typeof setTimeout> | undefined;
ws.on("close", () => {
clearTimeout(drainDeadline);
if (!gotTranslationClosed) {
console.error("Translation disconnected before final session.closed");
process.exitCode = 1;
}
});
function closeTranslationSession() {
if (translationSessionClosing) {
return;
}
translationSessionClosing = true;
// Adjust this deadline for your application's finalization requirements.
drainDeadline = setTimeout(() => {
console.error("Translation finalization timed out");
process.exitCode = 1;
ws.close();
}, 15_000);
ws.send(JSON.stringify({ type: "session.close" }));
}
// Use this in place of the earlier output handler, so audio plays only once.
ws.on("message", (data) => {
const event = JSON.parse(data.toString());
if (event.type === "session.output_audio.delta") {
playPcm16(event.delta);
}
if (event.type === "session.output_transcript.delta") {
process.stdout.write(event.delta);
}
if (event.type === "session.input_transcript.delta") {
updateSourceTranscript(event.delta);
}
if (event.type === "error") {
clearTimeout(drainDeadline);
console.error("Translation error", event.error?.code);
process.exitCode = 1;
ws.close();
}
if (event.type === "session.closed") {
clearTimeout(drainDeadline);
gotTranslationClosed = true;
ws.close();
}
});
// Call this when the source stream ends.
closeTranslationSession();Live-Übersetzung für ein Publikum entwickeln
Nutze diese Form der Übersetzung, wenn ein Publikum einer einzelnen Person oder einem Audiostream in einer anderen Sprache zuhören soll. Beispiele sind Livestreams, Konferenzvorträge, Webinare, Telefonkonferenzen zu Geschäftszahlen, Vorlesungen und Videos.
Der typische Ablauf sieht so aus.
source audio -> translation session -> translated audio + subtitles
Erstelle für jede Zielsprache eine eigene Übersetzungssitzung. Wenn du denselben englischen Audiostream auf Spanisch und Französisch ausgeben möchtest, erstelle eine Sitzung für die Übersetzung vom Englischen ins Spanische und eine zweite für die Übersetzung vom Englischen ins Französische.
Nimm in Browser-Apps für diese Art der Live-Übersetzung das Audio eines Tabs mit getDisplayMedia() auf, sende es über WebRTC und spiele die übersetzte Audiospur der Gegenstelle ab. Führe die Übersetzung bei Übertragungen im Produktivbetrieb in einem serverseitigen Media-Worker aus und stelle dem Publikum die übersetzten Audiospuren oder Untertitel bereit.
Gesprächsübersetzung entwickeln
Nutze die Gesprächsübersetzung, wenn zwei oder mehr Personen in unterschiedlichen Sprachen miteinander sprechen. Beispiele sind Support- und Vertriebsgespräche, Nachhilfe und Videoräume.
Halte die Audiospuren der einzelnen Personen getrennt. Wenn du mehrere Stimmen in einem Stream mischst, wird es schwieriger, die jeweils sprechende Person zu erkennen, ihr die passenden Untertitel zuzuordnen und gleichzeitig gesprochene Beiträge zu verarbeiten.
Erstelle für ein Gespräch zwischen zwei Personen eine Übersetzungssitzung pro Richtung.
Caller A audio -> translate into Caller B language -> play to Caller B
Caller B audio -> translate into Caller A language -> play to Caller A
In Gruppenräumen hängt die Anzahl der Sitzungen davon ab, wie viele Personen gerade sprechen und wie viele Zielsprachen benötigt werden.
translation sessions ~= active source speaker tracks x distinct target languages
In kleinen Räumen kann jede zuhörende Person im eigenen Browser Übersetzungs-Sidecars für die Gesprächsbeiträge derjenigen erstellen, die sie übersetzt hören möchte. Verwende in größeren Räumen einen serverseitigen Client, der am Gespräch teilnimmt, oder einen Media-Worker. Der Client oder Worker abonniert die Audiospur jeder sprechenden Person einmal, erstellt für jede Zielsprache eine Übersetzungssitzung und stellt die übersetzten Spuren wieder im Raum bereit.
Qualität und Latenz testen
Teste die Übersetzung mit echten Audioaufnahmen und lass sie von Personen prüfen, die beide Sprachen beherrschen. Automatisierte Metriken können helfen, erfassen aber nicht jeden Fehler, der bei der Nutzung auffällt.
Prüfe folgende Punkte.
- Übersetzungsqualität für das jeweilige Sprachenpaar
- Wiedergabe von Namen, Zahlen, Datumsangaben, Währungsangaben und Telefonnummern
- Übersetzung von Fachbegriffen
- Sprachwechsel und Gespräche, in denen sich mehrere Sprachen mischen
- Umgang mit Akzenten, hohem Sprechtempo und gleichzeitig gesprochenen Beiträgen
- Zeit bis zur ersten übersetzten Audioausgabe
- Verzögerung nach dem Ende einer Äußerung
- zeitliche Abstimmung der Untertitel
- Einheitlichkeit der Stimme
- Verhalten beim Wiederherstellen der Verbindung
Wenn es in deinem Anwendungsfall auf die exakte Wiedergabe von Namen oder Fachbegriffen ankommt, erstelle vor dem Start einen Referenzdatensatz und prüfe Fehler manuell.
Checkliste für den Produktivbetrieb
- Verwende WebRTC für die Audioübertragung im Browser und WebSockets für die Audioübertragung auf dem Server.
- Nutze den eigens für Übersetzungen vorgesehenen Endpunkt
/v1/realtime/translations. - Streame die Audiodaten kontinuierlich, auch während der Sprechpausen.
- Sende
session.closeund warte aufsession.closed, bevor du eine WebSocket-Sitzung schließt. - Halte bei der Gesprächsübersetzung die Audiospuren der einzelnen Personen getrennt.
- Verwende eine Sitzung pro Ausgabesprache.
- Zeige bei Bedarf sowohl das Transkript in der Ausgangssprache als auch das in der Zielsprache an.
- Biete Bedienelemente für Originalaudio, übersetztes Audio, Untertitel, Stummschaltung und Lautstärke an.
- Zeige an, wenn die Verbindung wiederhergestellt wird, sich die Übersetzung verzögert oder der Dienst nicht verfügbar ist.
- Erfasse die Latenz getrennt von der Übersetzungsqualität.
Weiterführende Leitfäden
Vergleiche Sitzungen mit Sprachagenten, Übersetzungssitzungen und Transkriptionssitzungen.
Verbinde Medienstreams aus dem Browser mit einer Realtime-Sitzung.
Streame rohe Audiodaten über eine serverseitige Medienpipeline.
Empfange fortlaufend neue Transkriptabschnitte aus einem Live-Audiostream.