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é.
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.
wss://api.gpttranslator.co └── namespace: /api/realtime-translator
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.
// 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));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.
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.
Attendre les signaux de disponibilité
vous écoutezLe 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.
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.
Recevoir la sortie traduite
vous écoutezPendant 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.
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.
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 émetteztranslation_startDé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_chunkEnvoie 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_stopTermine proprement la session. Le serveur finalise la facturation et émet translation_closed.
Événements que Vous Écoutez
vous écoutezsession_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_audiostatusLa session est entièrement active. Commencez maintenant à diffuser les événements audio_chunk.
output_audiostreamUn 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_transcriptstreamUn 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_transcriptstreamUn 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_closedstatusConfirme 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_errorerrorUne 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_tokenserrorVotre 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 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.
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');
}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
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.
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.
PCM 16-bit, little-endian24 000 Hz1 (mono)Base64 string// 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.