GPT Translator Logo
Live & Streaming

Realtime Vertaal-API

Voeg binnen enkele minuten live spraak-naar-spraakvertaling toe aan elke applicatie. Stream audio in en ontvang vertaalde audio en transcripties terug — allemaal via één enkele WebSocket-verbinding.

Waarom de Realtime Vertaal-API?

Gebouwd voor applicaties die directe en continue vertaling nodig hebben. Eén persistente verbinding beheert de volledige sessie — geen polling, geen vertragingen en geen complexiteit.

Ultralage Latentie

Streaming audio wordt in realtime vertaald en teruggestuurd. Geen request-response rondreizen — resultaten arriveren terwijl de spreker praat.

Audio In, Audio Uit

Verstuur ruwe microfoonaudio en ontvang vertaalde spraak terug. Zowel invoer- als uitvoertranscripties worden ook gestreamd zodat je live ondertitels kunt tonen.

130+ Talen

Vertaal naar elke belangrijke taal met standaard BCP-47-taalcodes. Wissel van doeltaal tussen sessies zonder wijzigingen aan de SDK.

Standaard Veilig

Elke verbinding wordt geauthenticeerd met je JWT-token. Sessies zijn per gebruiker geïsoleerd — je audio wordt nooit gedeeld of opgeslagen.

Aan de slag

Verbinden & Authenticeren

De Realtime Vertaal-API draait op een speciale Socket.IO-namespace. Geef je API-sleutel mee als queryparameter bij het maken van de verbinding — de server valideert deze voordat een sessie kan beginnen.

Endpoint
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
  },
});

Opmerking: Verkrijg je API-sleutel via het GPT Translator-dashboard onder API Keys. Verbindingen zonder geldige API-sleutel worden onmiddellijk geweigerd.

Stel je API-sleutel nooit bloot in client-side code

Het bovenstaande codevoorbeeld is alleen bedoeld ter illustratie. Door je API-sleutel rechtstreeks in browser-JavaScript op te nemen, wordt deze zichtbaar voor iedereen die de broncode van je pagina of het netwerkverkeer inspecteert — iedereen kan dan je sleutel gebruiken en je tokensaldo opgebruiken.

Aanbevolen: gebruik een proxy via je eigen backend

Je server bewaart de API-sleutel veilig en opent de Socket.IO-verbinding namens de browser. De browser maakt verbinding met jouw server, nooit rechtstreeks met de vertaal-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));
Sessieverloop

Sessielevenscyclus

Elke vertaalsessie volgt een eenvoudige reeks van vijf stappen. Door deze volgorde te begrijpen kun je een robuuste integratie bouwen.

1

Start een sessie

jij verzendt

Verzend translation_start met de doeltaalcode. De server reserveert je tokensaldo en begint met het initialiseren van de sessie.

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

Wacht op gereedheidssignalen

jij luistert

De server verzendt drie statusgebeurtenissen in volgorde: session_initializing, translation_ready en uiteindelijk ready_for_audio. Begin pas met het verzenden van audio na ready_for_audio.

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

Stream audioblokken

jij verzendt

Verzend continu audio_chunk-events met base64-gecodeerde PCM16-audio die via de microfoon is opgenomen. Houd de blokken klein (ongeveer 100 ms) voor de laagste latentie.

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

Ontvang vertaalde uitvoer

jij luistert

Tijdens het vertalen streamt de server output_audio (vertaalde spraak), output_transcript (vertaalde tekst) en input_transcript (herkende brontekst) — allemaal als incrementele delta’s.

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

Beëindig de sessie

jij verzendt

Verzend translation_stop om de sessie netjes af te sluiten. Het tokengebruik wordt afgerond en een translation_closed-event bevestigt dat de sessie is beëindigd.

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

Gebeurtenisreferentie

Een volledige referentie van elke gebeurtenis in de Realtime Vertaal-API — wat je verzendt en wat je ontvangt.

Gebeurtenissen die je verzendt

jij verzendt
translation_start

