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

# Twilio कॉल रजिस्टर करें

> **उन्नत**
>
> यह गाइड उन डेवलपर्स के लिए एक उन्नत इंटीग्रेशन पैटर्न कवर करती है, जिन्हें अपने
> Twilio इन्फ़्रास्ट्रक्चर पर पूरा नियंत्रण चाहिए। आसान सेटअप के लिए [नेटिव Twilio इंटीग्रेशन](/docs/hi/eleven-agents/phone-numbers/twilio-integration/native-integration) इस्तेमाल करने पर विचार करें,
> जो कॉन्फ़िगरेशन अपने-आप संभालता है।

## हर तरीका कब इस्तेमाल करें

शुरू करने से पहले, नेटिव इंटीग्रेशन और रजिस्टर कॉल तरीके के बीच अंतर समझें:

| सुविधा             | नेटिव इंटीग्रेशन    | रजिस्टर कॉल     |
| ------------------ | ------------------- | --------------- |
| सेटअप में आसानी    | आसान                | ज़्यादा जटिल    |
| कॉल ट्रांसफ़र      | समर्थित             | समर्थित नहीं    |
| कस्टम Twilio लॉजिक | सीमित               | पूरा नियंत्रण   |
| फ़ोन नंबर प्रबंधन  | ElevenLabs के ज़रिए | Twilio के ज़रिए |

## ओवरव्यू

