GPT Translator Logo
Live & Streaming

Echtzeit-Übersetzungs-API

Fügen Sie jeder Anwendung in wenigen Minuten Live-Sprach-zu-Sprach-Übersetzung hinzu. Streamen Sie Audio hinein und erhalten Sie übersetztes Audio sowie Transkripte zurück — alles über eine einzige WebSocket-Verbindung.

Warum die Echtzeit-Übersetzungs-API?

Entwickelt für Anwendungen, die sofortige und kontinuierliche Übersetzung benötigen. Eine einzige dauerhafte Verbindung verwaltet die gesamte Sitzung — kein Polling, keine Verzögerungen, keine Komplexität.

Ultra-niedrige Latenz

Streaming-Audio wird in Echtzeit übersetzt und zurückgegeben. Keine Request-Response-Rundläufe — Ergebnisse erscheinen, während der Sprecher spricht.

Audio rein, Audio raus

Senden Sie rohes Mikrofon-Audio und erhalten Sie übersetzte Sprache zurück. Sowohl Eingabe- als auch Ausgabe-Transkripte werden ebenfalls gestreamt, sodass Sie Live-Untertitel anzeigen können.

130+ Sprachen

Übersetzen Sie in jede wichtige Sprache mithilfe standardisierter BCP-47-Sprachcodes. Wechseln Sie die Zielsprache zwischen Sitzungen ohne Änderungen am SDK.

Standardmäßig sicher

Jede Verbindung wird mit Ihrem JWT-Token authentifiziert. Sitzungen sind pro Benutzer isoliert — Ihre Audiodaten werden niemals geteilt oder gespeichert.

Erste Schritte

Verbinden & Authentifizieren

Die Echtzeit-Übersetzungs-API läuft über einen dedizierten Socket.IO-Namespace. Übergeben Sie Ihren API-Schlüssel als Query-Parameter beim Aufbau der Verbindung — der Server validiert ihn, bevor eine Sitzung beginnen kann.

Endpunkt
wss://api.gpttranslator.co
  └── namespace: /api/realtime-translator
JavaScript — Socket.IO
import { io } from 'socket.io-client';

// Connect to the Realtime Translation namespace
const socket = io('https://api.gpttranslator.co/api/realtime-translator', {
  transports: ['websocket'],
  query: {
    apiKey: 'YOUR_API_KEY'  // your GPT Translator API key
  },
});

Hinweis: Erhalten Sie Ihren API-Schlüssel im GPT Translator-Dashboard unter API-Schlüssel. Verbindungen ohne gültigen API-Schlüssel werden sofort abgelehnt.

Geben Sie Ihren API-Schlüssel niemals im clientseitigen Code preis

Das obige Codebeispiel dient nur zur Veranschaulichung. Wenn Sie Ihren API-Schlüssel direkt in Browser-JavaScript einbetten, kann ihn jeder sehen, der den Seitenquelltext oder den Netzwerkverkehr überprüft — und Ihren Schlüssel verwenden, um Ihr Token-Guthaben aufzubrauchen.

Empfohlen: Proxy über Ihr eigenes Backend

Ihr Server speichert den API-Schlüssel sicher und stellt die Socket.IO-Verbindung im Namen des Browsers her. Der Browser verbindet sich mit Ihrem Server, niemals direkt mit der Übersetzungs-API.

Node.js backend (server-side)
// Your backend holds the key — the browser never sees it
const socket = io('https://api.gpttranslator.co/api/realtime-translator', {
  transports: ['websocket'],
  query: { apiKey: process.env.GPT_TRANSLATOR_API_KEY },
});

// Proxy events between the browser client and the translation API
browserSocket.on('translation_start', (data) => socket.emit('translation_start', data));
browserSocket.on('audio_chunk', (chunk) => socket.emit('audio_chunk', chunk));
browserSocket.on('translation_stop', () => socket.emit('translation_stop'));

socket.on('output_audio', (data) => browserSocket.emit('output_audio', data));
socket.on('output_transcript', (data) => browserSocket.emit('output_transcript', data));
socket.on('input_transcript', (data) => browserSocket.emit('input_transcript', data));
Sitzungsablauf

Sitzungslebenszyklus

Jede Übersetzungssitzung folgt einer einfachen fünfstufigen Sequenz. Das Verständnis dieser Reihenfolge hilft Ihnen, eine robuste Integration zu erstellen.

1

Sitzung starten

Sie senden

Senden Sie translation_start mit dem Zielsprachcode. Der Server reserviert Ihr Token-Guthaben und beginnt mit der Initialisierung der Sitzung.

socket.emit('translation_start', { "targetLanguage": "es" });
2

Auf Bereitschaftssignale warten

Sie empfangen

Der Server sendet drei Statusereignisse in dieser Reihenfolge: session_initializing, translation_ready und schließlich ready_for_audio. Beginnen Sie erst nach ready_for_audio mit dem Senden von Audio.