Start een nieuwe vertaalsessie. Geef de BCP-47-taalcode van de doeltaal mee.

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

Verstuurt een blok ruwe microfoonaudio. Het veld audioData moet een base64-gecodeerde PCM16 mono-audiobuffer zijn met een samplefrequentie van 24.000 Hz.

{
  "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

Beëindigt de sessie netjes. De server rondt de facturatie af en verzendt translation_closed.

Gebeurtenissen waarnaar je luistert

jij luistert
session_initializingstatus

Wordt direct na translation_start verzonden. Geeft aan dat de sessie wordt opgezet — nog niet klaar voor audio.

translation_readystatus

Wordt verzonden zodra de server-side verbinding is opgezet. Wacht nog op de definitieve activering van de sessie.

ready_for_audiostatus

De sessie is volledig actief. Begin nu met het streamen van audio_chunk-events.

output_audiostream

Een blok vertaalde spraakaudio. De delta is een base64-gecodeerde PCM16-audiobuffer. Buffer opeenvolgende delta’s en speel ze in volgorde af.

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

Een fragment van de vertaalde tekst. Voeg delta’s samen om de volledige vertaalde transcriptie in je UI op te bouwen.

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

Een fragment van de herkende bronspraak. Voeg delta’s samen om de ondertiteling in de brontaal op te bouwen.

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

Bevestigt dat de sessie netjes is beëindigd — na translation_stop of wanneer de server de sessie sluit vanwege uitgeputte tokens.

translation_errorerror

Er is een onverwachte fout opgetreden. Het veld message legt uit wat er misging. De sessie kan nog actief zijn — je kunt opnieuw proberen of translation_stop aanroepen.

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

Je tokensaldo is opgebruikt. De sessie wordt automatisch gesloten. Upgrade je abonnement om door te gaan.

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

Volledig Integratievoorbeeld

Een minimaal maar volledig JavaScript-voorbeeld dat laat zien hoe je verbinding maakt, een sessie start, audio streamt, alle serverevents verwerkt en de sessie netjes stopt.

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');
}
Facturatie

Hoe Facturatie Werkt

Realtime vertaling wordt gefactureerd op basis van de sessieduur — de tijd tussen sessieactivatie en translation_stop of tokenuitputting. Geen telling per teken of per woord.

Facturatie per Seconde

Gebruik wordt gemeten in seconden vanaf het moment dat je sessie volledig actief is totdat deze eindigt. Gedeeltelijke seconden worden naar boven afgerond.

📊

Tokens Worden Live Afgetrokken

Tokens worden aan het einde van elke sessie van je saldo afgetrokken op basis van de werkelijke duur. Je beschikbare saldo wordt gecontroleerd voordat een sessie kan starten.

🔒

Automatische Limiet

De sessie wordt automatisch beëindigd wanneer je resterende tokensaldo bijna op is. Je ontvangt een insufficient_tokens-event voordat de sessie wordt gesloten.

Geschat Tokenverbruik

1 minuut
~3.000 tokens
Goed voor snelle controles
5 minuten
~15.000 tokens
Korte vergadering of interview
30 minuten
~90.000 tokens
Uitgebreid gesprek
1 uur
~180.000 tokens
Conferentie of lezing
Sessieduur
Ongeveer Gebruikte Tokens
Opmerkingen

Opmerking: Tokenramingen zijn indicatief. Het werkelijke verbruik hangt af van geluidsniveaus en sessieactiviteit. Controleer je dashboard voor realtime gebruik.

Audiogids

Vereisten voor Audioformaat

De API verwacht een specifiek audioformaat voor de beste nauwkeurigheid en laagste latentie. Gebruik het onderstaande codefragment om microfoonaudio in de browser vast te leggen en te converteren.

FormaatPCM 16-bit, little-endian
Samplefrequentie24 000 Hz
Kanalen1 (mono)
Transfer EncodingBase64 string
Browsermicrofoon-opname
// 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);

Veelgestelde Vragen

Veelgestelde vragen over het integreren en gebruiken van de Realtime Vertaal-API.