Vai al contenuto principale
Italiano— Scegli una lingua
Menu

Traduzione automatica

Lezione 8 di 18 Aggiornata il 3 novembre 2026 Sviluppatore
In questa pagina
  1. Due esigenze, due strumenti
  2. Tradurre una registrazione
  3. Interpretare il parlato in tempo reale
  4. Punti chiave

Lezione riscritta il 3 novembre 2026. In precedenza si basava sull’endpoint /v1/audio/translations e su whisper-1, entrambi deprecati e dismessi il 26 febbraio 2027, nonché su una sessione di assistente Realtime riadattata come interprete. OpenAI offre ora due percorsi: per le registrazioni, la trascrizione nella lingua originale con gpt-transcribe, seguita dalla traduzione del testo; per il parlato in tempo reale, una sessione di traduzione dedicata con gpt-realtime-translate. Il codice è stato verificato con l’SDK openai 3.42.1 e la libreria websocket-client. Fonti: Trascrizione file · Traduzione in tempo reale · Deprecazioni.

Due esigenze, due strumenti

La traduzione audio copre due scenari molto diversi e OpenAI li gestisce con strumenti differenti:

EsigenzaStrumento a partire da novembre 2026Risultato
Una registrazione da tradurre (riunione, podcast, chiamata archiviata)gpt-transcribe per trascrivere nella lingua originale, poi un modello testuale per tradurreTesto tradotto nella tua lingua di destinazione
Parlato in tempo reale da interpretare (chiamata, conferenza, lezione)Sessione di traduzione in tempo reale con gpt-realtime-translateAudio e trascrizioni tradotti, generati mentre si parla
Percorso legacy: /v1/audio/translations con whisper-1Deprecato, dismesso il 26 febbraio 2027Solo testo in inglese

La guida di OpenAI sottolinea un punto fondamentale: cambiare semplicemente l’ID del modello in una richiesta /v1/audio/translations non effettua alcuna migrazione. Il vecchio endpoint, che poteva tradurre solo in inglese, non ha un sostituto diretto.

Tradurre una registrazione

Questo metodo prima trascrive fedelmente nella lingua parlata, poi traduce il testo. Funziona per qualsiasi lingua di destinazione, a differenza del vecchio endpoint che produceva solo inglese, e ti fornisce entrambi i testi, utile per la verifica:

from openai import OpenAI

client = OpenAI()


def translate_recording(path: str, target_language: str) -> dict[str, str]:
    """Trascrive una registrazione nella sua lingua originale, poi traduce il testo."""
    with open(path, "rb") as f:
        transcription = client.audio.transcriptions.create(model="gpt-transcribe", file=f)

    response = client.responses.create(
        model="gpt-6-luna",
        instructions=(
            f"Translate the text provided by the user into {target_language}. "
            "Keep the tone and style. Respond only with the translation."
        ),
        input=transcription.text,
    )
    return {"original": transcription.text, "translation": response.output_text}


result = translate_recording("reunion_fr.mp3", "German")
print(result["translation"])

Due scelte meritano una spiegazione. L’istruzione di traduzione va in instructions, mentre la trascrizione arriva come dati semplici in input: una registrazione può contenere qualsiasi cosa, inclusa una frase che sembra un comando, e non deve poter modificare l’istruzione. Il modello gpt-6-luna è quello che OpenAI raccomanda per elaborazioni su larga scala sensibili ai costi; per testi legali o tecnici delicati, scegli un modello più capace, come gpt-6.1-sol.

Interpretare il parlato in tempo reale

Per tradurre mentre qualcuno parla, OpenAI offre un tipo speciale di sessione Realtime. La guida la distingue chiaramente da una sessione di agente vocale:

Sessione agente vocaleSessione di traduzione
Si connette a /v1/realtimeSi connette a /v1/realtime/translations
Il modello agisce come assistenteIl modello agisce come interprete
Ciclo conversazione e risposta (response.create)Flusso continuo dall’audio in ingresso, nessun response.create
Può chiamare strumentiProduce audio e trascrizioni tradotti

Il trasporto dipende da dove arriva l’audio. Nel browser, WebRTC invia l’input del microfono e riceve la voce tradotta come tracce audio; il tuo server crea un segreto client effimero per questo tramite /v1/realtime/translations/client_secrets, così la tua chiave API non lascia mai il server. Lato server, quando l’audio arriva già grezzo (un flusso telefonico, una cattura), basta una connessione WebSocket:

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",  # hashed identifier of your user
    ],
)

# Lingua di output dell'interprete
ws.send(json.dumps({"type": "session.update", "session": {"audio": {"output": {"language": "en"}}}}))


def send_audio(pcm16: bytes) -> None:
    """Aggiunge un chunk di audio sorgente: PCM a 16 bit, mono, 24 kHz."""
    ws.send(json.dumps({"type": "session.input_audio_buffer.append", "audio": base64.b64encode(pcm16).decode()}))

Mentre invii l’audio, inclusi i silenzi, la sessione restituisce eventi da elaborare al volo: session.output_audio.delta contiene l’audio tradotto in base64, session.output_transcript.delta il testo tradotto e session.input_transcript.delta la trascrizione dell’originale. Quando la sorgente si ferma, invia session.close: il servizio termina la traduzione corrente, poi risponde con session.closed.

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

Non trascurare l’evento error: una chiave rifiutata non fa fallire la connessione stessa; arriva subito dopo come evento error con codice invalid_api_key (osservato il 3 novembre 2026). In produzione, la ricezione gira in parallelo all’invio, in un thread o task separato, e l’audio tradotto va al player o alla linea telefonica man mano che arriva: la guida ufficiale fornisce una versione completa, inclusa la riproduzione audio.

Punti chiave

  • /v1/audio/translations e whisper-1 chiuderanno il 26 febbraio 2027, senza un sostituto diretto: cambiare il modello non basta
  • Per una registrazione: gpt-transcribe nella lingua originale, poi traduzione testuale tramite un modello testuale, in qualsiasi lingua
  • Mantieni l’istruzione di traduzione in instructions e la trascrizione come dati semplici
  • Per il parlato in tempo reale: una sessione di traduzione (/v1/realtime/translations, gpt-realtime-translate), che agisce come interprete, senza response.create
  • WebRTC nel browser, con un segreto client creato dal server; WebSocket lato server, con audio PCM a 16 bit a 24 kHz