Traduction automatique

Leçon réécrite le 3 novembre 2026. Elle reposait sur l’endpoint /v1/audio/translations et whisper-1, tous deux dépréciés et arrêtés le 26 février 2027, et sur une session Realtime d’assistant détournée en interprète. OpenAI propose désormais deux chemins : pour un enregistrement, la transcription dans la langue d’origine avec gpt-transcribe, puis la traduction du texte ; pour la parole en direct, une session de traduction dédiée avec gpt-realtime-translate. Le code a été vérifié avec le SDK openai 3.42.1 et la bibliothèque websocket-client. Sources : File transcription · Realtime translation · Deprecations.

Deux besoins, deux outils

Traduire de l’audio recouvre deux situations très différentes, et OpenAI ne les traite pas avec le même outil :

Le guide d’OpenAI insiste sur un point : changer seulement l’identifiant du modèle dans une requête /v1/audio/translations ne migre rien. L’ancien endpoint, qui ne savait traduire que vers l’anglais, n’a pas de remplaçant direct.

Traduire un enregistrement

La méthode transcrit d’abord fidèlement, dans la langue parlée, puis traduit le texte. Elle fonctionne vers n’importe quelle langue, là où l’ancien endpoint ne produisait que de l’anglais, et vous donne les deux textes, utiles pour vérifier :

from openai import OpenAI

client = OpenAI()


def traduire_enregistrement(chemin: str, langue_cible: str) -> dict[str, str]:
    """Transcrit un enregistrement dans sa langue, puis traduit le texte."""
    with open(chemin, "rb") as f:
        transcription = client.audio.transcriptions.create(model="gpt-transcribe", file=f)

    response = client.responses.create(
        model="gpt-6-luna",
        instructions=(
            f"Traduis en {langue_cible} le texte fourni par l'utilisateur. "
            "Garde le ton et le style. Réponds uniquement par la traduction."
        ),
        input=transcription.text,
    )
    return {"original": transcription.text, "traduction": response.output_text}


resultat = traduire_enregistrement("reunion_fr.mp3", "allemand")
print(resultat["traduction"])

Deux choix méritent une explication. La consigne de traduction est dans instructions, et la transcription arrive comme simple donnée dans input : un enregistrement peut contenir n’importe quoi, y compris une phrase qui ressemble à un ordre, et elle ne doit pas pouvoir modifier la consigne. Le modèle gpt-6-luna est celui qu’OpenAI conseille pour les traitements volumineux et sensibles au coût ; pour un texte juridique ou technique délicat, choisissez un modèle plus capable, comme gpt-6.1-sol.

Interpréter la parole en direct

Pour traduire pendant que la personne parle, OpenAI propose une session Realtime d’un genre particulier. Le guide la distingue nettement d’une session d’agent vocal :

Le transport dépend de l’endroit où arrive l’audio. Dans un navigateur, WebRTC envoie le micro et reçoit la voix traduite comme pistes audio ; votre serveur crée pour cela un secret client à courte durée de vie, via /v1/realtime/translations/client_secrets, et votre clé d’API ne quitte jamais le serveur. Côté serveur, quand l’audio vous parvient déjà brut (un flux téléphonique, une captation), une connexion WebSocket suffit :

import base64
import json
import os

import websocket  # pip install websocket-client

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",  # identifiant haché de votre utilisateur
    ],
)

# Langue de sortie de l'interprète
ws.send(json.dumps({"type": "session.update", "session": {"audio": {"output": {"language": "en"}}}}))


def envoyer_audio(pcm16: bytes) -> None:
    """Ajoute un morceau d'audio source : PCM 16 bits, mono, 24 kHz."""
    ws.send(json.dumps({"type": "session.input_audio_buffer.append", "audio": base64.b64encode(pcm16).decode()}))

Pendant que vous envoyez l’audio, silences compris, la session renvoie des événements à traiter au fil de l’eau : session.output_audio.delta porte l’audio traduit en base64, session.output_transcript.delta le texte traduit et session.input_transcript.delta la transcription de l’original. Quand la source s’arrête, envoyez session.close : le service termine la traduction en cours, puis répond par session.closed.

traduction: list[str] = []
while True:
    event = json.loads(ws.recv())
    if event["type"] == "session.output_transcript.delta":
        traduction.append(event["delta"])
    elif event["type"] == "error":
        raise RuntimeError(f"Erreur de traduction : {event['error']['code']}")
    elif event["type"] == "session.closed":
        break
ws.close()
print("".join(traduction))

Ne négligez pas l’événement error : une clé refusée ne fait pas échouer la connexion elle-même, elle arrive juste après sous la forme d’un événement error de code invalid_api_key (constaté le 3 novembre 2026). En production, la réception tourne en parallèle de l’envoi, dans un fil ou une tâche à part, et l’audio traduit part vers le lecteur ou la ligne téléphonique au fur et à mesure : le guide officiel en donne une version complète, avec lecture du son.

Points clés à retenir

• /v1/audio/translations et whisper-1 s’arrêtent le 26 février 2027, sans remplaçant direct : changer le modèle ne suffit pas
• Pour un enregistrement : gpt-transcribe dans la langue d’origine, puis traduction du texte par un modèle de texte, vers n’importe quelle langue
• Gardez la consigne de traduction dans instructions et la transcription comme simple donnée
• Pour le direct : une session de traduction (/v1/realtime/translations, gpt-realtime-translate), qui joue l’interprète, sans response.create
• WebRTC dans le navigateur, avec un secret client créé par le serveur ; WebSocket côté serveur, avec de l’audio PCM 16 bits à 24 kHz