socket.on('session_initializing', callback);
socket.on('translation_ready', callback);
socket.on('ready_for_audio', callback);
3

Audio-Chunks streamen

Sie senden

Senden Sie kontinuierlich audio_chunk-Ereignisse mit base64-kodiertem PCM16-Audio, das vom Mikrofon aufgenommen wurde. Halten Sie die Chunks klein (etwa 100 ms), um die geringste Latenz zu erreichen.

socket.emit('audio_chunk', { "audioData": "<base64-pcm16-string>" });
4

Übersetzte Ausgabe empfangen

Sie empfangen

Während der Übersetzung streamt der Server output_audio (übersetzte Sprache), output_transcript (übersetzter Text) und input_transcript (erkannter Ausgangstext) — alles als inkrementelle Deltas.

socket.on('output_audio', callback);
socket.on('output_transcript', callback);
socket.on('input_transcript', callback);
5

Sitzung beenden

Sie senden

Senden Sie translation_stop, um die Sitzung ordnungsgemäß zu schließen. Die Token-Nutzung wird abgeschlossen und ein translation_closed-Ereignis bestätigt das Sitzungsende.

socket.emit('translation_stop');
API-Referenz

Ereignisreferenz

Eine vollständige Referenz aller Ereignisse der Echtzeit-Übersetzungs-API — was Sie senden und was Sie empfangen.

Ereignisse, die Sie senden

Sie senden
translation_start

Startet eine neue Übersetzungssitzung. Übergeben Sie den BCP-47-Sprachcode für die Zielsprache.

{
  "targetLanguage": "es"  // BCP-47 language code (e.g. "fr", "de", "zh", "ja")
}
audio_chunk

Sendet einen Chunk von rohem Mikrofon-Audio. Das Feld audioData muss ein base64-kodierter PCM16-Mono-Audiopuffer mit einer Abtastrate von 24.000 Hz sein.

{
  "audioData": "<base64-encoded PCM16 mono audio>"
  // Sample rate: 24 000 Hz
  // Encoding: 16-bit PCM, little-endian
  // Send continuously while the user speaks
}
translation_stop

Beendet die Sitzung ordnungsgemäß. Der Server finalisiert die Abrechnung und sendet translation_closed.

Ereignisse, die Sie empfangen

Sie empfangen
session_initializingstatus

Wird unmittelbar nach translation_start gesendet. Zeigt an, dass die Sitzung eingerichtet wird — Audio ist noch nicht bereit.

translation_readystatus

Wird gesendet, sobald die serverseitige Verbindung hergestellt wurde. Die endgültige Sitzungsaktivierung steht noch aus.

ready_for_audiostatus

Die Sitzung ist vollständig aktiv. Beginnen Sie jetzt mit dem Streamen von audio_chunk-Ereignissen.

output_audiostream

Ein Chunk übersetzter Sprachaudio. Das Delta ist ein base64-kodierter PCM16-Audiopuffer. Puffern Sie aufeinanderfolgende Deltas und spielen Sie sie in der richtigen Reihenfolge ab.

{
  "delta": "<base64-encoded PCM16 audio chunk>"
  // Decoded and played directly to the output speaker
  // Arrives incrementally — buffer chunks for smooth playback
}
output_transcriptstream

Ein Fragment des übersetzten Textes. Fügen Sie die Deltas zusammen, um das vollständige übersetzte Transkript in Ihrer Benutzeroberfläche zu erstellen.

{
  "delta": "Hola, ¿cómo estás?"  // translated text fragment
}
input_transcriptstream

Ein Fragment der erkannten Ausgangssprache. Fügen Sie die Deltas zusammen, um die Untertitel der Ausgangssprache zu erstellen.

{
  "delta": "Hello, how are you?"  // recognized source speech fragment
}
translation_closedstatus

Bestätigt, dass die Sitzung sauber beendet wurde — entweder nach translation_stop oder wenn der Server die Sitzung wegen aufgebrauchter Tokens schließt.

translation_errorerror

Ein unerwarteter Fehler ist aufgetreten. Das Feld message erklärt, was schiefgelaufen ist. Die Sitzung kann weiterhin aktiv sein — Sie können erneut versuchen oder translation_stop aufrufen.

{
  "message": "Translation session error. Please try again."
}
insufficient_tokenserror

Ihr Token-Guthaben ist aufgebraucht. Die Sitzung wird automatisch geschlossen. Aktualisieren Sie Ihren Tarif, um fortzufahren.

{
  "message": "You have reached the limit of words for translation...",
  "remainingTokens": 0
}
Codebeispiel

Vollständiges Integrationsbeispiel

Ein minimales, aber vollständiges JavaScript-Beispiel, das zeigt, wie man sich verbindet, eine Sitzung startet, Audio streamt, alle Serverereignisse verarbeitet und die Sitzung sauber beendet.

realtime-translator.js
import { io } from 'socket.io-client';

