Traduzione automatica
In questa pagina
Lezione riscritta il 3 novembre 2026. In precedenza si basava sull’endpoint
/v1/audio/translationse suwhisper-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 congpt-transcribe, seguita dalla traduzione del testo; per il parlato in tempo reale, una sessione di traduzione dedicata congpt-realtime-translate. Il codice è stato verificato con l’SDKopenai3.42.1 e la libreriawebsocket-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:
| Esigenza | Strumento a partire da novembre 2026 | Risultato |
|---|---|---|
| Una registrazione da tradurre (riunione, podcast, chiamata archiviata) | gpt-transcribe per trascrivere nella lingua originale, poi un modello testuale per tradurre | Testo tradotto nella tua lingua di destinazione |
| Parlato in tempo reale da interpretare (chiamata, conferenza, lezione) | Sessione di traduzione in tempo reale con gpt-realtime-translate | Audio e trascrizioni tradotti, generati mentre si parla |
Percorso legacy: /v1/audio/translations con whisper-1 | Deprecato, dismesso il 26 febbraio 2027 | Solo 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 vocale | Sessione di traduzione |
|---|---|
Si connette a /v1/realtime | Si connette a /v1/realtime/translations |
| Il modello agisce come assistente | Il modello agisce come interprete |
Ciclo conversazione e risposta (response.create) | Flusso continuo dall’audio in ingresso, nessun response.create |
| Può chiamare strumenti | Produce 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/translationsewhisper-1chiuderanno il 26 febbraio 2027, senza un sostituto diretto: cambiare il modello non basta- Per una registrazione:
gpt-transcribenella lingua originale, poi traduzione testuale tramite un modello testuale, in qualsiasi lingua - Mantieni l’istruzione di traduzione in
instructionse 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, senzaresponse.create - WebRTC nel browser, con un segreto client creato dal server; WebSocket lato server, con audio PCM a 16 bit a 24 kHz