Traduction en temps réel

La traduction en temps réel vous permet d’envoyer un flux audio source dans une session de traduction dédiée et de recevoir l’audio traduit ainsi que des deltas de transcription pendant que la personne parle encore. Utilisez-la pour l’interprétation en direct, les appels multilingues, les diffusions, les réunions, les cours et les salons vidéo.

Utilisez gpt-realtime-translate lorsque votre application doit traduire les propos d’une personne. Si vous avez besoin d’un assistant qui répond aux questions, appelle des outils et gère une conversation, utilisez plutôt gpt-realtime-2.1 avec une session Realtime standard.

Particularités des sessions de traduction

Les sessions de traduction en temps réel utilisent une architecture différente de celle des sessions d’agent vocal :

Session d’agent vocal	Session de traduction
Se connecte à `/v1/realtime`.	Se connecte à `/v1/realtime/translations`.
Le modèle joue le rôle d’assistant.	Le modèle joue le rôle d’interprète.
Utilise un cycle de vie de conversation et de réponse.	Produit un flux continu à partir de l’audio entrant.
Peut appeler des outils et produire des tours de parole de l’assistant.	Produit de l’audio traduit et des deltas de transcription.
Vous pouvez appeler `response.create`.	Vous n’appelez pas `response.create`.

La traduction démarre à partir du flux audio lui-même. Continuez à ajouter de l’audio, y compris les silences entre les phrases, et traitez les événements de sortie à mesure qu’ils arrivent.

Choisissez un protocole de transport

Utilisez WebRTC lorsque le navigateur capture ou lit l’audio. WebRTC envoie l’audio source sous forme de piste multimédia et reçoit la parole traduite sous forme de piste audio distante. Vous n’avez donc pas à rééchantillonner ni à lire manuellement les blocs PCM.

Utilisez WebSockets lorsque votre serveur reçoit déjà de l’audio brut, par exemple via Twilio Media Streams, des flux multimédias SIP, l’ingestion de flux de diffusion ou un worker multimédia. Avec WebSockets, envoyez de l’audio PCM16 à 24 kHz encodé en base64 et gérez vous-même la lecture des deltas audio renvoyés.

Créez une session WebRTC dans le navigateur

Pour les applications dans le navigateur, créez un secret client à courte durée de validité sur votre serveur. N’exposez pas votre clé API standard dans le navigateur.

Créez un secret client pour la traduction

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25app.post("/session", async (req, res) => {
  const language = req.body.targetLanguage ?? "es";

  const response = await fetch(
    "https://api.openai.com/v1/realtime/translations/client_secrets",
    {
      method: "POST",
      headers: {
        Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
        "Content-Type": "application/json",
        "OpenAI-Safety-Identifier": "hashed-user-id",
      },
      body: JSON.stringify({
        session: {
          model: "gpt-realtime-translate",
          audio: {
            output: { language },
          },
        },
      }),
    }
  );

  res.status(response.status).json(await response.json());
});

Dans le navigateur, capturez l’audio, créez une connexion entre pairs et envoyez l’offre SDP par POST au point de terminaison des appels de traduction :

Établissez un appel de traduction dans le navigateur

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50const { value: clientSecret } = await fetch("/session", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ targetLanguage: "es" }),
}).then((response) => response.json());

const sourceStream = await navigator.mediaDevices.getUserMedia({
  audio: true,
});

const pc = new RTCPeerConnection();
pc.addTrack(sourceStream.getAudioTracks()[0], sourceStream);

const translatedAudio = new Audio();
translatedAudio.autoplay = true;
pc.ontrack = ({ streams }) => {
  translatedAudio.srcObject = streams[0];
};

const events = pc.createDataChannel("oai-events");
events.onmessage = ({ data }) => {
  const event = JSON.parse(data);
  if (event.type === "session.output_transcript.delta") {
    subtitles.textContent += event.delta;
  }
};

const offer = await pc.createOffer();
await pc.setLocalDescription(offer);

const sdpResponse = await fetch(
  "https://api.openai.com/v1/realtime/translations/calls",
  {
    method: "POST",
    headers: {
      Authorization: `Bearer ${clientSecret}`,
      "Content-Type": "application/sdp",
    },
    body: offer.sdp,
  }
);