const socket = io('https://api.gpttranslator.co/api/realtime-translator', {
  transports: ['websocket'],
  query: { apiKey: 'YOUR_API_KEY' },
});

// ─── Listen for server events ───────────────────────────────────────

socket.on('session_initializing', () => {
  console.log('Session is being prepared...');
});

socket.on('translation_ready', () => {
  console.log('Session connected. Waiting for activation...');
});

socket.on('ready_for_audio', () => {
  console.log('Ready! Start streaming audio chunks now.');
  startMicrophone(); // begin capturing and sending audio
});

socket.on('output_audio', ({ delta }) => {
  // delta is a base64-encoded PCM16 audio chunk
  playAudioChunk(atob(delta));
});

socket.on('output_transcript', ({ delta }) => {
  // Append translated text delta to your UI
  appendToTranscript('translated', delta);
});

socket.on('input_transcript', ({ delta }) => {
  // Append recognized source speech to your UI
  appendToTranscript('original', delta);
});

socket.on('translation_closed', () => {
  console.log('Session ended.');
  stopMicrophone();
});

socket.on('translation_error', ({ message }) => {
  console.error('Error:', message);
  stopMicrophone();
});

socket.on('insufficient_tokens', ({ message, remainingTokens }) => {
  console.warn('Out of tokens:', message, 'remaining:', remainingTokens);
  stopMicrophone();
  showUpgradePrompt();
});

// ─── Start a session ────────────────────────────────────────────────

socket.emit('translation_start', { targetLanguage: 'es' });

// ─── Stream audio chunks ────────────────────────────────────────────

function onAudioData(pcm16Base64) {
  socket.emit('audio_chunk', { audioData: pcm16Base64 });
}

// ─── Stop the session ───────────────────────────────────────────────

function stopSession() {
  socket.emit('translation_stop');
}
Abrechnung

So funktioniert die Abrechnung

Echtzeitübersetzung wird nach Sitzungsdauer abgerechnet — also der Zeit zwischen Sitzungsaktivierung und translation_stop oder Token-Erschöpfung. Keine Berechnung pro Zeichen oder Wort.

Sekundengenaue Abrechnung

Die Nutzung wird in Sekunden gemessen, vom Zeitpunkt der vollständigen Aktivierung der Sitzung bis zu ihrem Ende. Angebrochene Sekunden werden aufgerundet.

📊

Tokens werden live abgezogen

Tokens werden am Ende jeder Sitzung basierend auf der tatsächlichen Dauer von Ihrem Guthaben abgezogen. Ihr verfügbares Guthaben wird überprüft, bevor eine Sitzung starten kann.

🔒

Automatische Begrenzung

Die Sitzung wird automatisch beendet, wenn Ihr verbleibendes Token-Guthaben aufgebraucht wäre. Sie erhalten ein insufficient_tokens-Ereignis, bevor die Sitzung geschlossen wird.

Geschätzter Tokenverbrauch

1 Minute
~3.000 Tokens
Gut für schnelle Prüfungen
5 Minuten
~15.000 Tokens
Kurzes Meeting oder Interview
30 Minuten
~90.000 Tokens
Längeres Gespräch
1 Stunde
~180.000 Tokens
Konferenz oder Vorlesung
Sitzungsdauer
Ca. verwendete Tokens
Hinweise

Hinweis: Die Token-Schätzungen sind ungefähr. Der tatsächliche Verbrauch hängt von Geräuschpegeln und der Sitzungsaktivität ab. Prüfen Sie Ihr Dashboard für die Echtzeitnutzung.

Audio-Leitfaden

Anforderungen an das Audioformat

Die API erwartet ein bestimmtes Audioformat für beste Genauigkeit und geringste Latenz. Verwenden Sie den untenstehenden Codeausschnitt, um Mikrofon-Audio im Browser aufzunehmen und zu konvertieren.

FormatPCM 16-bit, little-endian
Abtastrate24 000 Hz
Kanäle1 (Mono)
ÜbertragungskodierungBase64 string
Browser-Mikrofonaufnahme
// Capture PCM16 audio from the browser microphone
const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
const audioContext = new AudioContext({ sampleRate: 24000 });
const source = audioContext.createMediaStreamSource(stream);
const processor = audioContext.createScriptProcessor(4096, 1, 1);

processor.onaudioprocess = (e) => {
  const float32 = e.inputBuffer.getChannelData(0);

  // Convert Float32 → Int16 PCM
  const int16 = new Int16Array(float32.length);
  for (let i = 0; i < float32.length; i++) {
    int16[i] = Math.max(-32768, Math.min(32767, float32[i] * 32768));
  }

  // Base64-encode and send
  const base64 = btoa(String.fromCharCode(...new Uint8Array(int16.buffer)));
  socket.emit('audio_chunk', { audioData: base64 });
};

source.connect(processor);
processor.connect(audioContext.destination);

Häufig gestellte Fragen

Häufige Fragen zur Integration und Nutzung der Echtzeit-Übersetzungs-API.