Traducción en tiempo real

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

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

Diferencias entre las sesiones de traducción y las de agentes de voz

Las sesiones de traducción de Realtime tienen una arquitectura distinta a 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.
Gestiona el ciclo de vida de la conversación y de las respuestas.	Traduce de forma continua a medida que recibe audio.
Puede invocar herramientas y generar intervenciones del asistente.	Genera audio traducido y fragmentos de la transcripción.
Puedes llamar a `response.create`.	No llamas a `response.create`.

La traducción comienza con el propio flujo de audio. Sigue enviando audio, incluidos los silencios entre frases, y procesa los eventos de salida a medida que lleguen.

Elegir un protocolo de transporte

Usa WebRTC cuando el navegador capture o reproduzca audio. WebRTC envía el audio original como una pista multimedia y recibe la voz traducida como una pista de audio remota. Así evitas tener que remuestrear o reproducir manualmente los fragmentos de audio PCM.

Usa WebSockets cuando tu servidor ya reciba audio sin procesar, por ejemplo, de Twilio Media Streams, de flujos multimedia SIP, de un sistema de recepción de transmisiones o de un proceso multimedia. Con WebSockets, envía audio PCM16 a 24 kHz codificado en base64 y encárgate de reproducir los fragmentos de audio que recibas.

Crear una sesión WebRTC en el navegador

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

Crear 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 el audio, crea una conexión entre pares y envía la oferta SDP mediante una solicitud POST al punto de acceso para llamadas de traducción.

Conectar una llamada de traducción desde 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(),
});

Crear una sesión WebSocket

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

Antes de ejecutar este ejemplo, instala ws para Node.js, websocket-client y sounddevice para Python o async-websocket para Ruby (gem install async-websocket). Para Java, agrega la dependencia de Maven com.openai:openai-java:4.75.1.

Los ejemplos de Java muestran por separado cómo establecer la conexión, configurar el idioma y enviar el audio de entrada. El SDK de Java permite recibir eventos y finalizar una sesión, pero esta guía no incluye ejemplos de Java para esos pasos. Para seguir el flujo de traducción completo que se describe a continuación, usa los ejemplos de Node.js o Python.

Conectarse 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
16ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
defer cancel()
client := openai.NewClient()
session, err := client.Realtime.ConnectTranslation(ctx, "gpt-realtime-translate", realtime.TranslationConnectionOptions{}, option.WithHeader("OpenAI-Safety-Identifier", "hashed-user-id"))
if err != nil {
	return err
}
defer session.Abort()
created, err := session.Recv(ctx)
if err != nil {
	return err
}
fmt.Println(created.Type)
if created.Type != "session.created" {
	return fmt.Errorf("expected session.created, got %s", created.Type)
}

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
32import com.openai.client.okhttp.OkHttpClient;
import com.openai.core.ClientOptions;
import com.openai.helpers.TranslationConnection;
import com.openai.helpers.TranslationWebSocketOptions;
import com.openai.models.realtime.*;

var http = OkHttpClient.builder().build();
var options =
    ClientOptions.builder()
        .fromEnv()
        .httpClient(http)
        .putHeader("OpenAI-Safety-Identifier", "hashed-user-id")
        .build();
try (http;
    var connection =
        TranslationConnection.connect(
            options,
            TranslationWebSocketOptions.builder()
                .model("gpt-realtime-translate")
                .sendTimeout(java.time.Duration.ofSeconds(30))
                .build())) {
  while (true) {
    var event = connection.receive();
    if (event.error().isPresent())
      throw new IllegalStateException(event.error().orElseThrow().toString());
    if (event.sessionCreated().isPresent()) {
      System.out.println("Connected to translation session.");
      System.out.println(event);
      break;
    }
  }
}

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

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

El ejemplo de conexión en Java cierra el socket cuando termina el bloque try. Los ejemplos de configuración y entrada de audio en Java requieren una TranslationConnection abierta. Mantenla abierta mientras envías audio y recibes la salida. Antes de salir del bloque, finaliza la sesión y lee todos sus eventos hasta recibir session.closed, como se describe en Cerrar una sesión WebSocket.

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

