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

# Registrera Twilio-samtal

> **Avancerat**
>
> Den här guiden beskriver ett avancerat integrationsmönster för utvecklare som behöver full kontroll över sin
> Twilio-infrastruktur. För en enklare installation kan du använda den [inbyggda Twilio- integrationen](/docs/sv/eleven-agents/phone-numbers/twilio-integration/native-integration), som
> hanterar konfigurationen automatiskt.

## När du ska använda respektive metod

Innan du börjar bör du förstå avvägningarna mellan den inbyggda integrationen och metoden för att registrera samtal:

| Funktion               | Inbyggd integration | Registrera samtal |
| ---------------------- | ------------------- | ----------------- |
| Enkel att konfigurera  | Enklare             | Mer komplex       |
| Samtalsöverföringar    | Stöds               | Stöds inte        |
| Anpassad Twilio-logik  | Begränsad           | Full kontroll     |
| Telefonnummerhantering | Via ElevenLabs      | Via Twilio        |

## Översikt

Slutpunkten för att registrera samtal gör att du kan använda din egen Twilio-infrastruktur samtidigt som du använder ElevenLabs-agenter för samtalet. I stället för att importera ditt Twilio-nummer till ElevenLabs behåller du full kontroll över din Twilio-konfiguration och använder ElevenLabs API för att registrera samtal och ta emot [TwiML](https://www.twilio.com/docs/voice/twiml) för att ansluta dem till dina agenter.

Den här metoden är idealisk när du:

* Behöver behålla din befintliga Twilio-infrastruktur och dina arbetsflöden
* Vill ha programmatisk kontroll över samtalsdirigering och hantering
* Har komplexa samtalsflöden som kräver anpassad Twilio-logik innan du ansluter till en agent
* Behöver integrera ElevenLabs-agenter i ett befintligt telefonisystem

## Så fungerar det

1. Din server tar emot ett inkommande samtal eller startar ett utgående samtal via Twilio
2. Din server anropar ElevenLabs slutpunkt för att registrera samtal med information om agenten och samtalet
3. ElevenLabs returnerar TwiML som ansluter samtalet till din agent via WebSocket
4. Du returnerar denna TwiML till Twilio för att upprätta anslutningen

> **Note**
>
> När du använder slutpunkten för att registrera samtal är funktionen för samtalsöverföring inte tillgänglig eftersom ElevenLabs
> inte har direkt åtkomst till dina Twilio-kontouppgifter.

## Förutsättningar

* Ett [ElevenLabs-konto](https://elevenlabs.io)
* En konfigurerad ElevenLabs konversationsagent ([skapa en här](/docs/sv/eleven-agents/quickstart))
* Ett [Twilio-konto](https://www.twilio.com/try-twilio) med ett aktivt telefonnummer
* Din agent konfigurerad med ljudformatet μ-law 8000 Hz (se [agentkonfiguration](#agent-configuration))

## Agentkonfiguration

Innan du använder slutpunkten för att registrera samtal ska du konfigurera agenten att använda rätt ljudformat som stöds av Twilio.

#### Konfigurera TTS-utdata

1. Gå till agentinställningarna
2. Gå till avsnittet Voice
3. Välj "μ-law 8000 Hz" i rullgardinsmenyn

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

#### Ange indataformat

1. Gå till agentinställningarna
2. Gå till avsnittet Advanced
3. Välj "μ-law 8000 Hz" som indataformat

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

## API-referens

Slutpunkten för att registrera samtal tar emot följande parametrar:

| Parameter                             | Typ    | Krävs | Beskrivning                                            |
| ------------------------------------- | ------ | ----- | ------------------------------------------------------ |
| `agent_id`                            | string | Ja    | ID:t för agenten som ska hantera samtalet              |
| `from_number`                         | string | Ja    | Uppringarens telefonnummer                             |
| `to_number`                           | string | Ja    | Telefonnummer för destinationen                        |
| `direction`                           | string | Nej   | Samtalsriktning: `inbound` (standard) eller `outbound` |
| `conversation_initiation_client_data` | object | Nej   | Dynamiska variabler och konfigurationsåsidosättningar  |

Slutpunkten returnerar TwiML som du ska skicka direkt till Twilio.

## Implementering

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

## Utgående samtal

För utgående samtal startar du samtalet via Twilio och pekar webhook-URL:en till din server, som sedan registrerar det hos 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);
});
```

## Personalisera samtal

Använd parametern `conversation_initiation_client_data` för att skicka dynamiska variabler och åsidosätta agentkonfiguration:

```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**
>
> Mer information om dynamiska variabler och åsidosättningar finns i dokumentationen om [dynamiska variabler](/docs/sv/eleven-agents/customization/personalization/dynamic-variables) och
> [åsidosättningar](/docs/sv/eleven-agents/customization/personalization/overrides).

## Twilio-konfiguration

Konfigurera ditt Twilio-telefonnummer så att det pekar på din server:

#### Skapa en offentlig URL

För lokal utveckling använder du [ngrok](https://ngrok.com) för att exponera din server:

```bash
ngrok http 8000
```

#### Konfigurera ditt Twilio-nummer

1. Gå till [Twilio Console](https://console.twilio.com)
2. Gå till Phone Numbers > Manage > Active numbers
3. Välj ditt telefonnummer
4. Under "Voice Configuration" anger du webhook-URL:en till din serverslutpunkt (t.ex. `https://your-ngrok-url.ngrok.app/twilio/inbound`)
5. Ange HTTP-metoden POST

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

## Begränsningar

När du använder slutpunkten för att registrera samtal i stället för den inbyggda integrationen:

* **Inga samtalsöverföringar**: Överföringsfunktionen är inte tillgänglig eftersom ElevenLabs inte har åtkomst till dina Twilio-uppgifter
* **Manuell konfiguration**: Du måste själv konfigurera ljudformat och hantera TwiML-dirigering
* **Ingen import till dashboarden**: Telefonnummer som registreras på detta sätt visas inte i ElevenLabs dashboard för telefonnummer