> 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-oproepen registreren

> **Geavanceerd**
>
> Deze handleiding behandelt een geavanceerd integratiepatroon voor ontwikkelaars die volledige controle over hun
> Twilio-infrastructuur nodig hebben. Overweeg voor een eenvoudigere installatie de [native Twilio- integratie](/docs/nl/eleven-agents/phone-numbers/twilio-integration/native-integration), die de
> configuratie automatisch afhandelt.

## Wanneer gebruik je welke aanpak?

Voordat je begint, is het belangrijk de afwegingen tussen de native integratie en de register call-aanpak te begrijpen:

| Functie                    | Native integratie | Register call      |
| -------------------------- | ----------------- | ------------------ |
| Eenvoud van installatie    | Eenvoudiger       | Complexer          |
| Oproepen doorverbinden     | Ondersteund       | Niet ondersteund   |
| Aangepaste Twilio-logica   | Beperkt           | Volledige controle |
| Beheer van telefoonnummers | Via ElevenLabs    | Via Twilio         |

## Overzicht

Met het register call-endpoint kun je je eigen Twilio-infrastructuur gebruiken en tegelijk ElevenLabs-agents inzetten voor het gesprek. In plaats van je Twilio-nummer naar ElevenLabs te importeren, houd je volledige controle over je Twilio-configuratie en gebruik je de ElevenLabs API om oproepen te registreren en [TwiML](https://www.twilio.com/docs/voice/twiml) te ontvangen om ze met je agents te verbinden.

Deze aanpak is ideaal als je:

* Je bestaande Twilio-infrastructuur en workflows wilt behouden
* Programmatische controle wilt over oproeprouting en -afhandeling
* Complexe oproepflows hebt die aangepaste Twilio-logica vereisen voordat je verbinding maakt met een agent
* ElevenLabs-agents moet integreren in een bestaand telefoniesysteem

## Zo werkt het

1. Je server ontvangt een inkomende oproep of start via Twilio een uitgaande oproep
2. Je server roept het ElevenLabs register call-endpoint aan met gegevens over de agent en de oproep
3. ElevenLabs retourneert TwiML dat de oproep via WebSocket met je agent verbindt
4. Je retourneert deze TwiML aan Twilio om de verbinding tot stand te brengen

> **Note**
>
> Wanneer je het register call-endpoint gebruikt, is de functie voor het doorverbinden van oproepen niet beschikbaar, omdat ElevenLabs
> geen directe toegang heeft tot je Twilio-accountgegevens.

## Vereisten

* Een [ElevenLabs-account](https://elevenlabs.io)
* Een geconfigureerde ElevenLabs Conversational Agent ([maak er hier een](/docs/nl/eleven-agents/quickstart))
* Een [Twilio-account](https://www.twilio.com/try-twilio) met een actief telefoonnummer
* Je agent is geconfigureerd met de audio-indeling μ-law 8000 Hz (zie [agentconfiguratie](#agent-configuration))

## Agentconfiguratie

Configureer je agent voordat je het register call-endpoint gebruikt met de juiste audio-indeling die Twilio ondersteunt.

#### TTS-uitvoer configureren

1. Ga naar de instellingen van je agent
2. Ga naar de sectie Voice
3. Selecteer "μ-law 8000 Hz" in de dropdown

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

#### Invoerindeling instellen

1. Ga naar de instellingen van je agent
2. Ga naar de sectie Advanced
3. Selecteer "μ-law 8000 Hz" voor de invoerindeling

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

## API-referentie

Het register call-endpoint accepteert de volgende parameters:

| Parameter                             | Type   | Vereist | Beschrijving                                           |
| ------------------------------------- | ------ | ------- | ------------------------------------------------------ |
| `agent_id`                            | string | Ja      | De ID van de agent die de oproep afhandelt             |
| `from_number`                         | string | Ja      | Het telefoonnummer van de beller                       |
| `to_number`                           | string | Ja      | Het telefoonnummer van de bestemming                   |
| `direction`                           | string | Nee     | Oproeprichting: `inbound` (standaard) of `outbound`    |
| `conversation_initiation_client_data` | object | Nee     | Dynamische variabelen en configuratie-overschrijvingen |

Het endpoint retourneert TwiML dat je rechtstreeks aan Twilio moet doorgeven.

## Implementatie

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

## Uitgaande oproepen

Start voor uitgaande oproepen de oproep via Twilio en laat de webhook-URL naar je server wijzen, die zich vervolgens bij ElevenLabs registreert:

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

## Gesprekken personaliseren

Gebruik de parameter `conversation_initiation_client_data` om dynamische variabelen door te geven en de agentconfiguratie te overschrijven:

```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**
>
> Zie voor meer informatie over dynamische variabelen en overschrijvingen de documentatie over [dynamische variabelen](/docs/nl/eleven-agents/customization/personalization/dynamic-variables) en
> [overschrijvingen](/docs/nl/eleven-agents/customization/personalization/overrides).

## Twilio-configuratie

Configureer je Twilio-telefoonnummer zodat het naar je server wijst:

#### Een openbare URL maken

Gebruik voor lokale ontwikkeling [ngrok](https://ngrok.com) om je server beschikbaar te maken:

```bash
ngrok http 8000
```

#### Je Twilio-nummer configureren

1. Ga naar de [Twilio Console](https://console.twilio.com)
2. Ga naar Phone Numbers > Manage > Active numbers
3. Selecteer je telefoonnummer
4. Stel onder "Voice Configuration" de webhook-URL in op je serverendpoint (bijvoorbeeld `https://your-ngrok-url.ngrok.app/twilio/inbound`)
5. Stel de HTTP-methode in op POST

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

## Beperkingen

Wanneer je het register call-endpoint gebruikt in plaats van de native integratie:

* **Geen oproepen doorverbinden**: De doorverbindfunctie is niet beschikbaar, omdat ElevenLabs geen toegang heeft tot je Twilio-gegevens
* **Handmatige configuratie**: Je moet zelf audio-indelingen configureren en TwiML-routing afhandelen
* **Geen dashboardimport**: Telefoonnummers die op deze manier zijn geregistreerd, worden niet weergegeven in het ElevenLabs-dashboard voor telefoonnummers