रजिस्टर कॉल एंडपॉइंट आपको बातचीत के लिए ElevenLabs एजेंट्स का लाभ लेते हुए अपना Twilio इन्फ़्रास्ट्रक्चर इस्तेमाल करने देता है। अपना Twilio नंबर ElevenLabs में इंपोर्ट करने के बजाय, आप अपने Twilio सेटअप पर पूरा नियंत्रण रखते हैं और कॉल रजिस्टर करने व उन्हें अपने एजेंट्स से कनेक्ट करने के लिए [TwiML](https://www.twilio.com/docs/voice/twiml) पाने हेतु ElevenLabs API इस्तेमाल करते हैं।

यह तरीका इन स्थितियों में आदर्श है:

* आपको अपना मौजूदा Twilio इन्फ़्रास्ट्रक्चर और workflow बनाए रखना है
* आपको कॉल रूटिंग और हैंडलिंग पर प्रोग्रामेटिक नियंत्रण चाहिए
* आपके पास जटिल कॉल फ़्लो हैं, जिनमें एजेंट से कनेक्ट करने से पहले कस्टम Twilio लॉजिक चाहिए
* आपको ElevenLabs एजेंट्स को किसी मौजूदा टेलीफोनी सिस्टम में इंटीग्रेट करना है

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

1. आपका सर्वर इनबाउंड कॉल प्राप्त करता है या Twilio के ज़रिए आउटबाउंड कॉल शुरू करता है
2. आपका सर्वर एजेंट और कॉल विवरण के साथ ElevenLabs रजिस्टर कॉल एंडपॉइंट को कॉल करता है
3. ElevenLabs TwiML लौटाता है, जो WebSocket के ज़रिए कॉल को आपके एजेंट से कनेक्ट करता है
4. कनेक्शन स्थापित करने के लिए आप यह TwiML Twilio को लौटाते हैं

> **Note**
>
> रजिस्टर कॉल एंडपॉइंट इस्तेमाल करते समय, कॉल ट्रांसफ़र सुविधा उपलब्ध नहीं होती क्योंकि ElevenLabs को
> आपके Twilio अकाउंट क्रेडेंशियल का सीधा एक्सेस नहीं होता।

## आवश्यक शर्तें

* एक [ElevenLabs अकाउंट](https://elevenlabs.io)
* कॉन्फ़िगर किया हुआ ElevenLabs कन्वर्सेशनल AI एजेंट ([यहाँ बनाएं](/docs/hi/eleven-agents/quickstart))
* सक्रिय फ़ोन नंबर वाला एक [Twilio अकाउंट](https://www.twilio.com/try-twilio)
* आपका एजेंट μ-law 8000 Hz ऑडियो फ़ॉर्मैट के साथ कॉन्फ़िगर हो (देखें [एजेंट कॉन्फ़िगरेशन](#agent-configuration))

## एजेंट कॉन्फ़िगरेशन

रजिस्टर कॉल एंडपॉइंट इस्तेमाल करने से पहले, अपने एजेंट को Twilio द्वारा समर्थित सही ऑडियो फ़ॉर्मैट इस्तेमाल करने के लिए कॉन्फ़िगर करें।

#### TTS आउटपुट कॉन्फ़िगर करें

1. अपने एजेंट सेटिंग्स पर जाएं
2. Voice सेक्शन में जाएं
3. ड्रॉपडाउन से "μ-law 8000 Hz" चुनें

![](/docs/_fern-img/b37196c36051755fb0b10a99b393501ec11573f963c83b6b092e1b5926c6617f.webp)

#### इनपुट फ़ॉर्मैट सेट करें

1. अपने एजेंट सेटिंग्स पर जाएं
2. Advanced सेक्शन में जाएं
3. इनपुट फ़ॉर्मैट के लिए "μ-law 8000 Hz" चुनें

![](/docs/_fern-img/ec87531c38e26f2293b90126f1b91ee9acb4cc677c6f3e83a6e1b6029743d3f7.webp)

## API रेफरेंस

रजिस्टर कॉल एंडपॉइंट ये पैरामीटर स्वीकार करता है:

| पैरामीटर                              | टाइप   | ज़रूरी | विवरण                                           |
| ------------------------------------- | ------ | ------ | ----------------------------------------------- |
| `agent_id`                            | string | हाँ    | कॉल संभालने वाले एजेंट की ID                    |
| `from_number`                         | string | हाँ    | कॉलर का फ़ोन नंबर                               |
| `to_number`                           | string | हाँ    | गंतव्य फ़ोन नंबर                                |
| `direction`                           | string | नहीं   | कॉल की दिशा: `inbound` (डिफ़ॉल्ट) या `outbound` |
| `conversation_initiation_client_data` | object | नहीं   | डायनामिक वेरिएबल और कॉन्फ़िगरेशन ओवरराइड        |

एंडपॉइंट TwiML लौटाता है, जिसे आपको सीधे Twilio को भेजना चाहिए।

## इंप्लीमेंटेशन

```python
import os
from fastapi import FastAPI, Request
from fastapi.responses import Response
from elevenlabs import ElevenLabs

app = FastAPI()

elevenlabs = ElevenLabs()
AGENT_ID = os.getenv("ELEVENLABS_AGENT_ID")

@app.post("/twilio/inbound")
async def handle_inbound_call(request: Request):
    form_data = await request.form()
    from_number = form_data.get("From")
    to_number = form_data.get("To")

    # Register the call with ElevenLabs
    twiml = elevenlabs.conversational_ai.twilio.register_call(
        agent_id=AGENT_ID,
        from_number=from_number,
        to_number=to_number,
        direction="inbound",
        conversation_initiation_client_data={
            "dynamic_variables": {
                "caller_number": from_number,
            }
        }
    )

    # Return the TwiML directly to Twilio
    return Response(content=twiml, media_type="application/xml")

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)
```

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

const app = express();
app.use(express.urlencoded({ extended: true }));

const elevenlabs = new ElevenLabsClient();
const AGENT_ID = process.env.ELEVENLABS_AGENT_ID;

// Handle incoming Twilio calls
app.post("/twilio/inbound", async (req, res) => {
  const { From: fromNumber, To: toNumber } = req.body;

  // Register the call with ElevenLabs
  const twiml = await elevenlabs.conversationalAi.twilio.registerCall({
    agentId: AGENT_ID,
    fromNumber,
    toNumber,
    direction: "inbound",
    conversationInitiationClientData: {
      dynamicVariables: {
        caller_number: fromNumber,
      },
    },
  });

  // Return the TwiML directly to Twilio
  res.type("application/xml").send(twiml);
});

app.listen(8000, () => {
  console.log("Server running on port 8000");
});
```

## आउटबाउंड कॉल

आउटबाउंड कॉल के लिए, Twilio के ज़रिए कॉल शुरू करें और webhook URL को अपने सर्वर पर पॉइंट करें, जो फिर ElevenLabs के साथ रजिस्टर करेगा:

```python
from twilio.rest import Client
import os
from fastapi import Request
from fastapi.responses import Response
from elevenlabs import ElevenLabs

# Initialize clients
twilio_client = Client(
    os.getenv("TWILIO_ACCOUNT_SID"),
    os.getenv("TWILIO_AUTH_TOKEN")
)
elevenlabs = ElevenLabs()
AGENT_ID = os.getenv("ELEVENLABS_AGENT_ID")

def initiate_outbound_call(to_number: str):
    call = twilio_client.calls.create(
        from_=os.getenv("TWILIO_PHONE_NUMBER"),
        to=to_number,
        url="https://your-server.com/twilio/outbound"
    )
    return call.sid

@app.post("/twilio/outbound")
async def handle_outbound_webhook(request: Request):
    form_data = await request.form()
    from_number = form_data.get("From")
    to_number = form_data.get("To")

    twiml = elevenlabs.conversational_ai.twilio.register_call(
        agent_id=AGENT_ID,
        from_number=from_number,
        to_number=to_number,
        direction="outbound",
    )

    return Response(content=twiml, media_type="application/xml")
```

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

// Initialize clients
const twilioClient = new Twilio(process.env.TWILIO_ACCOUNT_SID, process.env.TWILIO_AUTH_TOKEN);
const elevenlabs = new ElevenLabsClient();
const AGENT_ID = process.env.ELEVENLABS_AGENT_ID;

// Initiate an outbound call
async function initiateOutboundCall(toNumber: string) {
  const call = await twilioClient.calls.create({
    from: process.env.TWILIO_PHONE_NUMBER,
    to: toNumber,
    url: "https://your-server.com/twilio/outbound",
  });
  return call.sid;
}

// Handle the Twilio webhook for outbound calls
app.post("/twilio/outbound", async (req, res) => {
  const { From: fromNumber, To: toNumber } = req.body;

  const twiml = await elevenlabs.conversationalAi.twilio.registerCall({
    agentId: AGENT_ID,
    fromNumber,
    toNumber,
    direction: "outbound",
  });

  res.type("application/xml").send(twiml);
});
```

## बातचीत को व्यक्तिगत बनाना

डायनामिक वेरिएबल पास करने और एजेंट कॉन्फ़िगरेशन ओवरराइड करने के लिए `conversation_initiation_client_data` पैरामीटर इस्तेमाल करें:

```json
{
  "agent_id": "your-agent-id",
  "from_number": "+1234567890",
  "to_number": "+0987654321",
  "direction": "inbound",
  "conversation_initiation_client_data": {
    "dynamic_variables": {
      "customer_name": "John Doe",
      "account_type": "premium",
      "order_id": "ORD-12345"
    }
  }
}
```

> **Info**
>
> डायनामिक वेरिएबल और ओवरराइड के बारे में अधिक जानकारी के लिए [डायनामिक वेरिएबल](/docs/hi/eleven-agents/customization/personalization/dynamic-variables) और
> [ओवरराइड](/docs/hi/eleven-agents/customization/personalization/overrides) दस्तावेज़ देखें।

## Twilio कॉन्फ़िगरेशन

अपने Twilio फ़ोन नंबर को अपने सर्वर पर पॉइंट करने के लिए कॉन्फ़िगर करें:

#### पब्लिक URL बनाएं

लोकल डेवलपमेंट के लिए, अपने सर्वर को एक्सपोज़ करने हेतु [ngrok](https://ngrok.com) इस्तेमाल करें:

```bash
ngrok http 8000
```

#### अपना Twilio नंबर कॉन्फ़िगर करें

1. [Twilio Console](https://console.twilio.com) पर जाएं
2. Phone Numbers > Manage > Active numbers पर जाएं
3. अपना फ़ोन नंबर चुनें
4. "Voice Configuration" के अंतर्गत, webhook URL को अपने सर्वर एंडपॉइंट पर सेट करें (उदाहरण के लिए, `https://your-ngrok-url.ngrok.app/twilio/inbound`)
5. HTTP मेथड को POST पर सेट करें

![](/docs/_fern-img/510d09d492b0c6ac9966f8fe39a9da685df79e8108f6fbc55fe502f48f650084.webp)

## सीमाएं

नेटिव इंटीग्रेशन की जगह रजिस्टर कॉल एंडपॉइंट इस्तेमाल करते समय:

* **कॉल ट्रांसफ़र नहीं**: ट्रांसफ़र सुविधा उपलब्ध नहीं है, क्योंकि ElevenLabs को आपके Twilio क्रेडेंशियल का एक्सेस नहीं है
* **मैन्युअल कॉन्फ़िगरेशन**: आपको ऑडियो फ़ॉर्मैट कॉन्फ़िगर करने और TwiML रूटिंग खुद संभालने की ज़रूरत है
* **डैशबोर्ड में इंपोर्ट नहीं**: इस तरह रजिस्टर किए गए फ़ोन नंबर ElevenLabs फ़ोन नंबर डैशबोर्ड में दिखाई नहीं देते