> 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.

# Kompatibilitet med OpenAI Realtime API

ElevenLabs Realtime använder samma trådprotokoll som OpenAI:s Realtime API: samma klient- och serverhändelser över samma WebSocket-transport. Om du redan har en app byggd med OpenAI:s Realtime SDK kan du peka den mot ElevenLabs Realtime i stället för `api.openai.com` utan att byta SDK.

> **Info**
>
> Den här guiden beskriver flödet i webbläsaren, där ett litet steg på serversidan skapar en kortlivad
> autentiseringsuppgift och webbläsaren ansluter direkt till ElevenLabs Realtime.

## Tillgängliga modeller

| Namn                    | Optimerad för                   |
| ----------------------- | ------------------------------- |
| Eleven Realtime v1 mini | Pris och hastighet              |
| Eleven Realtime v1 max  | Kvalitet och komplexa uppgifter |

## Så fungerar det

1. Din backend begär en kortlivad klienthemlighet från ElevenLabs, avgränsad till en specifik sessionskonfiguration.
2. Din frontend skickar klienthemligheten till OpenAI:s Realtime SDK i stället för en OpenAI API-nyckel.
3. SDK:t ansluter via WebSocket till ElevenLabs Realtime, och konversationen fortsätter med samma klient- och serverhändelser som OpenAI:s Realtime API.

## Skapa en klienthemlighet

Begär klienthemligheten från din backend, inte från webbläsaren, så att din ElevenLabs API-nyckel aldrig når klienten.

[Skapa en API-nyckel i dashboarden här](https://elevenlabs.io/app/api/api-keys), som du använder för att säkert [få åtkomst till API:t](/docs/sv/api-reference/authentication).

Spara nyckeln som en hanterad hemlighet och skicka den till SDK:erna antingen som en miljövariabel via en `.env`-fil eller direkt i appens konfiguration, beroende på vad du föredrar.

**`.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 },
});
```

Svaret innehåller `value` (den tillfälliga autentiseringsuppgift som din frontend använder), dess utgångstid och den förhandlade `session`. Returnera endast `value` till webbläsaren.

> **Note**
>
> En `model`-sträng väljer agentens beteende direkt, i stället för att referera till ett `agent_id` från
> dashboarden. Sessionskonfigurationen som du skickar när du skapar klienthemligheten är den
> auktoritativa startsessionen för den autentiseringsuppgiften.

## Anslut från webbläsaren

Skicka klienthemligheten till OpenAI:s Realtime SDK (`@openai/agents-realtime`) som API-nyckel och peka WebSocket-transporten mot ElevenLabs slutpunkt i stället för OpenAI:s standardalternativ.

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

SDK:t kopplar automatiskt ljud endast för sin WebRTC-transport. Via WebSocket behöver du själv spela in och spela upp PCM16-ljud i 24 kHz, till exempel med [`wavtools`](https://www.npmjs.com/package/wavtools), samma hjälpfunktion som OpenAI använder i sina egna WebSocket-exempel.

## Begränsningar

Den här guiden beskriver direktanslutning från en webbläsare. Dokumentation för anslutning från OpenAI Realtime SDK:er på serversidan har inte publicerats ännu.

## Vanliga frågor

#### När ska jag använda Realtime-modeller?

Realtime-modeller är det snabbaste sättet att börja bygga in röst i en produkt. Eleven Realtime v1
mini är optimerad för pris och hastighet, medan Eleven Realtime v1 max är optimerad för kvalitet och mer
komplexa uppgifter.

#### Vilken arkitektur ligger till grund för Realtime-modeller?

Eleven Realtime v1 mini och max använder en kaskadarkitektur, optimerad från början till slut så att varje
komponent fungerar bäst som del av ett enda system.

#### Hur jämför de sig med att välja komponentmodellerna i ElevenAgents?

Detaljerna om de underliggande modellerna är inte offentliga. Varje komponent använder ElevenLabs senaste
forskning och är optimerad för att fungera bäst tillsammans i Realtime-modeller.

#### Är Realtime-modeller sammanslagna modeller?

Nej. Realtime-modeller använder en kaskadarkitektur: varje komponent är en separat modell, byggd med
ElevenLabs senaste forskning och optimerad för att fungera bäst tillsammans.