if (!sdpResponse.ok) {
  throw new Error(await sdpResponse.text());
}

await pc.setRemoteDescription({
  type: "answer",
  sdp: await sdpResponse.text(),
});

Créez une session WebSocket

Connectez-vous au point de terminaison dédié à la traduction et sélectionnez le modèle dans l’URL :

Avant d’exécuter cet exemple, installez ws pour Node.js, websocket-client pour Python ou async-websocket pour Ruby (gem install async-websocket).

Connectez-vous à une session de traduction

JavaScript

1
2
3
4
5
6
7
8
9
10
11import WebSocket from "ws";

const ws = new WebSocket(
  "wss://api.openai.com/v1/realtime/translations?model=gpt-realtime-translate",
  {
    headers: {
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
      "OpenAI-Safety-Identifier": "hashed-user-id",
    },
  }
);

1
2
3
4
5
6
7
8
9
10
11import os
import websocket

ws = websocket.WebSocket()
ws.connect(
    "wss://api.openai.com/v1/realtime/translations?model=gpt-realtime-translate",
    header=[
        f"Authorization: Bearer {os.environ['OPENAI_API_KEY']}",
        "OpenAI-Safety-Identifier: hashed-user-id",
    ],
)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21require "async"
require "async/http/endpoint"
require "async/websocket/client"
require "json"

endpoint = Async::HTTP::Endpoint.parse("wss://api.openai.com/v1/realtime/translations?model=gpt-realtime-translate", timeout: 10, alpn_protocols: ["http/1.1"])
headers = {
  "Authorization" => "Bearer #{ENV.fetch("OPENAI_API_KEY")}",
  "OpenAI-Safety-Identifier" => "hashed-user-id"
}
Sync do |task|
  task.with_timeout(120) do
    Async::WebSocket::Client.connect(endpoint, headers: headers) do |connection|
      message = connection.read or raise "Connection closed before session creation"
      event = JSON.parse(message.to_str)
      raise "Expected session.created: #{event}" unless event["type"] == "session.created"

      puts(event.fetch("type"))
    end
  end
end

Pour Ruby, insérez les extraits de code de configuration et d’ajout de données audio ci-dessous dans le bloc Async::WebSocket::Client.connect, après la vérification de la création de la session et avant la fin du bloc. Gardez la connexion ouverte pendant l’envoi des données audio et la réception des événements de traduction.

Configurez la langue cible après l’ouverture du socket :

