GPT Translator Logo
En Direct & Streaming

API de Traduction en Temps Réel

Ajoutez une traduction vocale en direct à n’importe quelle application en quelques minutes. Diffusez l’audio en entrée et recevez l’audio traduit ainsi que les transcriptions — le tout via une seule connexion WebSocket.

Pourquoi l’API de Traduction en Temps Réel ?

Conçue pour les applications nécessitant une traduction instantanée et continue. Une seule connexion persistante gère toute la session — sans polling, sans délais et sans complexité.

Latence Ultra Faible

L’audio en streaming est traduit et renvoyé en temps réel. Aucun aller-retour requête-réponse — les résultats arrivent pendant que l’orateur parle.

Audio Entrant, Audio Sortant

Envoyez l’audio brut du microphone et recevez la parole traduite en retour. Les transcriptions d’entrée et de sortie sont également diffusées afin que vous puissiez afficher des sous-titres en direct.

Plus de 130 Langues

Traduisez vers n’importe quelle langue majeure en utilisant les codes de langue standard BCP-47. Changez la langue cible entre les sessions sans modifier le SDK.

Sécurisé par Défaut

Chaque connexion est authentifiée avec votre jeton JWT. Les sessions sont isolées par utilisateur — votre audio n’est jamais partagé ni stocké.

Commencer

Connexion & Authentification

L’API de Traduction en Temps Réel fonctionne sur un namespace Socket.IO dédié. Passez votre clé API comme paramètre de requête lors de la création de la connexion — le serveur la valide avant qu’une session puisse commencer.

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

Remarque : Obtenez votre clé API depuis le tableau de bord GPT Translator dans la section API Keys. Les connexions sans clé API valide sont immédiatement rejetées.

N’exposez jamais votre clé API dans le code côté client

L’exemple de code ci-dessus est fourni uniquement à titre d’illustration. Intégrer directement votre clé API dans le JavaScript du navigateur l’expose à toute personne inspectant le code source de votre page ou le trafic réseau — n’importe qui peut alors utiliser votre clé et vider votre solde de jetons.

Recommandé : utiliser un proxy via votre propre backend

Votre serveur conserve la clé API de manière sécurisée et ouvre la connexion Socket.IO au nom du navigateur. Le navigateur se connecte à votre serveur, jamais directement à l’API de traduction.

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));
Flux de Session

Cycle de Vie de la Session

Chaque session de traduction suit une simple séquence de cinq étapes. Comprendre cet ordre vous aidera à créer une intégration robuste.

1

Démarrer une session

vous émettez

Émettez translation_start avec le code de la langue cible. Le serveur réserve votre solde de jetons et commence l’initialisation de la session.

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

Attendre les signaux de disponibilité

vous écoutez

Le serveur émet trois événements de statut dans l’ordre : session_initializing, translation_ready puis ready_for_audio. Commencez à envoyer l’audio uniquement après ready_for_audio.

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

Diffuser des segments audio

vous émettez

Émettez continuellement des événements audio_chunk avec un audio PCM16 encodé en base64 capturé depuis le microphone. Gardez les segments petits (environ 100 ms chacun) pour obtenir la latence la plus faible possible.

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

Recevoir la sortie traduite

vous écoutez

Pendant la traduction, le serveur diffuse output_audio (parole traduite), output_transcript (texte traduit) et input_transcript (texte source reconnu) — le tout sous forme de deltas incrémentaux.

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

Terminer la session

vous émettez

Émettez translation_stop pour fermer proprement la session. L’utilisation des jetons est finalisée et un événement translation_closed confirme la fin de la session.

socket.emit('translation_stop');
Référence API

Référence des Événements

Une référence complète de chaque événement de l’API de Traduction en Temps Réel — ce que vous envoyez et ce que vous recevez.

Événements que Vous Émettez

vous émettez
translation_start

Démarre une nouvelle session de traduction. Passez le code de langue BCP-47 pour la langue cible.

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

Envoie un segment d’audio brut du microphone. Le champ audioData doit être un buffer audio PCM16 mono encodé en base64 échantillonné à 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

Termine proprement la session. Le serveur finalise la facturation et émet translation_closed.

Événements que Vous Écoutez

vous écoutez
session_initializingstatus

Émis immédiatement après translation_start. Indique que la session est en cours de configuration — elle n’est pas encore prête pour l’audio.

translation_readystatus

Émis une fois la connexion côté serveur établie. L’activation finale de la session est encore en attente.

ready_for_audiostatus

La session est entièrement active. Commencez maintenant à diffuser les événements audio_chunk.

output_audiostream

Un segment d’audio vocal traduit. Le delta est un buffer audio PCM16 encodé en base64. Mettez en mémoire tampon les deltas consécutifs et lisez-les dans l’ordre.

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

Un fragment du texte traduit. Assemblez les deltas pour construire la transcription traduite complète dans votre interface.

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

Un fragment de la parole source reconnue. Assemblez les deltas pour construire les sous-titres dans la langue source.

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

Confirme que la session s’est terminée proprement — soit après translation_stop, soit lorsque le serveur ferme la session en raison d’un épuisement des jetons.

translation_errorerror

Une erreur inattendue s’est produite. Le champ message explique ce qui s’est mal passé. La session peut toujours être active — vous pouvez réessayer ou appeler translation_stop.

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

Votre solde de jetons est épuisé. La session est automatiquement fermée. Passez à une offre supérieure pour continuer.

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

Exemple d’Intégration Complète

Un exemple JavaScript minimal mais complet montrant comment se connecter, démarrer une session, diffuser l’audio, gérer tous les événements du serveur et arrêter proprement la session.

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

Fonctionnement de la Facturation

La traduction en temps réel est facturée selon la durée de la session — le temps entre l’activation de la session et translation_stop ou l’épuisement des jetons. Aucun comptage par caractère ou par mot.

Facturation à la Seconde

L’utilisation est mesurée en secondes à partir du moment où votre session est entièrement active jusqu’à sa fin. Les secondes partielles sont arrondies à l’unité supérieure.

📊

Jetons Déduits en Temps Réel

Les jetons sont déduits de votre solde à la fin de chaque session en fonction de la durée réelle. Votre solde disponible est vérifié avant qu’une session puisse commencer.

🔒

Limite Automatique

La session est automatiquement terminée lorsque votre solde de jetons restant est sur le point d’être épuisé. Vous recevrez un événement insufficient_tokens avant la fermeture de la session.

Consommation Estimée de Jetons

1 minute
~3 000 jetons
Idéal pour des vérifications rapides
5 minutes
~15 000 jetons
Réunion courte ou entretien
30 minutes
~90 000 jetons
Conversation prolongée
1 heure
~180 000 jetons
Conférence ou cours
Durée de la Session
Jetons Utilisés Approx.
Notes

Remarque : Les estimations de jetons sont approximatives. La consommation réelle dépend des niveaux de bruit audio et de l’activité de la session. Consultez votre tableau de bord pour l’utilisation en temps réel.

Guide Audio

Exigences du Format Audio

L’API attend un format audio spécifique pour obtenir la meilleure précision et la plus faible latence. Utilisez l’extrait de code ci-dessous pour capturer et convertir l’audio du microphone dans le navigateur.

FormatPCM 16-bit, little-endian
Taux d’Échantillonnage24 000 Hz
Canaux1 (mono)
Encodage de TransfertBase64 string
Capture du microphone du navigateur
// 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);

Questions Fréquemment Posées

Questions courantes sur l’intégration et l’utilisation de l’API de Traduction en Temps Réel.