Traducción en tiempo real

La traducción en tiempo real te permite transmitir el audio de origen a una sesión dedicada de traducción y recibir audio traducido y fragmentos incrementales de transcripción mientras la persona sigue hablando. Úsala para interpretación en vivo, llamadas multilingües, transmisiones, reuniones, clases y salas de videollamadas.

Usa gpt-realtime-translate cuando tu aplicación deba traducir lo que dice una persona. Si necesitas un asistente que responda preguntas, llame a herramientas y gestione una conversación, usa gpt-realtime-2.1 con una sesión estándar de Realtime.

En qué se diferencian las sesiones de traducción

Las sesiones de traducción en tiempo real usan una arquitectura distinta de la de las sesiones de agentes de voz:

Sesión de agente de voz	Sesión de traducción
Se conecta a `/v1/realtime`.	Se conecta a `/v1/realtime/translations`.
El modelo actúa como asistente.	El modelo actúa como intérprete.
Usa un ciclo de vida de conversación y respuesta.	Transmite de forma continua a partir del audio entrante.
Puede llamar a herramientas y generar turnos del asistente.	Genera audio traducido y fragmentos incrementales de transcripción.
Puedes llamar a `response.create`.	No llamas a `response.create`.

La traducción se inicia a partir del propio flujo de audio. Sigue agregando audio, incluidos los silencios entre frases, y procesa los eventos de salida a medida que llegan.

Elige un transporte

Usa WebRTC cuando el navegador capture o reproduzca audio. WebRTC envía el audio de origen como una pista multimedia y recibe la voz traducida como una pista de audio remota, por lo que no necesitas remuestrear ni reproducir fragmentos PCM manualmente.

Usa WebSockets cuando tu servidor ya reciba audio sin procesar, por ejemplo, de Twilio Media Streams, contenido multimedia SIP, ingesta de transmisiones o un proceso de trabajo multimedia. Con WebSockets, envía audio PCM16 a 24 kHz codificado en base64 y encárgate de reproducir los fragmentos incrementales de audio recibidos.

Crea una sesión WebRTC en el navegador

Para las aplicaciones de navegador, crea un secreto de cliente de corta duración en tu servidor. No expongas tu clave de API estándar en el navegador.

Crea un secreto de cliente para traducción

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());
});

En el navegador, captura audio, crea una conexión entre pares y envía la oferta SDP mediante una solicitud POST al punto de acceso de llamadas de traducción:

Conecta una llamada de traducción en el navegador

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(),
});

Crea una sesión WebSocket

Conéctate al punto de acceso dedicado de traducción y selecciona el modelo en la URL:

Antes de ejecutar este ejemplo, instala ws para Node.js, websocket-client para Python o async-websocket para Ruby (gem install async-websocket).

Conéctate a una sesión de traducción

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

Para Ruby, inserta los siguientes fragmentos de código para la configuración y la adición de audio dentro del bloque Async::WebSocket::Client.connect, después de la comprobación de que se creó la sesión y antes de que termine el bloque. Mantén la conexión abierta mientras envías audio y recibes eventos de traducción.

Configura el idioma de destino una vez que se abra el socket:

Configura el idioma de destino

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

Luego, agrega audio de forma continua:

Agrega audio de origen

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

Escucha los eventos de audio traducido y transcripciones:

Escucha los eventos de audio traducido y transcripciones

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"])

Cierra una sesión WebSocket

Cuando termine el flujo de origen, envía un evento session.close antes de cerrar el WebSocket. El evento indica al servicio que procese el audio de entrada pendiente, emita el audio traducido y la transcripción restantes y, luego, envíe un evento session.closed. El evento session.close solo se admite en las sesiones de traducción.

Después de enviar session.close, deja de agregar audio y sigue leyendo eventos en tu bucle de recepción habitual hasta recibir session.closed. Cerrar el socket de inmediato puede provocar la pérdida de la salida traducida que la sesión aún está enviando.

Cierra una sesión de traducción

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

Implementa la traducción para oyentes

Usa la traducción para oyentes cuando necesites ofrecer a una audiencia el audio traducido de una persona o transmisión de origen. Algunos ejemplos son las transmisiones en vivo, las charlas en conferencias, los seminarios web, las llamadas de presentación de resultados financieros, las clases y los videos.

La arquitectura habitual es:

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

Crea una sesión de traducción por cada idioma de destino. Si una misma fuente en inglés necesita salida en español y francés, crea una sesión de inglés a español y otra de inglés a francés.

Para las aplicaciones de traducción para oyentes que se ejecutan en el navegador, captura el audio de la pestaña con getDisplayMedia(), envíalo por WebRTC y reproduce la pista remota de audio traducido. Para las transmisiones en producción, ejecuta la traducción en un proceso de trabajo multimedia del servidor y publica pistas de audio traducido o subtítulos para los oyentes.

