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

# OpenAI Realtime API संगतता

ElevenLabs Realtime, OpenAI के Realtime API जैसा ही वायर प्रोटोकॉल इस्तेमाल करता है: वही क्लाइंट और सर्वर इवेंट्स, उसी WebSocket ट्रांसपोर्ट पर। अगर आपका ऐप पहले से OpenAI के Realtime SDK के साथ बना है, तो SDK बदले बिना आप इसे `api.openai.com` की जगह ElevenLabs Realtime पर पॉइंट कर सकते हैं।

> **Info**
>
> यह गाइड ब्राउज़र-आधारित फ़्लो के बारे में है, जिसमें सर्वर-साइड का एक छोटा चरण कम अवधि के लिए मान्य
> क्रेडेंशियल बनाता है और ब्राउज़र सीधे ElevenLabs Realtime से कनेक्ट होता है।

## उपलब्ध मॉडल

| नाम                     | इनके लिए ऑप्टिमाइज़्ड  |
| ----------------------- | ---------------------- |
| Eleven Realtime v1 mini | कीमत और गति            |
| Eleven Realtime v1 max  | गुणवत्ता और जटिल कार्य |

## यह कैसे काम करता है

1. आपका बैकएंड किसी खास सेशन कॉन्फ़िगरेशन तक सीमित, कम अवधि के लिए मान्य क्लाइंट सीक्रेट का अनुरोध ElevenLabs से करता है।
2. आपका फ़्रंटएंड उस क्लाइंट सीक्रेट को OpenAI API कुंजी की जगह OpenAI के Realtime SDK को देता है।
3. SDK, WebSocket के ज़रिए ElevenLabs Realtime से कनेक्ट होता है और बातचीत OpenAI के Realtime API जैसे ही क्लाइंट और सर्वर इवेंट्स का इस्तेमाल करके आगे बढ़ती है।

## क्लाइंट सीक्रेट बनाएं

क्लाइंट सीक्रेट का अनुरोध अपने बैकएंड से करें, ब्राउज़र से नहीं, ताकि आपकी ElevenLabs API कुंजी कभी क्लाइंट तक न पहुंचे।

[डैशबोर्ड में यहां API कुंजी बनाएं](https://elevenlabs.io/app/api/api-keys), जिसका इस्तेमाल आप सुरक्षित रूप से [API एक्सेस करने](/docs/hi/api-reference/authentication) के लिए करेंगे।

अपनी पसंद के अनुसार, कुंजी को मैनेज्ड सीक्रेट के रूप में स्टोर करें और इसे SDKs को `.env` फ़ाइल के ज़रिए एनवायरनमेंट वेरिएबल के रूप में या सीधे अपने ऐप के कॉन्फ़िगरेशन में भेजें।

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

रिस्पॉन्स में `value` (वह अस्थायी क्रेडेंशियल जिसका आपका फ़्रंटएंड इस्तेमाल करेगा), इसकी समाप्ति का समय और तय किया गया `session` शामिल होता है। ब्राउज़र को सिर्फ़ `value` लौटाएं।

> **Note**
>
> `model` स्ट्रिंग डैशबोर्ड के `agent_id` को रेफ़र करने के बजाय सीधे एजेंट का व्यवहार चुनती है।
> क्लाइंट सीक्रेट बनाते समय भेजा गया सेशन कॉन्फ़िगरेशन उस क्रेडेंशियल के लिए
> आधिकारिक शुरुआती सेशन होता है।

## ब्राउज़र से कनेक्ट करें

क्लाइंट सीक्रेट को OpenAI के Realtime SDK (`@openai/agents-realtime`) में API कुंजी के रूप में पास करें और WebSocket ट्रांसपोर्ट को डिफ़ॉल्ट OpenAI एंडपॉइंट की जगह ElevenLabs एंडपॉइंट पर पॉइंट करें।

```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 अपने WebRTC ट्रांसपोर्ट के लिए ही ऑडियो को अपने-आप कनेक्ट करता है। WebSocket पर PCM16 ऑडियो को 24kHz पर खुद कैप्चर और प्ले करें, उदाहरण के लिए [`wavtools`](https://www.npmjs.com/package/wavtools) के साथ। यही हेल्पर OpenAI अपने WebSocket उदाहरणों में इस्तेमाल करता है।

## सीमाएं

यह गाइड ब्राउज़र से सीधे कनेक्ट करने के बारे में है। सर्वर-साइड OpenAI Realtime SDKs से कनेक्ट करने का दस्तावेज़ अभी प्रकाशित नहीं हुआ है।

## अक्सर पूछे जाने वाले सवाल

#### मुझे Realtime मॉडल कब इस्तेमाल करने चाहिए?

किसी प्रोडक्ट में वॉइस बनाना शुरू करने का सबसे तेज़ तरीका Realtime मॉडल हैं। Eleven Realtime v1
mini कीमत और गति के लिए ऑप्टिमाइज़्ड है; Eleven Realtime v1 max गुणवत्ता और अधिक
जटिल कार्यों के लिए ऑप्टिमाइज़्ड है।

#### Realtime मॉडल के पीछे कौन-सा आर्किटेक्चर है?

Eleven Realtime v1 mini और max कैस्केडेड आर्किटेक्चर का इस्तेमाल करते हैं, जो एंड-टू-एंड इस तरह
ऑप्टिमाइज़्ड है कि हर कंपोनेंट एक ही सिस्टम के हिस्से के रूप में सबसे बेहतर काम करे।

#### इनकी तुलना ElevenAgents में कंपोनेंट मॉडल चुनने से कैसे होती है?

इनके आधारभूत मॉडलों की खास जानकारी सार्वजनिक नहीं है। हर कंपोनेंट ElevenLabs के नवीनतम
शोध का इस्तेमाल करता है और Realtime मॉडलों में साथ मिलकर सबसे बेहतर काम करने के लिए ऑप्टिमाइज़्ड है।

#### क्या Realtime मॉडल फ़्यूज़्ड मॉडल हैं?

नहीं। Realtime मॉडल कैस्केडेड आर्किटेक्चर का इस्तेमाल करते हैं: हर कंपोनेंट एक अलग मॉडल है, जिसे
ElevenLabs के नवीनतम शोध के साथ बनाया गया है और साथ मिलकर सबसे बेहतर काम करने के लिए ऑप्टिमाइज़्ड किया गया है।