GPT Translator Logo
Live & Streaming

Realtime-översättnings-API

Lägg till live tal-till-tal-översättning i vilken applikation som helst på några minuter. Strömma in ljud och få tillbaka översatt ljud och transkriptioner — allt via en enda WebSocket-anslutning.

Varför använda Realtime-översättnings-API?

Byggt för applikationer som behöver omedelbar och kontinuerlig översättning. En enda beständig anslutning hanterar hela sessionen — ingen polling, inga fördröjningar och ingen komplexitet.

Ultralåg latens

Strömmande ljud översätts och returneras i realtid. Inga request-response-rundor — resultaten kommer medan talaren pratar.

Ljud in, ljud ut

Skicka rått mikrofonljud och få tillbaka översatt tal. Både in- och utgående transkriptioner strömmas också så att du kan visa liveundertexter.

130+ språk

Översätt till vilket större språk som helst med standardiserade BCP-47-språkkoder. Byt målspråk mellan sessioner utan ändringar i SDK.

Säkert som standard

Varje anslutning autentiseras med din JWT-token. Sessioner är isolerade per användare — ditt ljud delas eller lagras aldrig.

Kom igång

Anslut & autentisera

Realtime-översättnings-API körs över ett dedikerat Socket.IO-namnrymd. Skicka din API-nyckel som en query-parameter när anslutningen skapas — servern verifierar den innan någon session kan starta.

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

Obs: Hämta din API-nyckel från GPT Translators dashboard under API Keys. Anslutningar utan giltig API-nyckel avvisas omedelbart.

Exponera aldrig din API-nyckel i klientkod

Kodexemplet ovan är endast avsett som illustration. Att bädda in din API-nyckel direkt i JavaScript i webbläsaren gör den synlig för alla som granskar sidans källkod eller nätverkstrafik — vem som helst kan då använda din nyckel och tömma ditt tokensaldo.

Rekommenderat: använd proxy via din egen backend

Din server lagrar API-nyckeln säkert och öppnar Socket.IO-anslutningen på webbläsarens vägnar. Webbläsaren ansluter till din server, aldrig direkt till översättnings-API:t.

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));
Sessionsflöde

Sessionens livscykel

Varje översättningssession följer en enkel femstegssekvens. Att förstå denna ordning hjälper dig att bygga en robust integration.

1

Starta en session

du skickar

Skicka translation_start med målspråkskoden. Servern reserverar ditt tokensaldo och börjar initiera sessionen.

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

Vänta på redo-signaler

du lyssnar

Servern skickar tre statushändelser i ordning: session_initializing, translation_ready och slutligen ready_for_audio. Börja skicka ljud först efter ready_for_audio.

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

Strömma ljudblock

du skickar

Skicka kontinuerligt audio_chunk-händelser med base64-kodat PCM16-ljud som fångats från mikrofonen. Håll blocken små (cirka 100 ms) för lägsta möjliga latens.

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

Ta emot översatt utdata

du lyssnar

När översättningen sker strömmar servern output_audio (översatt tal), output_transcript (översatt text) och input_transcript (igenkänd källtext) — allt som inkrementella deltas.

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

Avsluta sessionen

du skickar

Skicka translation_stop för att avsluta sessionen korrekt. Tokenanvändningen slutförs och en translation_closed-händelse bekräftar att sessionen har avslutats.

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

Händelsereferens

En komplett referens över varje händelse i Realtime-översättnings-API — vad du skickar och vad du tar emot.

Händelser du skickar

du skickar
translation_start

Startar en ny översättningssession. Skicka BCP-47-språkkoden för målspråket.

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

Skickar ett block med rått mikrofonljud. Fältet audioData måste vara en base64-kodad PCM16 mono-ljudbuffer med en samplingsfrekvens på 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

Avslutar sessionen korrekt. Servern slutför faktureringen och skickar translation_closed.

Händelser du lyssnar på

du lyssnar
session_initializingstatus

Skickas omedelbart efter translation_start. Indikerar att sessionen håller på att sättas upp — ännu inte redo för ljud.

translation_readystatus

Skickas när anslutningen på serversidan har etablerats. Väntar fortfarande på slutlig aktivering av sessionen.

ready_for_audiostatus

Sessionen är helt aktiv. Börja nu strömma audio_chunk-händelser.

output_audiostream

Ett block av översatt talat ljud. Deltat är en base64-kodad PCM16-ljudbuffer. Buffra efterföljande deltas och spela upp dem i ordning.

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

Ett fragment av den översatta texten. Lägg ihop deltas för att bygga hela den översatta transkriptionen i ditt gränssnitt.

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

Ett fragment av det igenkända källtalet. Lägg ihop deltas för att bygga undertexter på källspråket.

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

Bekräftar att sessionen avslutades korrekt — antingen efter translation_stop eller när servern stänger sessionen på grund av att tokens tagit slut.

translation_errorerror

Ett oväntat fel uppstod. Fältet message förklarar vad som gick fel. Sessionen kan fortfarande vara aktiv — du kan försöka igen eller anropa translation_stop.

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

Ditt tokensaldo är slut. Sessionen stängs automatiskt. Uppgradera din plan för att fortsätta.

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

Komplett integrations­exempel

Ett minimalt men komplett JavaScript-exempel som visar hur man ansluter, startar en session, strömmar ljud, hanterar alla serverhändelser och avslutar sessionen korrekt.

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

Så fungerar faktureringen

Realtime-översättning faktureras efter sessionslängd — tiden mellan att sessionen aktiveras och translation_stop eller att tokens tar slut. Ingen räkning per tecken eller ord.

Fakturering per sekund

Användningen mäts i sekunder från det att sessionen är helt aktiv tills den avslutas. Delvisa sekunder avrundas uppåt.

📊

Tokens dras i realtid

Tokens dras från ditt saldo i slutet av varje session baserat på faktisk längd. Ditt tillgängliga saldo kontrolleras innan en session kan starta.

🔒

Automatisk gräns

Sessionen avslutas automatiskt när ditt återstående tokensaldo håller på att ta slut. Du får en insufficient_tokens-händelse innan sessionen stängs.

Beräknad tokenförbrukning

1 minut
~3 000 tokens
Bra för snabba kontroller
5 minuter
~15 000 tokens
Kort möte eller intervju
30 minuter
~90 000 tokens
Längre konversation
1 timme
~180 000 tokens
Konferens eller föreläsning
Sessionslängd
Ungefär använda tokens
Anteckningar

Obs: Tokenuppskattningarna är ungefärliga. Faktisk förbrukning beror på ljudnivåer och sessionsaktivitet. Kontrollera din dashboard för användning i realtid.

Ljudguide

Krav för ljudformat

API:t förväntar sig ett specifikt ljudformat för bästa noggrannhet och lägsta latens. Använd kodexemplet nedan för att fånga och konvertera mikrofonljud i webbläsaren.

FormatPCM 16-bit, little-endian
Samplingsfrekvens24 000 Hz
Kanaler1 (mono)
ÖverföringskodningBase64 string
Mikrofoninspelning i webbläsaren
// 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);

Vanliga frågor

Vanliga frågor om integration och användning av Realtime-översättnings-API.