Implementa la traducción de conversaciones

Usa la traducción de conversaciones cuando dos o más participantes hablen en distintos idiomas. Algunos ejemplos son las llamadas de soporte, las llamadas de ventas, las tutorías y las salas de videollamadas.

Mantén separadas las pistas de audio de los participantes. Mezclar las voces en un solo flujo dificulta gestionar la identidad de cada hablante, sus subtítulos y las intervenciones simultáneas.

Para una llamada entre dos personas, crea una sesión de traducción por cada dirección:

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

En las salas grupales, la cantidad de sesiones depende de los hablantes activos y los idiomas de destino:

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

En las salas pequeñas, cada oyente puede crear componentes auxiliares de traducción en el navegador para los hablantes remotos que quiera escuchar traducidos. En las salas más grandes, usa un participante o un proceso de contenido multimedia del lado del servidor que se suscriba una sola vez a cada hablante de origen, cree una sesión de traducción por idioma de destino y vuelva a publicar las pistas traducidas.

Evaluar la calidad y la latencia

Prueba la traducción con audio real y una revisión bilingüe. Las métricas automatizadas pueden ayudar, pero no detectarán todos los errores que perciban los usuarios.

Evalúa:

la calidad de traducción para cada par de idiomas;
los nombres, números, fechas, monedas y números de teléfono;
la terminología específica del ámbito;
la alternancia de idiomas y las conversaciones que mezclan idiomas;
los acentos, el habla rápida y las voces superpuestas;
la latencia hasta recibir el primer audio traducido;
la latencia al finalizar el enunciado;
la sincronización de los subtítulos;
la consistencia de la voz;
el comportamiento al reconectarse.

Si tu caso de uso depende de la exactitud de los nombres o de los términos especializados, crea un conjunto de referencia antes del lanzamiento y revisa los errores manualmente.

Lista de verificación para producción

Elige WebRTC para el contenido multimedia del navegador y WebSockets para el contenido multimedia del servidor.
Usa el punto de acceso específico /v1/realtime/translations.
Transmite audio de forma continua, incluidos los silencios entre frases.
Usa session.close y espera a recibir session.closed antes de cerrar una sesión WebSocket.
Mantén separadas las pistas de los hablantes para la traducción de conversaciones.
Usa una sesión por idioma de salida.
Muestra las transcripciones tanto del idioma de origen como del de destino cuando sea útil.
Ofrece controles para el audio original, el audio traducido, los subtítulos, el silencio y el volumen.
Muestra los estados de reconexión, retraso y falta de disponibilidad.
Monitorea la latencia por separado de la calidad de traducción.

Descripción general de tiempo real y audio

Compara las sesiones de agentes de voz, traducción y transcripción.

Conexión WebRTC

Conecta el contenido multimedia del navegador a una sesión en tiempo real.

Conexión WebSocket

Transmite audio sin procesar a través de un flujo de procesamiento multimedia del lado del servidor.

Transcripción en tiempo real

Transmite actualizaciones incrementales de la transcripción a partir de audio en vivo.

Sugerencias

Primeros pasos

Conceptos fundamentales

SDK y CLI

Recursos

API heredadas

Elige un modelo

Texto y código

Diseño de prompts

Razonamiento

Imágenes y video

Tiempo real y audio

Modelos especializados

API de agentes

SDK de agentes

ChatKit

Búsqueda y recuperación

Conecta herramientas y datos

Crea flujos de trabajo con herramientas

Computadora y código

Contenido multimedia

GPT-Live

Realtime API

Desarrollar con voz

Conexiones

Procesamiento de audio

Pasa a producción

Rendimiento y calidad

Costo y rendimiento

Seguridad y gobernanza

Infraestructura y acceso

Operaciones

Conceptos fundamentales

Plan

Build

Test and publish

Conversion specs

Guías

Recursos

Primeros pasos

Guías

File Upload

API

Measurement

Advertiser API

Referencia de la API

Primeros pasos

Fundamentos

Explorar

Disponible en

Versiones

Flujos de trabajo

Capacidades

Referencia

Personalización

Archivo de configuración

Configuración de agentes

Ampliar las capacidades de ChatGPT y Codex

Linux

Windows

Flujos de trabajo de desarrollo

Extender y automatizar

Entornos

Crear con Codex

Integraciones de terceros

Referencia

Permisos

Codex Security

Seguridad cibernética

Primeros pasos

ChatGPT Work

Identidad y autenticación

Acceso, políticas y modelos del espacio de trabajo

Controles de complementos y conectores

Uso, gobernanza y cumplimiento

Implementación y proveedores de modelos

Comunidad

Blog

Comunidad

Blog