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

# एजेंट ऑथेंटिकेशन

## परिचय

कन्वर्सेशनल एजेंट बनाते समय, आपको कुछ एजेंट या बातचीत का एक्सेस सीमित करना पड़ सकता है। ElevenLabs कई ऑथेंटिकेशन तरीके देता है, ताकि सिर्फ़ अधिकृत यूज़र ही आपके एजेंट्स से इंटरैक्ट कर सकें।

## ऑथेंटिकेशन के तरीके

ElevenLabs आपके कन्वर्सेशनल एजेंट्स को सुरक्षित रखने के लिए दो मुख्य तरीके देता है:

#### [साइन्ड URLs](#using-signed-urls)

API keys दिखाए बिना सुरक्षित क्लाइंट-साइड कनेक्शन के लिए अस्थायी ऑथेंटिकेटेड URLs जनरेट करें।

#### [अलाउलिस्ट](#using-allowlists)

उन खास डोमेन या होस्टनेम तक एक्सेस सीमित करें जो आपके एजेंट से कनेक्ट हो सकते हैं।

## साइन्ड URLs का इस्तेमाल

क्लाइंट-साइड ऐप्लिकेशन के लिए साइन्ड URLs सुझाया गया तरीका है। इससे आप अपनी API key दिखाए बिना यूज़र्स को ऑथेंटिकेट कर सकते हैं।