Configurar 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
2
3
4
5
6
7
8
9if err := session.Send(ctx, realtime.RealtimeTranslationClientEventParamOfSessionUpdate(realtime.RealtimeTranslationSessionUpdateRequestParam{
	Audio: realtime.RealtimeTranslationSessionUpdateRequestAudioParam{
		Output: realtime.RealtimeTranslationSessionUpdateRequestAudioOutputParam{
			Language: openai.String("es"),
		},
	},
})); err != nil {
	return err
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20import com.openai.client.okhttp.OkHttpClient;
import com.openai.core.ClientOptions;
import com.openai.helpers.TranslationConnection;
import com.openai.helpers.TranslationWebSocketOptions;
import com.openai.models.realtime.*;

connection.send(
    RealtimeTranslationClientEvent.ofSessionUpdate(
        RealtimeTranslationSessionUpdateEvent.builder()
            .session(
                RealtimeTranslationSessionUpdateRequest.builder()
                    .audio(
                        RealtimeTranslationSessionUpdateRequest.Audio.builder()
                            .output(
                                RealtimeTranslationSessionUpdateRequest.Audio.Output.builder()
                                    .language("es")
                                    .build())
                            .build())
                    .build())
            .build()));

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

Luego, agrega audio de forma continua.

Agregar audio original

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// audio contains mono PCM16 samples at 24 kHz.
for start := 0; start < len(audio); start += 4800 {
	end := min(start+4800, len(audio))
	if err := session.Send(ctx, realtime.RealtimeTranslationClientEventParamOfSessionInputAudioBufferAppend(base64.StdEncoding.EncodeToString(audio[start:end]))); err != nil {
		return err
	}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14import com.openai.client.okhttp.OkHttpClient;
import com.openai.core.ClientOptions;
import com.openai.helpers.TranslationConnection;
import com.openai.helpers.TranslationWebSocketOptions;
import com.openai.models.realtime.*;
import java.util.Base64;

// Call for each PCM16, 24 kHz, mono chunk supplied by your audio source.
static void appendAudio(TranslationConnection connection, byte[] pcmAudio) {
  String base64Pcm16 = Base64.getEncoder().encodeToString(pcmAudio);
  connection.send(
      RealtimeTranslationClientEvent.ofSessionInputAudioBufferAppend(
          RealtimeTranslationInputAudioBufferAppendEvent.builder().audio(base64Pcm16).build()));
}

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 que contienen el audio traducido y las transcripciones.

Escuchar eventos de audio traducido y transcripción

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
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
50import base64
import json
from concurrent.futures import ThreadPoolExecutor
from contextlib import suppress
from queue import SimpleQueue

import sounddevice as sd

audio_queue = SimpleQueue()


def play_audio():
    try:
        # Closing the stream waits for PortAudio's pending buffers to finish.
        with sd.RawOutputStream(samplerate=24000, channels=1, dtype="int16") as stream:
            while (pcm := audio_queue.get()) is not None:
                stream.write(pcm)
    except Exception:
        # The receiver may have already closed the socket.
        with suppress(OSError):
            ws.abort()  # Wake recv() so the receiver can report the playback failure.
        raise


with ThreadPoolExecutor(max_workers=1) as executor:
    playback = executor.submit(play_audio)
    try:
        while True:
            event = json.loads(ws.recv())
            if playback.done():
                playback.result()  # Report a playback failure on the receiver.

            if event["type"] == "session.output_audio.delta":
                audio_queue.put(base64.b64decode(event["delta"]))

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

            if event["type"] == "error":
                raise RuntimeError(f"Translation error: {event['error']['code']}")

            if event["type"] == "session.closed":
                break
    finally:
        ws.close()
        audio_queue.put(None)
        playback.result()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24// Run this listener while another goroutine sends audio into the session.
func listen(ctx context.Context, session *realtime.TranslationSession) error {
	for {
		event, err := session.Recv(ctx)
		if err != nil {
			return err
		}
		switch event.Type {
		case "error":
			return fmt.Errorf("translation error: %s", event.OfRealtimeErrorEvent.Error.Message)
		case "session.output_transcript.delta":
			fmt.Print(event.OfRealtimeTranslationOutputTranscriptDeltaEvent.Delta)
		case "session.output_audio.delta":
			pcm, err := base64.StdEncoding.DecodeString(event.OfRealtimeTranslationOutputAudioDeltaEvent.Delta)
			if err != nil {
				return err
			}
			// Feed pcm into your application's 24 kHz audio player.
			fmt.Fprintln(log.Writer(), "Received audio bytes:", len(pcm))
		case "session.closed":
			return session.Close()
		}
	}
}

En Go, ejecuta listen en paralelo con el envío de audio. Esta función cierra la conexión de transporte después de recibir session.closed.

Cerrar una sesión WebSocket

Cuando termine el flujo de audio original, envía un evento session.close antes de cerrar el WebSocket. El evento le indica al servicio que procese el audio de entrada pendiente, emita el audio traducido y la transcripción que queden por enviar 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 habitual de recepción hasta que recibas session.closed. Si cierras el socket de inmediato, puedes perder parte de la traducción que la sesión aún está enviando.

Cerrar 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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59let translationSessionClosing = false;
let gotTranslationClosed = false;
let drainDeadline;

ws.on("close", () => {
  clearTimeout(drainDeadline);
  if (!gotTranslationClosed) {
    console.error("Translation disconnected before final session.closed");
    process.exitCode = 1;
  }
});

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

  translationSessionClosing = true;
  // Adjust this deadline for your application's finalization requirements.
  drainDeadline = setTimeout(() => {
    console.error("Translation finalization timed out");
    process.exitCode = 1;
    ws.close();
  }, 15_000);
  ws.send(JSON.stringify({ type: "session.close" }));
}

// Use this in place of the earlier output handler, so audio plays only once.
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 === "error") {
    clearTimeout(drainDeadline);
    console.error("Translation error", event.error?.code);
    process.exitCode = 1;
    ws.close();
  }

  if (event.type === "session.closed") {
    clearTimeout(drainDeadline);
    gotTranslationClosed = true;
    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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76import base64
import json
import time
from concurrent.futures import ThreadPoolExecutor
from contextlib import suppress
from queue import SimpleQueue

import sounddevice as sd

audio_queue = SimpleQueue()


def play_audio():
    try:
        # Closing the stream waits for PortAudio's pending buffers to finish.
        with sd.RawOutputStream(samplerate=24000, channels=1, dtype="int16") as stream:
            while (pcm := audio_queue.get()) is not None:
                stream.write(pcm)
    except Exception:
        # The receiver may have already closed the socket.
        with suppress(OSError):
            ws.abort()  # Wake recv() so the receiver can report the playback failure.
        raise


translation_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"}))


with ThreadPoolExecutor(max_workers=1) as executor:
    playback = executor.submit(play_audio)
    try:
        # Call this when the source stream ends.
        close_translation_session()
        # Adjust this deadline for your application's finalization requirements.
        drain_deadline = time.monotonic() + 15.0

        while True:
            remaining = drain_deadline - time.monotonic()
            if remaining <= 0:
                raise TimeoutError("Translation finalization timed out")
            ws.settimeout(remaining)
            data = ws.recv()
            if not data:
                raise RuntimeError("Translation disconnected before session.closed")
            event = json.loads(data)
            if playback.done():
                playback.result()  # Report a playback failure on the receiver.

            if event["type"] == "error":
                raise RuntimeError(f"Translation error: {event['error']['code']}")

            if event["type"] == "session.output_audio.delta":
                audio_queue.put(base64.b64decode(event["delta"]))

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

            if event["type"] == "session.closed":
                break
    finally:
        # The server deadline covers receiving events, not local playback.
        ws.close()
        audio_queue.put(None)
        playback.result()

1
2
3
4
5
6// Stop sending audio first. The listener closes the transport after session.closed.
if err := session.Send(ctx, realtime.RealtimeTranslationClientEventUnionParam{
	OfSessionClose: &realtime.RealtimeTranslationSessionCloseEventParam{},
}); err != nil {
	return err
}

Implementar la traducción para una audiencia

Usa esta modalidad cuando necesites traducir para una audiencia el audio de una sola persona o de una sola transmisión. Algunos ejemplos son las transmisiones en vivo, las ponencias en conferencias, los seminarios web, las llamadas de presentación de resultados financieros, las clases y los videos.

Esta es la arquitectura habitual.

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

Crea una sesión de traducción por cada idioma de destino. Si necesitas traducir el mismo audio en inglés al español y al francés, crea una sesión de inglés a español y otra de inglés a francés.

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

Implementar la traducción de conversaciones

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

Mantén separadas las pistas de audio de los participantes. Mezclar las voces en un solo flujo dificulta identificar a cada persona, asignarle los subtítulos que le corresponden y procesar el audio cuando varias personas hablan a la vez.

Para una llamada entre dos personas, crea una sesión de traducción para cada sentido.

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 cuántas personas estén hablando y de los idiomas de destino.

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

En salas pequeñas, cada oyente puede crear en su navegador procesos auxiliares de traducción para los participantes remotos a quienes quiera escuchar en su idioma. En salas más grandes, usa un participante o un proceso multimedia que se ejecute en el servidor, se suscriba una sola vez a la pista de cada persona que habla, 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 pide a personas bilingües que la revisen. Las métricas automatizadas pueden ayudar, pero hay errores que los usuarios notarán aunque las métricas no los detecten.

Evalúa los siguientes aspectos.

La calidad de la traducción para cada par de idiomas.
La traducción de nombres, números, fechas, monedas y números de teléfono.
El manejo de la terminología especializada.
Los cambios de idioma y las conversaciones en las que se mezclan idiomas.
El manejo de acentos, del habla rápida y de voces que se superponen.
La latencia hasta recibir el primer fragmento de audio traducido.
La latencia al final de cada intervención.
La sincronización de los subtítulos.
La consistencia de la voz.
El comportamiento durante la reconexión.

Si tu caso de uso exige reproducir con exactitud los nombres o los términos especializados, prepara un conjunto de pruebas de referencia antes del lanzamiento y revisa los errores manualmente.

Lista de verificación para producción

Elige WebRTC para los flujos multimedia del navegador y WebSockets para los del servidor.
Usa el punto de acceso dedicado /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 cada participante al traducir conversaciones.
Usa una sesión por idioma de destino.
Muestra tanto la transcripción original como la traducida cuando sea útil.
Ofrece controles para el audio original, el audio traducido, los subtítulos, el silencio y el volumen.
Indica cuándo hay una reconexión en curso, un retraso o falta de disponibilidad.
Mide la latencia por separado de la calidad de la traducción.

Guías relacionadas

Introducción a Realtime y al audio

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

Conexión mediante WebRTC

Conecta los flujos multimedia del navegador a una sesión en tiempo real.

Conexión mediante WebSocket

Transmite audio sin procesar mediante un flujo de procesamiento multimedia en el servidor.

Transcripción en tiempo real

Transmite fragmentos de la transcripción a medida que se recibe el audio en vivo.

Sugerencias

Primeros pasos

Conceptos fundamentales

SDK y CLI

Proveedores de servicios en la nube

Recursos

API heredadas

Elige un modelo

Texto y código

Redacción de prompts

Razonamiento

Imágenes

Tiempo real y audio

Modelos especializados

API de agentes

Agents SDK

ChatKit

Búsqueda y recuperación de información

Conecta herramientas y datos

Crea flujos de trabajo con herramientas

Computadora y código

Multimedia

GPT-Live

Realtime API

Desarrollar aplicaciones de voz

Conexiones

Procesamiento de audio

Pasa a producción

Rendimiento y calidad

Evaluación

Costo y rendimiento

Seguridad y gobernanza

Infraestructura y acceso

Operaciones

Conceptos básicos

Planificación

Desarrollo

Pruebas y publicación

Especificaciones de conversión

Guías

Recursos

Identidad

Uso del plan de ChatGPT

Guías

Carga de archivos

API

Medición

API para anunciantes

Referencia de la API

Primeros pasos

Primeros pasos

Fundamentos

Explorar

Disponible en

Versiones

Flujos de trabajo

Capacidades

Sites

dots

ChatGPT Espacio

Referencia

Personalización

Archivo de configuración

Configuración de agentes

Ampliar las funciones de ChatGPT y Codex

Linux

Windows

Flujos de trabajo de desarrollo

Ampliar funciones y automatizar

Entornos

Codex Cloud

Desarrollar con Codex

Integraciones de terceros

Referencia

Permisos

Codex Security

Ciberseguridad

Primeros pasos

Configuración de funciones

Identidad y acceso