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

# Enregistrer des appels Twilio

> **Avancé**
>
> Ce guide couvre un modèle d’intégration avancé destiné aux développeurs qui ont besoin d’un contrôle total sur leur
> infrastructure Twilio. Pour une configuration plus simple, envisagez d’utiliser l’[intégration Twilio native](/docs/fr/eleven-agents/phone-numbers/twilio-integration/native-integration), qui
> gère automatiquement la configuration.

## Quand utiliser chaque approche

Avant de commencer, comprenez les compromis entre l’intégration native et l’approche d’enregistrement d’appel :

| Fonctionnalité                   | Intégration native | Enregistrement d’appel |
| -------------------------------- | ------------------ | ---------------------- |
| Facilité de configuration        | Plus simple        | Plus complexe          |
| Transferts d’appel               | Pris en charge     | Non pris en charge     |
| Logique Twilio personnalisée     | Limitée            | Contrôle total         |
| Gestion des numéros de téléphone | Via ElevenLabs     | Via Twilio             |

## Vue d’ensemble

Le point de terminaison d’enregistrement d’appel vous permet d’utiliser votre propre infrastructure Twilio tout en tirant parti des agents ElevenLabs pour la conversation. Au lieu d’importer votre numéro Twilio dans ElevenLabs, vous gardez le contrôle total de votre configuration Twilio et utilisez l’API ElevenLabs pour enregistrer les appels et recevoir du [TwiML](https://www.twilio.com/docs/voice/twiml) afin de les connecter à vos agents.

Cette approche est idéale si vous :

* Devez conserver votre infrastructure et vos workflows Twilio existants
* Souhaitez contrôler par programmation le routage et le traitement des appels
* Disposez de flux d’appel complexes nécessitant une logique Twilio personnalisée avant la connexion à un agent
* Devez intégrer des agents ElevenLabs à un système de téléphonie existant

## Fonctionnement

1. Votre serveur reçoit un appel entrant ou lance un appel sortant via Twilio
2. Votre serveur appelle le point de terminaison d’enregistrement d’appel ElevenLabs avec les détails de l’agent et de l’appel
3. ElevenLabs renvoie du TwiML qui connecte l’appel à votre agent via WebSocket
4. Vous renvoyez ce TwiML à Twilio afin d’établir la connexion

> **Note**
>
> Lorsque vous utilisez le point de terminaison d’enregistrement d’appel, la fonctionnalité de transfert d’appel n’est pas disponible,
> car ElevenLabs n’a pas accès directement aux identifiants de votre compte Twilio.

## Prérequis

* Un [compte ElevenLabs](https://elevenlabs.io)
* Un agent conversationnel ElevenLabs configuré ([créez-en un ici](/docs/fr/eleven-agents/quickstart))
* Un [compte Twilio](https://www.twilio.com/try-twilio) avec un numéro de téléphone actif
* Votre agent configuré avec le format audio μ-law 8000 Hz, consultez la [configuration de l’agent](#agent-configuration)

## Configuration de l’agent

Avant d’utiliser le point de terminaison d’enregistrement d’appel, configurez votre agent pour utiliser le bon format audio pris en charge par Twilio.

#### Configurer la sortie TTS

1. Accédez aux paramètres de votre agent
2. Ouvrez la section Voice
3. Sélectionnez « μ-law 8000 Hz » dans la liste déroulante

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

#### Définir le format d’entrée

1. Accédez aux paramètres de votre agent
2. Ouvrez la section Advanced
3. Sélectionnez « μ-law 8000 Hz » comme format d’entrée

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

## Référence API

Le point de terminaison d’enregistrement d’appel accepte les paramètres suivants :

| Paramètre                             | Type   | Obligatoire | Description                                            |
| ------------------------------------- | ------ | ----------- | ------------------------------------------------------ |
| `agent_id`                            | string | Oui         | ID de l’agent qui traite l’appel                       |
| `from_number`                         | string | Oui         | Numéro de téléphone de l’appelant                      |
| `to_number`                           | string | Oui         | Numéro de téléphone de destination                     |
| `direction`                           | string | Non         | Sens de l’appel : `inbound` (par défaut) ou `outbound` |
| `conversation_initiation_client_data` | object | Non         | Variables dynamiques et remplacements de configuration |

Le point de terminaison renvoie du TwiML que vous devez transmettre directement à Twilio.

## Implémentation

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

## Appels sortants

Pour les appels sortants, lancez l’appel via Twilio et dirigez l’URL du webhook vers votre serveur, qui s’enregistre ensuite auprès d’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);
});
```

## Personnaliser les conversations

Utilisez le paramètre `conversation_initiation_client_data` pour transmettre des variables dynamiques et remplacer la configuration de l’agent :

```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**
>
> Pour en savoir plus sur les variables dynamiques et les remplacements, consultez la documentation sur les [variables dynamiques](/docs/fr/eleven-agents/customization/personalization/dynamic-variables) et les
> [remplacements](/docs/fr/eleven-agents/customization/personalization/overrides).

## Configuration Twilio

Configurez votre numéro de téléphone Twilio pour qu’il pointe vers votre serveur :

#### Créer une URL publique

Pour le développement local, utilisez [ngrok](https://ngrok.com) afin d’exposer votre serveur :

```bash
ngrok http 8000
```

#### Configurer votre numéro Twilio

1. Accédez à la [console Twilio](https://console.twilio.com)
2. Accédez à Phone Numbers > Manage > Active numbers
3. Sélectionnez votre numéro de téléphone
4. Sous « Voice Configuration », définissez l’URL du webhook sur le point de terminaison de votre serveur, par exemple `https://your-ngrok-url.ngrok.app/twilio/inbound`
5. Définissez la méthode HTTP sur POST

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

## Limites

Lorsque vous utilisez le point de terminaison d’enregistrement d’appel au lieu de l’intégration native :

* **Aucun transfert d’appel** : la fonctionnalité de transfert n’est pas disponible, car ElevenLabs n’a pas accès à vos identifiants Twilio
* **Configuration manuelle** : vous devez configurer les formats audio et gérer vous-même le routage TwiML
* **Aucune importation dans le dashboard** : les numéros de téléphone enregistrés de cette manière n’apparaissent pas dans le dashboard des numéros de téléphone ElevenLabs