Configurez la langue cible

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14ws.on("open", () => {
  ws.send(
    JSON.stringify({
      type: "session.update",
      session: {
        audio: {
          output: {
            language: "es",
          },
        },
      },
    })
  );
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16import json

ws.send(
    json.dumps(
        {
            "type": "session.update",
            "session": {
                "audio": {
                    "output": {
                        "language": "es",
                    },
                },
            },
        }
    )
)

1
2connection.write(JSON.generate(type: "session.update", session: { audio: { output: { language: "es" } } }))
connection.flush

Ajoutez ensuite de l’audio en continu :

Ajoutez l’audio source

JavaScript

1
2
3
4
5
6ws.send(
  JSON.stringify({
    type: "session.input_audio_buffer.append",
    audio: base64Pcm16,
  })
);

1
2
3
4
5
6
7
8ws.send(
    json.dumps(
        {
            "type": "session.input_audio_buffer.append",
            "audio": base64_pcm16,
        }
    )
)

1
2
3
4
5
6
7
8require "base64"

File.open("speech.pcm", "rb") do |audio|
  while (chunk = audio.read(4_800))
    connection.write(JSON.generate(type: "session.input_audio_buffer.append", audio: Base64.strict_encode64(chunk)))
    connection.flush
  end
end

Écoutez les événements contenant l’audio traduit et les transcriptions :

Écoutez les événements contenant l’audio traduit et les transcriptions

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15ws.on("message", (data) => {
  const event = JSON.parse(data.toString());

  if (event.type === "session.output_audio.delta") {
    playPcm16(event.delta);
  }

  if (event.type === "session.output_transcript.delta") {
    process.stdout.write(event.delta);
  }

  if (event.type === "session.input_transcript.delta") {
    updateSourceTranscript(event.delta);
  }
});

1
2
3
4
5
6
7
8
9
10
11while True:
    event = json.loads(ws.recv())

    if event["type"] == "session.output_audio.delta":
        play_pcm16(event["delta"])

    if event["type"] == "session.output_transcript.delta":
        print(event["delta"], end="", flush=True)

    if event["type"] == "session.input_transcript.delta":
        update_source_transcript(event["delta"])

Fermez une session WebSocket

Lorsque votre flux source se termine, envoyez un événement session.close avant de fermer la connexion WebSocket. Cet événement indique au service de traiter l’audio d’entrée en attente, d’émettre le reste de l’audio traduit et de la transcription, puis d’envoyer un événement session.closed. L’événement session.close n’est pris en charge que pour les sessions de traduction.

Après avoir envoyé session.close, cessez d’ajouter de l’audio et continuez à lire les événements dans votre boucle de réception habituelle jusqu’à recevoir session.closed. Fermer le socket immédiatement peut entraîner la perte de données de traduction encore en cours d’émission par la session.

Fermez une session de traduction

JavaScript

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37let translationSessionClosing = false;

function closeTranslationSession() {
  if (translationSessionClosing) {
    return;
  }

  translationSessionClosing = true;
  ws.send(
    JSON.stringify({
      type: "session.close",
    })
  );
}

ws.on("message", (data) => {
  const event = JSON.parse(data.toString());

  if (event.type === "session.output_audio.delta") {
    playPcm16(event.delta);
  }

  if (event.type === "session.output_transcript.delta") {
    process.stdout.write(event.delta);
  }

  if (event.type === "session.input_transcript.delta") {
    updateSourceTranscript(event.delta);
  }

  if (event.type === "session.closed") {
    ws.close();
  }
});

// Call this when the source stream ends.
closeTranslationSession();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30translation_session_closing = False


def close_translation_session():
    global translation_session_closing
    if translation_session_closing:
        return

    translation_session_closing = True
    ws.send(json.dumps({"type": "session.close"}))


# Call this when the source stream ends.
close_translation_session()

while True:
    event = json.loads(ws.recv())

    if event["type"] == "session.output_audio.delta":
        play_pcm16(event["delta"])

    if event["type"] == "session.output_transcript.delta":
        print(event["delta"], end="", flush=True)

    if event["type"] == "session.input_transcript.delta":
        update_source_transcript(event["delta"])

    if event["type"] == "session.closed":
        ws.close()
        break

Créez une traduction en direct pour un public

Utilisez la traduction en direct pour un public lorsque vous devez traduire l’audio d’un seul intervenant ou d’un seul flux source à destination d’auditeurs. Il peut s’agir de diffusions en direct, d’interventions lors de conférences, de webinaires, de conférences téléphoniques sur les résultats financiers, de cours magistraux ou de vidéos.

L’architecture type est la suivante :

source audio -> translation session -> translated audio + subtitles

Créez une session de traduction pour chaque langue cible. Si une même source en anglais doit produire une sortie en espagnol et en français, créez une session de l’anglais vers l’espagnol et une autre de l’anglais vers le français.

Pour les applications de traduction en direct destinées à un public dans le navigateur, capturez l’audio de l’onglet avec getDisplayMedia(), envoyez-le via WebRTC et lisez la piste audio traduite distante. Pour les diffusions en production, exécutez la traduction dans un worker multimédia côté serveur et diffusez les pistes audio traduites ou les sous-titres aux auditeurs.

Créez un système de traduction conversationnelle

Utilisez la traduction conversationnelle lorsque deux participants ou plus échangent dans différentes langues. Il peut s’agir d’appels d’assistance, d’appels commerciaux, de tutorat ou de salons vidéo.

Gardez les pistes audio des participants séparées. Regrouper les voix dans un seul flux complique l’identification des intervenants, l’attribution des sous-titres et la gestion des prises de parole simultanées.

Pour un appel à deux personnes, créez une session de traduction par sens de traduction :

Caller A audio -> translate into Caller B language -> play to Caller B
Caller B audio -> translate into Caller A language -> play to Caller A

Pour les salons de groupe, le nombre de sessions dépend des personnes qui prennent la parole et des langues cibles :

translation sessions ~= active source speaker tracks x distinct target languages

Pour les petits salons, chaque auditeur peut créer des composants de traduction auxiliaires côté navigateur pour les intervenants distants dont il souhaite entendre la traduction. Pour les salons plus grands, utilisez un participant côté serveur ou un processus de traitement multimédia qui s’abonne une seule fois au flux de chaque intervenant source, crée une session de traduction par langue cible et republie les pistes traduites.

Testez la qualité et la latence

Testez la traduction avec de véritables données audio et faites-la vérifier par des personnes bilingues. Les métriques automatisées peuvent vous aider, mais elles ne détecteront pas toutes les erreurs que les utilisateurs remarquent.

Testez :

la qualité pour chaque paire de langues ;
les noms, les nombres, les dates, les devises et les numéros de téléphone ;
la terminologie propre au domaine ;
l’alternance entre langues et les conversations mêlant plusieurs langues ;
les accents, les débits de parole rapides et les prises de parole simultanées ;
la latence avant le premier audio traduit ;
la latence en fin d’énoncé ;
la synchronisation des sous-titres ;
la constance de la voix ;
le comportement lors des reconnexions.

Si votre cas d’usage exige une restitution exacte des noms ou des termes du domaine, constituez un jeu de référence avant le lancement et examinez les échecs manuellement.

Liste de vérification pour la mise en production

Choisissez WebRTC pour les flux multimédias côté navigateur et WebSockets pour les flux multimédias côté serveur.
Utilisez le point de terminaison dédié /v1/realtime/translations.
Transmettez l’audio en continu, y compris les silences entre les phrases.
Utilisez session.close et attendez session.closed avant de fermer une session WebSocket.
Gardez les pistes des intervenants séparées pour la traduction de conversations.
Utilisez une session par langue de sortie.
Affichez les transcriptions dans la langue source et la langue cible lorsque cela est utile.
Proposez des commandes pour l’audio original, l’audio traduit, les sous-titres, la coupure du son et le volume.
Signalez les états de reconnexion en cours, de retard et d’indisponibilité.
Suivez la latence séparément de la qualité de traduction.

Vue d’ensemble de Realtime et de l’audio

Comparez les sessions d’agent vocal, de traduction et de transcription.

Connexion WebRTC

Connectez les flux multimédias du navigateur à une session en temps réel.

Connexion WebSocket

Transmettez de l’audio brut en continu via un pipeline de traitement multimédia côté serveur.

Transcription en temps réel

Transmettez des mises à jour incrémentales de transcription à partir d’audio en direct.

Suggestions

Bien démarrer

Concepts fondamentaux

SDK et CLI

Ressources

Anciennes API

Choisissez un modèle

Texte et code

Conception de prompts

Raisonnement

Images et vidéo

Realtime et audio

Modèles spécialisés

API Agents

SDK Agents

ChatKit

Recherche et récupération

Connectez des outils et des données

Créez des flux de travail avec des outils

Ordinateur et code

Médias

GPT-Live

Realtime API

Développez avec la voix

Connexions

Traitement audio

Passez en production

Performances et qualité

Coût et débit

Sécurité et gouvernance

Infrastructure et accès

Opérations

Concepts fondamentaux

Plan

Build

Test and publish

Conversion specs

Guides

Ressources

Bien démarrer

Guides

File Upload

API

Measurement

Advertiser API

Référence de l’API

Bien démarrer

Fondamentaux

Explorer

Disponible sur

Versions

Flux de travail

Capacités

Référence

Personnalisation

Fichier de configuration

Configuration des agents

Étendez les capacités de ChatGPT et de Codex

Linux

Windows

Flux de travail de développement

Étendre et automatiser

Environnements

Développer avec Codex

Intégrations tierces

Référence

Autorisations

Codex Security

Cybersécurité

Bien démarrer

ChatGPT Work

Identité et authentification

Accès à l’espace de travail, stratégies et modèles

Contrôles des plugins et des connecteurs

Utilisation, gouvernance et conformité

Déploiement et fournisseurs de modèles

Communauté

Blog

Communauté

Blog