> 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-Anrufe registrieren

> **Erweitert**
>
> Dieser Leitfaden behandelt ein erweitertes Integrationsmuster für Entwickler, die vollständige Kontrolle über ihre
> Twilio-Infrastruktur benötigen. Für eine einfachere Einrichtung verwenden Sie die [native Twilio- Integration](/docs/de/eleven-agents/phone-numbers/twilio-integration/native-integration), die die
> Konfiguration automatisch übernimmt.

## Wann Sie welchen Ansatz verwenden sollten

Bevor Sie beginnen, sollten Sie die Unterschiede zwischen der nativen Integration und dem Ansatz zum Registrieren von Anrufen kennen:

| Funktion                 | Native Integration | Anruf registrieren |
| ------------------------ | ------------------ | ------------------ |
| Einfache Einrichtung     | Einfacher          | Komplexer          |
| Anrufweiterleitungen     | Unterstützt        | Nicht unterstützt  |
| Eigene Twilio-Logik      | Eingeschränkt      | Volle Kontrolle    |
| Telefonnummernverwaltung | Über ElevenLabs    | Über Twilio        |

## Überblick

Der Endpunkt zum Registrieren von Anrufen ermöglicht Ihnen, Ihre eigene Twilio-Infrastruktur zu verwenden und gleichzeitig ElevenLabs-Agenten für Gespräche einzusetzen. Statt Ihre Twilio-Nummer in ElevenLabs zu importieren, behalten Sie die volle Kontrolle über Ihre Twilio-Einrichtung und verwenden die ElevenLabs API, um Anrufe zu registrieren und [TwiML](https://www.twilio.com/docs/voice/twiml) zu erhalten, um sie mit Ihren Agenten zu verbinden.

Dieser Ansatz ist ideal, wenn Sie:

* Ihre bestehende Twilio-Infrastruktur und Workflows beibehalten müssen
* Programmatische Kontrolle über Anrufrouting und -verarbeitung wünschen
* Komplexe Anrufabläufe haben, die eigene Twilio-Logik erfordern, bevor ein Agent verbunden wird
* ElevenLabs-Agenten in ein bestehendes Telefonsystem integrieren müssen

## So funktioniert es

1. Ihr Server empfängt einen eingehenden Anruf oder initiiert über Twilio einen ausgehenden Anruf
2. Ihr Server ruft den ElevenLabs-Endpunkt zum Registrieren von Anrufen mit Agenten- und Anrufdetails auf
3. ElevenLabs gibt TwiML zurück, das den Anruf über WebSocket mit Ihrem Agenten verbindet
4. Sie geben diese TwiML an Twilio zurück, um die Verbindung herzustellen

> **Note**
>
> Bei Verwendung des Endpunkts zum Registrieren von Anrufen ist die Anrufweiterleitungsfunktion nicht verfügbar, da ElevenLabs
> keinen direkten Zugriff auf Ihre Twilio-Kontozugangsdaten hat.

## Voraussetzungen

* Ein [ElevenLabs-Konto](https://elevenlabs.io)
* Ein konfigurierter ElevenLabs Conversational Agent ([hier erstellen](/docs/de/eleven-agents/quickstart))
* Ein [Twilio-Konto](https://www.twilio.com/try-twilio) mit einer aktiven Telefonnummer
* Ihr Agent ist mit dem Audioformat μ-law 8000 Hz konfiguriert (siehe [Agentenkonfiguration](#agent-configuration))

## Agentenkonfiguration

Konfigurieren Sie Ihren Agenten vor der Verwendung des Endpunkts zum Registrieren von Anrufen für das von Twilio unterstützte korrekte Audioformat.

#### TTS-Ausgabe konfigurieren

1. Navigieren Sie zu Ihren Agenteneinstellungen
2. Öffnen Sie den Bereich Voice
3. Wählen Sie im Dropdown-Menü „μ-law 8000 Hz“ aus

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

#### Eingabeformat festlegen

1. Navigieren Sie zu Ihren Agenteneinstellungen
2. Öffnen Sie den Bereich Advanced
3. Wählen Sie für das Eingabeformat „μ-law 8000 Hz“ aus

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

## API-Referenz

Der Endpunkt zum Registrieren von Anrufen akzeptiert die folgenden Parameter:

| Parameter                             | Typ    | Erforderlich | Beschreibung                                            |
| ------------------------------------- | ------ | ------------ | ------------------------------------------------------- |
| `agent_id`                            | string | Ja           | Die ID des Agenten, der den Anruf bearbeitet            |
| `from_number`                         | string | Ja           | Telefonnummer des Anrufers                              |
| `to_number`                           | string | Ja           | Zieltelefonnummer                                       |
| `direction`                           | string | Nein         | Anrufrichtung: `inbound` (Standard) oder `outbound`     |
| `conversation_initiation_client_data` | object | Nein         | Dynamische Variablen und Konfigurationsüberschreibungen |

Der Endpunkt gibt TwiML zurück, das Sie direkt an Twilio übergeben sollten.

## Implementierung

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

## Ausgehende Anrufe

Für ausgehende Anrufe initiieren Sie den Anruf über Twilio und verweisen die Webhook-URL auf Ihren Server, der den Anruf dann bei ElevenLabs registriert:

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

## Gespräche personalisieren

Verwenden Sie den Parameter `conversation_initiation_client_data`, um dynamische Variablen zu übergeben und die Agentenkonfiguration zu überschreiben:

```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**
>
> Weitere Informationen zu dynamischen Variablen und Überschreibungen finden Sie in der Dokumentation zu [dynamischen Variablen](/docs/de/eleven-agents/customization/personalization/dynamic-variables) und
> [Überschreibungen](/docs/de/eleven-agents/customization/personalization/overrides).

## Twilio-Konfiguration

Konfigurieren Sie Ihre Twilio-Telefonnummer so, dass sie auf Ihren Server verweist:

#### Öffentliche URL erstellen

Verwenden Sie für die lokale Entwicklung [ngrok](https://ngrok.com), um Ihren Server öffentlich verfügbar zu machen:

```bash
ngrok http 8000
```

#### Ihre Twilio-Nummer konfigurieren

1. Öffnen Sie die [Twilio Console](https://console.twilio.com)
2. Navigieren Sie zu Phone Numbers > Manage > Active numbers
3. Wählen Sie Ihre Telefonnummer aus
4. Legen Sie unter „Voice Configuration“ die Webhook-URL auf Ihren Server-Endpunkt fest (z. B. `https://your-ngrok-url.ngrok.app/twilio/inbound`)
5. Setzen Sie die HTTP-Methode auf POST

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

## Einschränkungen

Bei Verwendung des Endpunkts zum Registrieren von Anrufen statt der nativen Integration:

* **Keine Anrufweiterleitungen**: Die Weiterleitungsfunktion ist nicht verfügbar, da ElevenLabs keinen Zugriff auf Ihre Twilio-Zugangsdaten hat
* **Manuelle Konfiguration**: Sie müssen Audioformate konfigurieren und das TwiML-Routing selbst verwalten
* **Kein Dashboard-Import**: Auf diese Weise registrierte Telefonnummern erscheinen nicht im ElevenLabs-Dashboard für Telefonnummern