> This is a page from the ElevenLabs documentation. For a complete page index, fetch https://elevenlabs.io/docs/llms.txt. For the full documentation in a single file, fetch https://elevenlabs.io/docs/llms-full.txt.

# Compatibilidad con la API Realtime de OpenAI

ElevenLabs Realtime utiliza el mismo protocolo de comunicación que la API Realtime de OpenAI: los mismos eventos de cliente y servidor, mediante el mismo transporte WebSocket. Si ya tienes una aplicación creada con el SDK Realtime de OpenAI, puedes dirigirla a ElevenLabs Realtime en lugar de a `api.openai.com` sin cambiar de SDK.

> **Info**
>
> Esta guía abarca el flujo basado en navegador, en el que un pequeño paso en el servidor genera una credencial
> de corta duración y el navegador se conecta directamente a ElevenLabs Realtime.

## Modelos disponibles

| Nombre                  | Optimizado para            |
| ----------------------- | -------------------------- |
| Eleven Realtime v1 mini | Precio y velocidad         |
| Eleven Realtime v1 max  | Calidad y tareas complejas |

## Cómo funciona

1. Tu backend solicita a ElevenLabs un secreto de cliente de corta duración, limitado a una configuración de sesión específica.
2. Tu frontend pasa ese secreto de cliente al SDK Realtime de OpenAI en lugar de una clave de API de OpenAI.
3. El SDK se conecta mediante WebSocket a ElevenLabs Realtime y la conversación continúa usando los mismos eventos de cliente y servidor que la API Realtime de OpenAI.

## Genera un secreto de cliente

Solicita el secreto de cliente desde tu backend, no desde el navegador, para que tu clave de API de ElevenLabs nunca llegue al cliente.

[Crea una clave de API en el panel aquí](https://elevenlabs.io/app/api/api-keys), que usarás para [acceder a la API](/docs/es/api-reference/authentication) de forma segura.

Guarda la clave como un secreto gestionado y pásala a los SDK como variable de entorno mediante un archivo `.env` o directamente en la configuración de tu app, según prefieras.

**`.env`**

```js title=".env"
ELEVENLABS_API_KEY=<your_api_key_here>
```

```python
import os

from dotenv import load_dotenv
from elevenlabs import (
    CreateClientSecretRequest,
    ExpiresAfter,
    OpenAiAudioConfigInput,
    OpenAiAudioInputConfigInput,
    OpenAiAudioInputFormat,
    OpenAiAudioOutputConfigInput,
    OpenAiAudioOutputFormat,
    OpenAiSessionConfigInput,
    OpenAiTurnDetection,
)
from elevenlabs.client import ElevenLabs

load_dotenv()

elevenlabs = ElevenLabs(api_key=os.getenv("ELEVENLABS_API_KEY"))

client_secret = elevenlabs.conversational_ai.realtime.create_client_secret(
    request=CreateClientSecretRequest(
        session=OpenAiSessionConfigInput(
            type="realtime",
            model="eleven_realtime_v1_mini",
            instructions="You are a helpful, friendly voice assistant. Keep replies concise.",
            output_modalities=["audio"],
            audio=OpenAiAudioConfigInput(
                input=OpenAiAudioInputConfigInput(
                    format=OpenAiAudioInputFormat(type="audio/pcm", rate=24000),
                    turn_detection=OpenAiTurnDetection(type="semantic_vad", eagerness="medium"),
                ),
                output=OpenAiAudioOutputConfigInput(
                    format=OpenAiAudioOutputFormat(type="audio/pcm"),
                    voice="brian",
                ),
            ),
        ),
        expires_after=ExpiresAfter(anchor="created_at", seconds=600),
    ),
)
```

```typescript
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

process.loadEnvFile();

const elevenlabs = new ElevenLabsClient();

const clientSecret = await elevenlabs.conversationalAi.realtime.createClientSecret({
  session: {
    type: "realtime",
    model: "eleven_realtime_v1_mini",
    instructions: "You are a helpful, friendly voice assistant. Keep replies concise.",
    outputModalities: ["audio"],
    audio: {
      input: {
        format: { type: "audio/pcm", rate: 24000 },
        turnDetection: { type: "semantic_vad", eagerness: "medium" },
      },
      output: {
        format: { type: "audio/pcm" },
        voice: "brian",
      },
    },
  },
  expiresAfter: { anchor: "created_at", seconds: 600 },
});
```

La respuesta contiene `value` (la credencial efímera que usará tu frontend), su fecha de caducidad y la `session` negociada. Devuelve solo `value` al navegador.

> **Note**
>
> Una cadena `model` selecciona directamente el comportamiento del agente, en lugar de hacer referencia a un `agent_id` del
> panel de control. La configuración de sesión que envías al generar el secreto de cliente es la
> sesión inicial autorizada para esa credencial.

## Conéctate desde el navegador

Pasa el secreto de cliente al SDK Realtime de OpenAI (`@openai/agents-realtime`) como clave de API y dirige el transporte WebSocket a la ruta de API de ElevenLabs en lugar de a la predeterminada de OpenAI.

```typescript
import { OpenAIRealtimeWebSocket, RealtimeAgent, RealtimeSession } from "@openai/agents-realtime";

const { value: clientSecret } = await fetch("/api/token").then((res) => res.json());

const agent = new RealtimeAgent({
  name: "ElevenLabs agent",
  instructions: "You are a helpful, friendly voice assistant. Keep replies concise.",
});

const transport = new OpenAIRealtimeWebSocket({
  url: "wss://api.elevenlabs.io/v1/convai/realtime",
});

const session = new RealtimeSession(agent, {
  transport,
  model: "eleven_realtime_v1_mini",
  config: {
    outputModalities: ["audio"],
    audio: { output: { voice: "brian" } },
  },
});

await session.connect({ apiKey: clientSecret });
```

El SDK solo conecta el audio automáticamente para su transporte WebRTC. Con WebSocket, captura y reproduce tú mismo audio PCM16 a 24 kHz, por ejemplo con [`wavtools`](https://www.npmjs.com/package/wavtools), el mismo asistente que OpenAI utiliza en sus propios ejemplos de WebSocket.

## Limitaciones

Esta guía abarca la conexión directa desde un navegador. La documentación para conectarse desde SDKs Realtime de OpenAI del lado del servidor aún no está publicada.

## Preguntas frecuentes

#### ¿Cuándo debería usar modelos Realtime?

Los modelos Realtime son la forma más rápida de empezar a incorporar voz a un producto. Eleven Realtime v1
mini está optimizado para precio y velocidad; Eleven Realtime v1 max está optimizado para calidad y tareas
más complejas.

#### ¿Cuál es la arquitectura en la que se basan los modelos Realtime?

Eleven Realtime v1 mini y max utilizan una arquitectura en cascada, optimizada de extremo a extremo para que cada
componente funcione de la mejor manera como parte de un único sistema.

#### ¿Cómo se comparan con seleccionar los modelos de componentes en ElevenAgents?

Los detalles de los modelos subyacentes no son públicos. Cada componente utiliza las últimas
investigaciones de ElevenLabs y está optimizado para funcionar mejor en conjunto dentro de los modelos Realtime.

#### ¿Los modelos Realtime son modelos fusionados?

No. Los modelos Realtime utilizan una arquitectura en cascada: cada componente es un modelo distinto, creado con las
últimas investigaciones de ElevenLabs y optimizado para funcionar mejor en conjunto.