> **Note**
>
> नीचे दिए गए गाइड में [JS client](https://www.npmjs.com/package/@elevenlabs/client) और
> [Python SDK](https://github.com/elevenlabs/elevenlabs-python/) का इस्तेमाल किया गया है।

### साइन्ड URLs कैसे काम करते हैं

1. आपका सर्वर आपकी API key का इस्तेमाल करके ElevenLabs से साइन्ड URL मांगता है।
2. ElevenLabs एक अस्थायी टोकन जनरेट करता है और साइन्ड WebSocket URL लौटाता है।
3. आपका क्लाइंट ऐप्लिकेशन WebSocket कनेक्शन बनाने के लिए इस साइन्ड URL का इस्तेमाल करता है।
4. साइन्ड URL 15 मिनट बाद एक्सपायर हो जाता है।

> **Warning**
>
> अपनी ElevenLabs API key को कभी भी क्लाइंट-साइड पर न दिखाएं।

### API से साइन्ड URL जनरेट करें

साइन्ड URL पाने के लिए, अपने एजेंट ID के साथ `get_signed_url` [endpoint](/docs/hi/eleven-agents/api-reference/conversations/get-signed-url) पर रिक्वेस्ट करें:

```python
# Server-side code using the Python SDK
from elevenlabs.client import ElevenLabs
async def get_signed_url():
    try:
        elevenlabs = ElevenLabs(api_key="your-api-key")
        response = await elevenlabs.conversational_ai.conversations.get_signed_url(agent_id="agent_7101k5zvyjhmfg983brhmhkd98n6")
        return response.signed_url
    except Exception as error:
        print(f"Error getting signed URL: {error}")
        raise
```

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

// Server-side code using the JavaScript SDK
const elevenlabs = new ElevenLabsClient({ apiKey: "your-api-key" });
async function getSignedUrl() {
  try {
    const response = await elevenlabs.conversationalAi.conversations.getSignedUrl({
      agentId: "agent_7101k5zvyjhmfg983brhmhkd98n6",
    });

    return response.signed_url;
  } catch (error) {
    console.error("Error getting signed URL:", error);
    throw error;
  }
}
```

```bash
curl -X GET "https://api.elevenlabs.io/v1/convai/conversation/get-signed-url?agent_id=agent_7101k5zvyjhmfg983brhmhkd98n6" \
-H "xi-api-key: your-api-key"
```

curl रिस्पॉन्स का फ़ॉर्मैट इस तरह होता है:

```json
{
  "signed_url": "wss://api.elevenlabs.io/v1/convai/conversation?agent_id=agent_7101k5zvyjhmfg983brhmhkd98n6&conversation_signature=your-token"
}
```

### साइन्ड URL से अपने एजेंट से कनेक्ट करना

क्लाइंट से सर्वर द्वारा जनरेट किया गया साइन्ड URL प्राप्त करें और WebSocket से कनेक्ट करने के लिए उसका इस्तेमाल करें।

```python
# Client-side code using the Python SDK
from elevenlabs.conversational_ai.conversation import (
    Conversation,
    AudioInterface,
    ClientTools,
    ConversationInitiationData
)
import os
from elevenlabs.client import ElevenLabs
api_key = os.getenv("ELEVENLABS_API_KEY")

elevenlabs = ElevenLabs(api_key=api_key)

conversation = Conversation(
  client=elevenlabs,
  agent_id=os.getenv("AGENT_ID"),
  requires_auth=True,
  audio_interface=AudioInterface(),
  config=ConversationInitiationData()
)

async def start_conversation():
  try:
    signed_url = await get_signed_url()
    conversation = Conversation(
      client=elevenlabs,
      url=signed_url,
    )

    conversation.start_session()
  except Exception as error:
    print(f"Failed to start conversation: {error}")

```

```javascript
// Client-side code using the JavaScript SDK
import { Conversation } from "@elevenlabs/client";

async function startConversation() {
  try {
    const signedUrl = await getSignedUrl();
    const conversation = await Conversation.startSession({
      signedUrl,
    });

    return conversation;
  } catch (error) {
    console.error("Failed to start conversation:", error);
    throw error;
  }
}
```

### साइन्ड URL की एक्सपायरी

साइन्ड URLs 15 मिनट तक मान्य रहते हैं। बातचीत का सेशन ज़्यादा समय तक चल सकता है, लेकिन बातचीत 15 मिनट की अवधि के भीतर शुरू होनी चाहिए।

## अलाउलिस्ट का इस्तेमाल

अलाउलिस्ट, मूल डोमेन के आधार पर आपके कन्वर्सेशनल एजेंट्स का एक्सेस सीमित करने का तरीका देती हैं। इससे सिर्फ़ स्वीकृत डोमेन से आने वाली रिक्वेस्ट ही आपके एजेंट से कनेक्ट हो पाती हैं।

### अलाउलिस्ट कैसे काम करती हैं

1. आप अपने एजेंट के लिए स्वीकृत होस्टनेम की सूची कॉन्फ़िगर करते हैं।
2. जब कोई क्लाइंट कनेक्ट करने की कोशिश करता है, तो ElevenLabs जांचता है कि रिक्वेस्ट का मूल किसी अनुमति वाले होस्टनेम से मेल खाता है या नहीं।
3. अगर मूल अलाउलिस्ट में है, तो कनेक्शन की अनुमति मिलती है; वरना उसे अस्वीकार कर दिया जाता है।

### अलाउलिस्ट कॉन्फ़िगर करना

अलाउलिस्ट आपके एजेंट की ऑथेंटिकेशन सेटिंग्स के हिस्से के रूप में कॉन्फ़िगर होती हैं। आप अपने एजेंट से कनेक्ट होने के लिए अधिकतम 10 अलग-अलग होस्टनेम तय कर सकते हैं।

### उदाहरण: अलाउलिस्ट सेट अप करना

#### डैशबोर्ड से कॉन्फ़िगर करें

डैशबोर्ड में अपना एजेंट खोलें और **Security** टैब पर जाएं। हर स्वीकृत होस्टनेम (जैसे `example.com`, `app.example.com`, `localhost:3000`) को अलाउलिस्ट में जोड़ें।

#### CLI से कॉन्फ़िगर करें

#### अपना एजेंट पुल करें

```bash
elevenlabs agents pull --agent "<agent-name>"
```

#### एजेंट कॉन्फ़िगरेशन संपादित करें

`agent_configs/<agent-name>.json` में `platform_settings.auth` सेट करें:

```json
{
  "platform_settings": {
    "auth": {
      "enable_auth": false,
      "allowlist": [
        { "hostname": "example.com" },
        { "hostname": "app.example.com" },
        { "hostname": "localhost:3000" }
      ]
    }
  }
}
```

#### बदलाव पुश करें

```bash
elevenlabs agents push --agent "<agent-name>"
```

#### API से कॉन्फ़िगर करें

```python
from elevenlabs.client import ElevenLabs
import os
from elevenlabs.types import *

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

agent = elevenlabs.conversational_ai.agents.create(
  conversation_config=ConversationalConfig(
    agent=AgentConfig(
      first_message="Hi. I'm an authenticated agent.",
    )
  ),
  platform_settings=AgentPlatformSettingsRequestModel(
  auth=AuthSettings(
    enable_auth=False,
    allowlist=[
      AllowlistItem(hostname="example.com"),
      AllowlistItem(hostname="app.example.com"),
      AllowlistItem(hostname="localhost:3000")
      ]
    )
  )
)
```

```javascript
async function createAuthenticatedAgent(client) {
  try {
    const agent = await elevenlabs.conversationalAi.agents.create({
      conversationConfig: {
        agent: {
          firstMessage: "Hi. I'm an authenticated agent.",
        },
      },
      platformSettings: {
        auth: {
          enableAuth: false,
          allowlist: [
            { hostname: 'example.com' },
            { hostname: 'app.example.com' },
            { hostname: 'localhost:3000' },
          ],
        },
      },
    });

    return agent;
  } catch (error) {
    console.error('Error creating agent:', error);
    throw error;
  }
}
```

## ऑथेंटिकेशन तरीका चुनना

हर एजेंट के लिए एक ऑथेंटिकेशन तरीका कॉन्फ़िगर करें:

1. ऑथेंटिकेटेड क्लाइंट सेशन के लिए साइन्ड URLs (`enable_auth`) का इस्तेमाल करें।
2. होस्टनेम-आधारित एक्सेस कंट्रोल के लिए अलाउलिस्ट (`allowlist`) का इस्तेमाल करें।

एक ही एजेंट पर साइन्ड URLs और अलाउलिस्ट को साथ में कॉन्फ़िगर न करें। अपने डिप्लॉयमेंट मॉडल के अनुसार तरीका चुनें।

### उदाहरण: सिर्फ़ साइन्ड URLs

`allowlist` के बिना `enable_auth` का इस्तेमाल करें:

```python
from elevenlabs.client import ElevenLabs
import os
from elevenlabs.types import *

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

agent = elevenlabs.conversational_ai.agents.create(
  conversation_config=ConversationalConfig(
    agent=AgentConfig(
      first_message="Hi. I require a signed URL.",
    )
  ),
  platform_settings=AgentPlatformSettingsRequestModel(
    auth=AuthSettings(
      enable_auth=True
    )
  )
)
```

```javascript
async function createSignedUrlAgent(client) {
  try {
    const agent = await client.conversationalAi.agents.create({
      conversationConfig: {
        agent: {
          firstMessage: "Hi. I require a signed URL.",
        },
      },
      platformSettings: {
        auth: {
          enableAuth: true,
        },
      },
    });

    return agent;
  } catch (error) {
    console.error("Error creating agent:", error);
    throw error;
  }
}
```

### उदाहरण: सिर्फ़ अलाउलिस्ट

साइन्ड URLs सक्षम किए बिना `allowlist` का इस्तेमाल करें:

```python
from elevenlabs.client import ElevenLabs
import os
from elevenlabs.types import *

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

agent = elevenlabs.conversational_ai.agents.create(
  conversation_config=ConversationalConfig(
    agent=AgentConfig(
      first_message="Hi. I only accept approved hostnames.",
    )
  ),
  platform_settings=AgentPlatformSettingsRequestModel(
    auth=AuthSettings(
      allowlist=[
        AllowlistItem(hostname="example.com"),
        AllowlistItem(hostname="app.example.com"),
      ]
    )
  )
)
```

```javascript
async function createAllowlistAgent(client) {
  try {
    const agent = await client.conversationalAi.agents.create({
      conversationConfig: {
        agent: {
          firstMessage: "Hi. I only accept approved hostnames.",
        },
      },
      platformSettings: {
        auth: {
          allowlist: [{ hostname: "example.com" }, { hostname: "app.example.com" }],
        },
      },
    });

    return agent;
  } catch (error) {
    console.error("Error creating agent:", error);
    throw error;
  }
}
```

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

#### क्या मैं कई यूज़र्स के लिए एक ही साइन्ड URL इस्तेमाल कर सकता हूँ?

यह संभव है, लेकिन हम हर यूज़र सेशन के लिए नया साइन्ड URL जनरेट करने की सलाह देते हैं।

#### अगर बातचीत के दौरान साइन्ड URL एक्सपायर हो जाए तो क्या होता है?

अगर साइन्ड URL एक्सपायर हो जाता है (15 मिनट बाद), तो उस साइन्ड URL से बनाया गया कोई भी WebSocket कनेक्शन बंद **नहीं** होगा, लेकिन उसी साइन्ड URL से नया कनेक्शन बनाने की कोशिश विफल हो जाएगी।

#### क्या मैं खास यूज़र्स का एक्सेस सीमित कर सकता हूँ?

साइन्ड URL सिस्टम सिर्फ़ यह जांचता है कि रिक्वेस्ट किसी अधिकृत स्रोत से आई है। खास यूज़र्स का एक्सेस सीमित करने के लिए, साइन्ड URL मांगने से पहले अपने ऐप्लिकेशन में यूज़र ऑथेंटिकेशन लागू करें।

#### मैं कितने साइन्ड URLs जनरेट कर सकता हूँ, क्या इसकी कोई सीमा है?

आपके जनरेट किए जा सकने वाले साइन्ड URLs की संख्या पर कोई खास सीमा नहीं है।

#### अलाउलिस्ट सबडोमेन को कैसे हैंडल करती हैं?

अलाउलिस्ट होस्टनेम पर सटीक मिलान करती हैं। अगर आप किसी डोमेन और उसके सबडोमेन, दोनों को अनुमति देना चाहते हैं, तो आपको हर एक को अलग से जोड़ना होगा (जैसे, "example.com" और "app.example.com")।

#### क्या मुझे दोनों ऑथेंटिकेशन तरीके इस्तेमाल करने होंगे?

नहीं। हर एजेंट के लिए साइन्ड URLs या अलाउलिस्ट में से कोई एक कॉन्फ़िगर करें। क्लाइंट-साइड ऐप्लिकेशन के लिए साइन्ड URLs सुझाया गया डिफ़ॉल्ट तरीका है।

#### मुझे और कौन-से सुरक्षा उपाय लागू करने चाहिए?

साइन्ड URLs और अलाउलिस्ट के अलावा, इन उपायों पर विचार करें:

* साइन्ड URLs मांगने से पहले यूज़र ऑथेंटिकेशन
* API रिक्वेस्ट पर रेट लिमिटिंग
* संदिग्ध पैटर्न के लिए उपयोग की निगरानी
* ऑथेंटिकेशन विफलताओं के लिए सही एरर हैंडलिंग