# API de modèles WhatsApp

Les modèles de message WhatsApp sont des messages pré-rédigés qui ont été approuvés pour être envoyés en dehors de la fenêtre de conversation normale de 24 heures — par exemple, un message de bienvenue, un rappel de rendez-vous ou une relance de réengagement. Cette API vous permet de lister, créer, modifier, soumettre, vérifier, supprimer et envoyer des modèles par programmation.

Tous les chemins ci-dessous sont relatifs à l'URL de base de l'API :

```
https://api.youraiconnector.com/v1
```

Chaque requête doit être authentifiée. Consultez [Authentification](authentication.md) pour connaître les quatre méthodes acceptées. Les exemples sur cette page utilisent l'en-tête `X-API-Key` (et une forme de paramètre de requête pour cURL).

::: note
**Remarque :** Les modèles reposent sur le canal de l'API WhatsApp Business. Cette partie de l'API nécessite donc à la fois un accès à l'API et un forfait incluant les canaux WhatsApp. Sans cela, les requêtes seront rejetées avec une erreur `403`.
:::


---

## Travailler avec des sous-comptes (agences)


---

## États d'approbation

Comme les messages envoyés en dehors d'une conversation ouverte doivent d'abord être examinés par WhatsApp, chaque modèle comporte un `status` d'approbation :

| Statut | Signification |
|---|---|
| `draft` | Créé ou enregistré mais pas encore envoyé pour examen. Vous pouvez toujours le modifier. |
| `received` | Soumis et accepté dans la file d'attente d'examen. |
| `pending` | En cours d'examen. |
| `approved` | Autorisé pour l'envoi. |
| `rejected` | Refusé. Le champ `rejection_reason` explique pourquoi ; corrigez-le, puis soumettez à nouveau. |

Seuls les modèles `draft` et `rejected` peuvent être modifiés ou (re)soumis. Une fois qu'un modèle est `approved`, il est verrouillé — créez-en un nouveau si vous avez besoin de modifications.

> **Approbation automatique :** Certains canaux ne nécessitent pas d'étape d'examen externe. Les modèles créés ou soumis pour une campagne sur un tel canal sont enregistrés immédiatement comme `approved`, sans identifiant de contenu (`sid`).

---

## Modèles sur les comptes connectés à Meta

Ces points de terminaison fonctionnent de la même manière, quel que soit le type de connexion WhatsApp utilisé par votre compte, mais ce qui se passe en arrière-plan diffère :

- Sur une **connexion WhatsApp gérée**, les modèles sont enregistrés auprès du fournisseur de messagerie et `sid` est l'identifiant de contenu du fournisseur (`HXXXXXXXX…`).
- Sur un compte dont le numéro fonctionne sur **son propre compte WhatsApp Business** (l'une ou l'autre des options de connexion Meta), les modèles sont créés et examinés **dans ce compte WhatsApp Business** et `sid` est l'identifiant de modèle propre à Meta — une chaîne numérique telle que `"3394843740694756"`. `status` utilise toujours les valeurs du tableau ci-dessus, et `rejection_reason` contient toujours l'explication de Meta.

Deux points de terminaison supplémentaires existent à cet effet : l'un pour demander sur quelle connexion vous vous trouvez, et l'autre pour réconcilier votre liste de modèles avec votre compte WhatsApp Business. Les modèles qui existent déjà dans le compte WhatsApp Business sont importés dans votre bibliothèque par la synchronisation, de sorte qu'un `GET /whatsapp-templates` ultérieur les répertorie comme n'importe quel autre modèle.

### Vérifier sur quelle connexion les modèles fonctionnent

`GET /whatsapp-templates/provider`

| Champ | Description |
|---|---|
| `provider` | `twilio` lorsque les modèles sont enregistrés auprès du fournisseur de messagerie géré, `meta` lorsqu'ils résident dans votre propre compte WhatsApp Business. |
| `lane` | Quelle connexion Meta est utilisée — `meta_cloud_api` (votre propre application Meta) ou `meta_embedded` (connectée via notre application Meta). `null` sur une connexion gérée. |
| `waba_id` | Le compte WhatsApp Business dans lequel les modèles sont créés, ou `null`. |
| `templates_enabled` | `false` lorsque la connexion Meta n'est pas encore terminée (aucun compte WhatsApp Business ou jeton d'accès stocké). La création ou la soumission de modèles échoue avec un `400` tant que ce n'est pas le cas. |

**cURL**

```bash
curl "https://api.youraiconnector.com/v1/whatsapp-templates/provider?apiKey=YOUR_API_KEY"
```

**JavaScript**

```javascript
const res = await fetch("https://api.youraiconnector.com/v1/whatsapp-templates/provider", {
  headers: { "X-API-Key": "YOUR_API_KEY" },
});
const data = await res.json();
```

**Python**

```python
import requests

res = requests.get(
    "https://api.youraiconnector.com/v1/whatsapp-templates/provider",
    headers={"X-API-Key": "YOUR_API_KEY"},
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "provider": "meta",
  "lane": "meta_cloud_api",
  "waba_id": "2357661648036355",
  "templates_enabled": true
}
```

### Synchroniser les modèles depuis Meta

Actualise le statut d'approbation de chaque modèle résidant dans votre compte WhatsApp Business et importe tout modèle qui y existe mais ne figure pas encore dans votre bibliothèque. Vous pouvez l'appeler aussi souvent que vous le souhaitez sans risque. Sur une connexion gérée, il n'y a rien à synchroniser, donc l'appel ne fait rien et indique simplement combien de modèles vous avez.

`POST /whatsapp-templates/meta-sync`

| Champ | Description |
|---|---|
| `imported` | Modèles trouvés dans le compte WhatsApp Business qui ont été ajoutés à votre bibliothèque par cet appel. |
| `updated` | Modèles existants dont le statut ou les détails ont changé. |
| `total` | Modèles présents dans votre bibliothèque après la synchronisation. |

**cURL**

```bash
curl -X POST "https://api.youraiconnector.com/v1/whatsapp-templates/meta-sync?apiKey=YOUR_API_KEY"
```

**JavaScript**

```javascript
const res = await fetch("https://api.youraiconnector.com/v1/whatsapp-templates/meta-sync", {
  method: "POST",
  headers: { "X-API-Key": "YOUR_API_KEY" },
});
const data = await res.json();
```

**Python**

```python
import requests

res = requests.post(
    "https://api.youraiconnector.com/v1/whatsapp-templates/meta-sync",
    headers={"X-API-Key": "YOUR_API_KEY"},
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "provider": "meta",
  "imported": 2,
  "updated": 5,
  "total": 12
}
```

### Communiquer directement avec Meta (avancé)

Si vous avez besoin de quelque chose que les points de terminaison ci-dessus n'exposent pas — en-têtes de modèle, pieds de page, boutons ou un modèle entièrement créé manuellement — `/v1/meta-templates` transmet votre demande directement à l'API de modèles de Meta, sans rien stocker dans votre bibliothèque de modèles. Cela ne fonctionne que sur les comptes dont le numéro fonctionne sur leur propre compte WhatsApp Business ; sur une connexion gérée, chaque appel renvoie `400` vous demandant de connecter d'abord une application Meta.

| Point de terminaison | Ce qu'il fait |
|---|---|
| `GET /meta-templates` | Répertorie les modèles de votre compte WhatsApp Business avec leur dernier statut. Ajoutez `?name=` pour filtrer sur un nom de modèle exact. Renvoie `{ "success": true, "templates": [...] }`. |
| `POST /meta-templates` | Crée un modèle et le soumet à l'examen de Meta en une seule étape. Nécessite `name`, `language` et `body` (ou un tableau `components` complet au lieu de `body`). Optionnel : `variables` (tableau de chaînes), `category` (`MARKETING`, `UTILITY` ou `AUTHENTICATION`), `header`, `footer`, `buttons`. Renvoie `201` avec `{ "success": true, "template": {...} }`. |
| `DELETE /meta-templates/{name}` | Supprime le modèle par son nom Meta — **toutes ses langues**. Ajoutez `?hsm_id=` avec l'identifiant de modèle de Meta pour supprimer une seule langue. Renvoie `{ "success": true, "name": "..." }`. |

Un modèle refusé par Meta renvoie `400` avec l'explication de Meta dans `error`.

---

## Lister les modèles

Renvoie tous les modèles de votre compte, avec un résumé léger de chacun.

`GET /whatsapp-templates`

**cURL**

```bash
curl "https://api.youraiconnector.com/v1/whatsapp-templates?apiKey=YOUR_API_KEY"
```

**JavaScript**

```javascript
const res = await fetch("https://api.youraiconnector.com/v1/whatsapp-templates", {
  headers: { "X-API-Key": "YOUR_API_KEY" },
});
const data = await res.json();
```

**Python**

```python
import requests

res = requests.get(
    "https://api.youraiconnector.com/v1/whatsapp-templates",
    headers={"X-API-Key": "YOUR_API_KEY"},
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "data": [
    {
      "id": "template_abc123",
      "name": "welcome_message",
      "status": "approved",
      "language": "en",
      "body": "Hi {{first_name}}, thanks for reaching out!"
    },
    {
      "id": "template_def456",
      "name": "appointment_reminder",
      "status": "pending",
      "language": "en",
      "body": "Hi {{first_name}}, this is a reminder about your appointment."
    }
  ]
}
```

---

## Obtenir un modèle

Renvoie les détails complets d'un modèle unique, y compris ses variables, son statut et ses horodatages.

`GET /whatsapp-templates/{templateId}`

**cURL**

```bash
curl "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123" \
  -H "X-API-Key: YOUR_API_KEY"
```

**JavaScript**

```javascript
const res = await fetch(
  "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123",
  { headers: { "X-API-Key": "YOUR_API_KEY" } }
);
const data = await res.json();
```

**Python**

```python
import requests

res = requests.get(
    "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123",
    headers={"X-API-Key": "YOUR_API_KEY"},
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "template": {
    "id": "template_abc123",
    "name": "welcome_message",
    "body": "Hi {{first_name}}, thanks for reaching out!",
    "language": "en",
    "variables": ["first_name"],
    "status": "approved",
    "sid": "HXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
    "type": "general",
    "category": "marketing",
    "rejection_reason": null,
    "campaign_id": "campaign123",
    "date_created": "2026-06-01T10:00:00.000Z",
    "date_updated": "2026-06-02T08:30:00.000Z",
    "submitted_at": "2026-06-01T10:05:00.000Z",
    "approved_at": "2026-06-02T08:30:00.000Z"
  }
}
```

Un modèle qui n'existe pas sur votre compte renvoie `404` avec `{ "success": false, "error": "Template not found" }`.

---

## Créer un modèle

Crée un modèle pour le message d'ouverture d'une campagne et le soumet à approbation en une seule étape.

`POST /whatsapp-templates`

| Champ | Requis | Description |
|---|---|---|
| `campaign_id` | Oui | La campagne à laquelle appartient le modèle. |
| `name` | Oui | Un nom pour le modèle. |
| `language` | Oui | Code de langue, par exemple `en`, `es`, `de`, `pt_BR`, `zh_CN`. |
| `body` | Oui | Le texte du message, jusqu'à 1024 caractères. |
| `variables` | Non | Liste ordonnée des noms de variables utilisés dans le corps du message. |

Les espaces réservés de variables peuvent être écrits sous la forme `{{first_name}}`, `{first_name}` ou `[first_name]` — ils sont tous normalisés au format à double accolade.

Le résultat dépend des canaux de la campagne :

- **Campagne WhatsApp Business API :** le contenu est envoyé pour examen par WhatsApp. La réponse contient `campaign_status` (`received` ou `pending`) et un `template_sid`.
- **Un canal sans étape d'examen externe :** le modèle est stocké et automatiquement approuvé (`campaign_status: "approved"`, `template_sid: null`).
- **Aucun canal WhatsApp sur la campagne :** rien n'est créé et `campaign_status` est `not_applicable`.

**cURL**

```bash
curl -X POST "https://api.youraiconnector.com/v1/whatsapp-templates?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "campaign_id": "campaign123",
    "name": "welcome_message",
    "language": "en",
    "body": "Hi {{first_name}}, thanks for reaching out!",
    "variables": ["first_name"]
  }'
```

**JavaScript**

```javascript
const res = await fetch("https://api.youraiconnector.com/v1/whatsapp-templates", {
  method: "POST",
  headers: {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    campaign_id: "campaign123",
    name: "welcome_message",
    language: "en",
    body: "Hi {{first_name}}, thanks for reaching out!",
    variables: ["first_name"],
  }),
});
const data = await res.json();
```

**Python**

```python
import requests

res = requests.post(
    "https://api.youraiconnector.com/v1/whatsapp-templates",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={
        "campaign_id": "campaign123",
        "name": "welcome_message",
        "language": "en",
        "body": "Hi {{first_name}}, thanks for reaching out!",
        "variables": ["first_name"],
    },
)
data = res.json()
```

**Réponse** (soumis pour examen)

```json
{
  "success": true,
  "campaign_status": "pending",
  "template_sid": "HXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
}
```

---

## Créer un modèle autonome

Crée un modèle dans votre bibliothèque de modèles sans le lier au message d'ouverture d'une campagne. Il s'agit de l'étape de création du cycle de vie que le reste de cette page suit : créez-le ici, modifiez-le, soumettez-le pour examen, vérifiez son statut et supprimez-le lorsque vous n'en avez plus besoin.

`POST /whatsapp-templates/docs`

| Champ | Requis | Description |
|---|---|---|
| `name` | Oui | Un nom pour le modèle. |
| `language` | Oui | Code de langue, par exemple `en`, `es`, `de`, `pt_BR`, `zh_CN`. |
| `body` | Oui | Le texte du message, jusqu'à 1024 caractères. |
| `variables` | Non | Liste ordonnée des noms de variables utilisés dans le corps. |
| `status` | Non | `draft` (par défaut) le stocke sans le soumettre ; `submitted` le place immédiatement dans la file d'attente pour examen par WhatsApp. |
| `type` | Non | `general` (par défaut) ou `smart_followup`. |
| `category` | Non | `marketing`, `utility`, `authentication` ou `authentication-international`. |
| `campaign_id` | Non | Lie le modèle à l'une de vos campagnes. |

> **Modèles d'authentification (code à usage unique).** WhatsApp n'accepte pas les modèles d'authentification en texte libre : le corps du message est prédéfini par WhatsApp et le modèle doit comporter un bouton « copier le code ». Lorsque vous créez un modèle avec `category: "authentication"`, nous le soumettons dans ce format fixe pour vous. Votre `body` est conservé comme aperçu affiché dans l'application, mais le texte que votre contact reçoit est celui de WhatsApp (le code, un rappel de sécurité et une note d'expiration de 10 minutes). Déclarez exactement une variable, par exemple `["code"]`, et transmettez le code lors de l'envoi (voir le champ `variables` sur [Envoyer un modèle à un contact](#send-a-template-to-a-contact)). Le code doit comporter moins de 15 caractères.

> **Quelle méthode de création utiliser ?** Utilisez celle-ci lorsque vous souhaitez un modèle que vous pouvez modifier et soumettre vous-même. Utilisez `POST /whatsapp-templates` (ci-dessus) lorsque vous souhaitez définir le message d'ouverture d'une campagne — celle-ci nécessite `campaign_id` et écrit directement dans la campagne.

Un modèle créé en tant que `submitted` est envoyé pour examen par WhatsApp en arrière-plan ; vérifiez donc le point de terminaison de statut pour connaître le résultat plutôt que de l'attendre dans la réponse.

**cURL**

```bash
curl -X POST "https://api.youraiconnector.com/v1/whatsapp-templates/docs?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "welcome_message",
    "language": "en",
    "body": "Hi {{first_name}}, thanks for reaching out!",
    "variables": ["first_name"],
    "status": "draft",
    "category": "marketing"
  }'
```

**JavaScript**

```javascript
const res = await fetch("https://api.youraiconnector.com/v1/whatsapp-templates/docs", {
  method: "POST",
  headers: {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    name: "welcome_message",
    language: "en",
    body: "Hi {{first_name}}, thanks for reaching out!",
    variables: ["first_name"],
    status: "draft",
    category: "marketing",
  }),
});
const data = await res.json();
```

**Python**

```python
import requests

res = requests.post(
    "https://api.youraiconnector.com/v1/whatsapp-templates/docs",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={
        "name": "welcome_message",
        "language": "en",
        "body": "Hi {{first_name}}, thanks for reaching out!",
        "variables": ["first_name"],
        "status": "draft",
        "category": "marketing",
    },
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "template_id": "template_abc123",
  "status": "draft"
}
```

Un `name`, `language` ou `body` manquant, une langue non prise en charge, un `status` autre que `draft` ou `submitted`, un `type` ou `category` inconnu, ou un corps de plus de 1024 caractères renvoie `400` avec un `error` explicatif. Un `campaign_id` qui ne correspond pas à l'une de vos campagnes renvoie `404`.

---

## Mettre à jour un modèle

Modifie un modèle qui n'a pas encore été approuvé. Seuls les modèles avec le statut `draft` ou `rejected` peuvent être modifiés. Fournissez n'importe quelle combinaison de `name`, `body`, `language` et `variables` — seuls les champs que vous envoyez sont modifiés.

`PUT /whatsapp-templates/{templateId}`

> La modification ne soumet **pas** à nouveau le modèle pour examen. Utilisez le point de terminaison de soumission par la suite.

**cURL**

```bash
curl -X PUT "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123" \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "body": "Hi {{first_name}}, here is an update for you.",
    "variables": ["first_name"]
  }'
```

**JavaScript**

```javascript
const res = await fetch(
  "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123",
  {
    method: "PUT",
    headers: {
      "X-API-Key": "YOUR_API_KEY",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      body: "Hi {{first_name}}, here is an update for you.",
      variables: ["first_name"],
    }),
  }
);
const data = await res.json();
```

**Python**

```python
import requests

res = requests.put(
    "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={
        "body": "Hi {{first_name}}, here is an update for you.",
        "variables": ["first_name"],
    },
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "template_id": "template_abc123"
}
```

Tenter de modifier un modèle qui est déjà `approved` (ou qui n'est pas modifiable pour une autre raison), envoyer des champs vides ou envoyer une valeur non valide renvoie `400` avec un `error` explicatif.

---

## Soumettre un modèle pour approbation

Soumet un modèle `draft` ou `rejected` pour examen. Les modèles sur un canal qui ne nécessite pas d'examen externe sont approuvés immédiatement ; tous les autres sont envoyés à WhatsApp et le `status` renvoyé (généralement `received` ou `pending`) est stocké sur le modèle.

`POST /whatsapp-templates/{templateId}/submit`

> Les **modèles de suivi** doivent déclarer et utiliser leurs variables requises avant de pouvoir être soumis : un espace réservé pour le prénom, ainsi qu'un espace réservé pour le contexte personnel pour les suivis intelligents.

**cURL**

```bash
curl -X POST "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/submit" \
  -H "X-API-Key: YOUR_API_KEY"
```

**JavaScript**

```javascript
const res = await fetch(
  "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/submit",
  { method: "POST", headers: { "X-API-Key": "YOUR_API_KEY" } }
);
const data = await res.json();
```

**Python**

```python
import requests

res = requests.post(
    "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/submit",
    headers={"X-API-Key": "YOUR_API_KEY"},
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "template_id": "template_abc123",
  "status": "pending",
  "sid": "HXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX"
}
```

---

## Vérifier le statut d'approbation

Un point de terminaison léger pour interroger le statut actuel d'un modèle. Le statut est lu à partir de l'enregistrement stocké, qui est actualisé périodiquement en arrière-plan, de sorte qu'une approbation ou un rejet très récent peut mettre un court instant à apparaître.

`GET /whatsapp-templates/{templateId}/status`

**cURL**

```bash
curl "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/status" \
  -H "X-API-Key: YOUR_API_KEY"
```

**JavaScript**

```javascript
const res = await fetch(
  "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/status",
  { headers: { "X-API-Key": "YOUR_API_KEY" } }
);
const data = await res.json();
```

**Python**

```python
import requests

res = requests.get(
    "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/status",
    headers={"X-API-Key": "YOUR_API_KEY"},
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "template_id": "template_abc123",
  "name": "welcome_message",
  "status": "approved",
  "sid": "HXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
  "rejection_reason": null,
  "date_updated": "2026-06-02T08:30:00.000Z"
}
```

---

## Supprimer un modèle

Supprime l'enregistrement du modèle de votre compte.

`DELETE /whatsapp-templates/{templateId}`

::: warning
**Important :** Sur une connexion gérée, seul l'enregistrement stocké est supprimé ; le contenu déjà approuvé par WhatsApp peut rester enregistré auprès du fournisseur de messagerie. Sur un compte utilisant son propre compte WhatsApp Business, le modèle est également supprimé de ce compte. Dans les deux cas, si une campagne utilise toujours ce modèle, redirigez cette campagne vers un autre modèle **avant** la suppression, sinon les envois qui en dépendent échoueront.
:::


**cURL**

```bash
curl -X DELETE "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123" \
  -H "X-API-Key: YOUR_API_KEY"
```

**JavaScript**

```javascript
const res = await fetch(
  "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123",
  { method: "DELETE", headers: { "X-API-Key": "YOUR_API_KEY" } }
);
const data = await res.json();
```

**Python**

```python
import requests

res = requests.delete(
    "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123",
    headers={"X-API-Key": "YOUR_API_KEY"},
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "template_id": "template_abc123",
  "note": "The template record was removed from your account. Content already approved by WhatsApp may remain registered with the messaging provider."
}
```

---

## Envoyer un modèle à un contact

Envoie un modèle approuvé à un contact, même en l'absence de conversation ouverte — cela rouvre la session de chat. Vous pouvez cibler le contact par `contactId` ou par `phoneNumber`, et choisir le modèle par `whatsappTemplateId` ou par `templateName`.

`POST /whatsapp-templates/send`

| Champ | Requis | Description |
|---|---|---|
| `contactId` | L'un de ces deux | L'identifiant du contact. |
| `phoneNumber` | L'un de ces deux | Le numéro de téléphone du contact (avec l'indicatif pays, sans espaces). Recherché ou créé si nécessaire. |
| `whatsappTemplateId` | L'un de ces deux | L'identifiant du modèle. |
| `templateName` | L'un de ces deux | Le nom du modèle, tel qu'affiché dans l'application. |
| `firstName` | Non | Utilisé pour remplir un contact nouvellement créé. |
| `lastName` | Non | Utilisé pour remplir un contact nouvellement créé. |
| `email` | Non | Utilisé pour remplir un contact nouvellement créé. |
| `variables` | Non | Valeurs explicites pour les variables du modèle, indexées par nom de variable, par exemple `{ "code": "482913" }`. Une valeur donnée ici prévaut sur les champs du contact pour cette variable ; les variables que vous omettez sont toujours remplies à partir du contact comme décrit ci-dessous. C'est ainsi que vous transmettez un code à usage unique à un modèle d'authentification. |

Le corps du modèle prend en charge la substitution avancée de variables :

- **Variables de base :** `{{first_name}}`, `{{email}}`, `{{company}}`
- **Valeurs par défaut :** `{{first_name|there}}` affiche `there` si le champ est vide
- **Transformations :** `{{company|uppercase}}`, `{{name|lowercase}}`, `{{name|capitalize}}`
- **Combiné :** `{{company|Your Company|uppercase}}`

> **Crédits :** L'envoi d'un modèle consomme des crédits. Le coût exact dépend du pays du destinataire et de la catégorie du modèle.

**cURL**

```bash
curl -X POST "https://api.youraiconnector.com/v1/whatsapp-templates/send?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "contactId": "contact123",
    "whatsappTemplateId": "template_abc123"
  }'
```

**JavaScript**

```javascript
const res = await fetch("https://api.youraiconnector.com/v1/whatsapp-templates/send", {
  method: "POST",
  headers: {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    contactId: "contact123",
    whatsappTemplateId: "template_abc123",
  }),
});
const data = await res.json();
```

**Python**

```python
import requests

res = requests.post(
    "https://api.youraiconnector.com/v1/whatsapp-templates/send",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={
        "contactId": "contact123",
        "whatsappTemplateId": "template_abc123",
    },
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "data": "WhatsApp template message sent successfully"
}
```

Une requête manquant à la fois d'un identifiant de contact et des deux identifiants de modèle renvoie `400`. Si votre compte ne dispose pas des identifiants de messagerie nécessaires pour l'envoi, la réponse est `403`.

---

## Créer ou mettre à jour le modèle actif d'une campagne

Une seconde paire de points de terminaison pour le modèle d'ouverture d'une campagne, définis par le chemin d'accès plutôt que par un `campaign_id` dans le corps de la requête. Ce sont ceux à utiliser pour une campagne déjà active : contrairement à [Créer un modèle](#create-a-template) ci-dessus, la mise à jour ici soumet également à nouveau les brouillons de suivi de la campagne pour examen, afin que le modèle d'ouverture et ses suivis restent synchronisés.

`POST /whatsapp-templates/campaign/{campaignId}` crée le modèle d'ouverture de la campagne. `PUT /whatsapp-templates/campaign/{campaignId}` le modifie — la campagne doit déjà posséder un modèle, sinon cela renvoie `400`.

| Champ | Requis | Description |
|---|---|---|
| `name` | Oui | Un nom pour le modèle. |
| `language` | Oui | Code de langue, par exemple `en`, `es`, `de`, `pt_BR`, `zh_CN`. |
| `body` | Oui | Le texte du message, jusqu'à 1024 caractères. |
| `variables` | Oui | Liste ordonnée des noms de variables utilisés dans le corps. Passez un tableau vide si le modèle n'en utilise aucun. |

**cURL** (créer)

```bash
curl -X POST "https://api.youraiconnector.com/v1/whatsapp-templates/campaign/campaign123?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "welcome_message",
    "language": "en",
    "body": "Hi {{first_name}}, thanks for reaching out!",
    "variables": ["first_name"]
  }'
```

**JavaScript**

```javascript
const res = await fetch("https://api.youraiconnector.com/v1/whatsapp-templates/campaign/campaign123", {
  method: "POST",
  headers: {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    name: "welcome_message",
    language: "en",
    body: "Hi {{first_name}}, thanks for reaching out!",
    variables: ["first_name"],
  }),
});
const data = await res.json();
```

**Python**

```python
import requests

res = requests.post(
    "https://api.youraiconnector.com/v1/whatsapp-templates/campaign/campaign123",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={
        "name": "welcome_message",
        "language": "en",
        "body": "Hi {{first_name}}, thanks for reaching out!",
        "variables": ["first_name"],
    },
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "campaign_status": "pending",
  "template_sid": "HXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX",
  "message": "WhatsApp template created and campaign updated successfully."
}
```

Pour modifier, changez la méthode pour `PUT` et utilisez les mêmes champs — cela soumet à nouveau le modèle d'ouverture (et les brouillons de suivi de la campagne, sur une campagne WhatsApp API) pour examen.

Une campagne qui n'appartient pas à votre compte renvoie `404` ; une campagne appartenant à un autre compte pour lequel vous n'êtes pas autorisé renvoie `403`. La modification d'une campagne sans modèle existant renvoie `400`.

---

## Envoyer un modèle à un contact existant

Une alternative plus simple, définie par le chemin d'accès, à [Envoyer un modèle à un contact](#send-a-template-to-a-contact) ci-dessus : le modèle et le contact doivent déjà exister — rien n'est recherché par nom ou créé à la volée.

`POST /whatsapp-templates/{templateId}/send-to-contact`

| Champ | Requis | Description |
|---|---|---|
| `contactId` | Oui | L'identifiant du contact. Doit appartenir à votre compte. |

**cURL**

```bash
curl -X POST "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/send-to-contact?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "contactId": "contact123" }'
```

**JavaScript**

```javascript
const res = await fetch(
  "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/send-to-contact",
  {
    method: "POST",
    headers: {
      "X-API-Key": "YOUR_API_KEY",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ contactId: "contact123" }),
  }
);
const data = await res.json();
```

**Python**

```python
import requests

res = requests.post(
    "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/send-to-contact",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={"contactId": "contact123"},
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "data": "WhatsApp template message sent successfully"
}
```

> **Crédits :** L'envoi consomme des crédits, facturés de la même manière que le point de terminaison ci-dessus. Un `contactId` manquant ou n'appartenant pas à votre compte renvoie `403` ; un `templateId` inexistant renvoie `404`.

---

## Envoi groupé d'un modèle

Envoyez un modèle à de nombreux contacts en un seul appel, avec un aperçu du coût que vous pouvez afficher avant de confirmer.

### Estimer le coût au préalable

Renvoie le coût d'un envoi, détaillé par pays de destination, sans rien envoyer ni utiliser de crédits. La tarification des modèles est par pays de destination, elle doit donc être calculée côté serveur par rapport aux contacts réels plutôt qu'estimée côté client.

`POST /whatsapp-templates/{templateId}/estimate-bulk-cost`

| Champ | Requis | Description |
|---|---|---|
| `contactIds` | Oui | Contacts à tarifer, jusqu'à 500 par appel. Les doublons sont comptés une seule fois. |

**cURL**

```bash
curl -X POST "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/estimate-bulk-cost?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "contactIds": ["contact123", "contact456"] }'
```

**JavaScript**

```javascript
const res = await fetch(
  "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/estimate-bulk-cost",
  {
    method: "POST",
    headers: {
      "X-API-Key": "YOUR_API_KEY",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ contactIds: ["contact123", "contact456"] }),
  }
);
const data = await res.json();
```

**Python**

```python
import requests

res = requests.post(
    "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/estimate-bulk-cost",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={"contactIds": ["contact123", "contact456"]},
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "data": {
    "countries": [
      {
        "countryCode": "1",
        "name": "United States",
        "iso": "US",
        "flag": "🇺🇸",
        "contactCount": 120,
        "costPerContact": 0.5,
        "subtotal": 60.0
      }
    ],
    "totalContacts": 120,
    "totalTemplateCost": 60.0,
    "templateCategory": "marketing",
    "skippedContacts": 2
  }
}
```

`skippedContacts` compte les identifiants manquants, qui ne vous appartiennent pas ou qui n'ont pas de numéro de téléphone — l'estimation ne couvre que le reste, donc une valeur non nulle signifie que l'envoi réel atteindra moins de contacts que ceux sélectionnés.

### Envoyer le lot

Envoie le modèle à chaque contact de la liste, en résolvant toutes les variables intelligentes par contact et en débitant des crédits par envoi.

`POST /whatsapp-templates/{templateId}/bulk-send`

| Champ | Requis | Description |
|---|---|---|
| `contactIds` | Oui | Contacts auxquels envoyer, jusqu'à 5000 par appel. |

**cURL**

```bash
curl -X POST "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/bulk-send?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "contactIds": ["contact123", "contact456"] }'
```

**JavaScript**

```javascript
const res = await fetch(
  "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/bulk-send",
  {
    method: "POST",
    headers: {
      "X-API-Key": "YOUR_API_KEY",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ contactIds: ["contact123", "contact456"] }),
  }
);
const data = await res.json();
```

**Python**

```python
import requests

res = requests.post(
    "https://api.youraiconnector.com/v1/whatsapp-templates/template_abc123/bulk-send",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={"contactIds": ["contact123", "contact456"]},
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "data": { "sent": 118, "failed": 2, "total": 120 }
}
```

Un contact qui échoue (non trouvé, pas sur votre compte ou erreur d'envoi) est ignoré et compté dans `failed` au lieu d'arrêter le lot. Un `contactIds` vide, plus de 5000 identifiants sur un envoi (500 sur une estimation) ou un `templateId` manquant renvoie `400`.

---

## Réessayer un message ayant échoué

Deux points de terminaison pour renvoyer un message ayant échoué, sans créer de nouvel enregistrement de message ni dépenser à nouveau des crédits.

`POST /whatsapp-templates/messages/{contactId}/{messageId}/retry-template` réessaie spécifiquement un message de modèle ayant échoué — il résout à nouveau le contenu du modèle à partir de la campagne si le message ayant échoué ne le contient pas déjà. Seuls les messages avec le statut `failed` et le type `template` peuvent être réessayés de cette manière.

`POST /whatsapp-templates/messages/{contactId}/{messageId}/retry` est indépendant du canal et fonctionne pour tout message non basé sur un modèle ayant échoué (par exemple WhatsApp Web), en le dirigeant vers le bon chemin d'envoi en fonction du canal du message. Il accepte les statuts `failed`, `failed_connection`, `limit_exceeded` ou `queued_retry`.

Aucun des deux points de terminaison ne prend de corps de requête.

**cURL**

```bash
curl -X POST "https://api.youraiconnector.com/v1/whatsapp-templates/messages/contact123/msg_abc789/retry-template?apiKey=YOUR_API_KEY"
```

**JavaScript**

```javascript
const res = await fetch(
  "https://api.youraiconnector.com/v1/whatsapp-templates/messages/contact123/msg_abc789/retry-template",
  { method: "POST", headers: { "X-API-Key": "YOUR_API_KEY" } }
);
const data = await res.json();
```

**Python**

```python
import requests

res = requests.post(
    "https://api.youraiconnector.com/v1/whatsapp-templates/messages/contact123/msg_abc789/retry-template",
    headers={"X-API-Key": "YOUR_API_KEY"},
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "data": "Message retry initiated successfully"
}
```

Pour la version indépendante du canal, remplacez le chemin par `.../msg_abc789/retry`. Un message dont le statut n'est pas éligible à une nouvelle tentative, ou (sur le point de terminaison de modèle) qui n'est pas un message de modèle, renvoie `400`. Un contact ou un message manquant renvoie `404`.

---

## Profil WhatsApp Business

Gérez le profil WhatsApp Business (à propos, adresse, description, e-mail, sites web, catégorie d'entreprise et logo) affiché aux contacts sur WhatsApp. Fonctionne à la fois sur une connexion gérée et sur un compte utilisant son propre compte WhatsApp Business.

### Enregistrer le profil

`PUT /whatsapp-templates/profile`

| Champ | Requis | Description |
|---|---|---|
| `phoneNumber` | Oui | Le numéro WhatsApp auquel appartient ce profil. Doit être connecté sur votre compte. |
| `about` | Non | Court texte « À propos » affiché sur le profil. |
| `address` | Non | Adresse de l'entreprise. |
| `description` | Non | Description plus longue de l'entreprise. |
| `email` | Non | E-mail de contact affiché sur le profil. |
| `websites` | Non | Tableau d'URLs de sites web. Chacune doit être une URL valide. |
| `vertical` | Non | Catégorie d'entreprise, par exemple `Retail` ou `Professional Services`. |
| `profilePictureHandle` | Non | L'identifiant renvoyé par le point de terminaison de téléchargement d'image ci-dessous, pour définir la photo de profil. |

**cURL**

```bash
curl -X PUT "https://api.youraiconnector.com/v1/whatsapp-templates/profile?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "phoneNumber": "+31612345678",
    "about": "We reply within a few hours",
    "email": "support@example.com",
    "websites": ["https://example.com"]
  }'
```

**JavaScript**

```javascript
const res = await fetch("https://api.youraiconnector.com/v1/whatsapp-templates/profile", {
  method: "PUT",
  headers: {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    phoneNumber: "+31612345678",
    about: "We reply within a few hours",
    email: "support@example.com",
    websites: ["https://example.com"],
  }),
});
const data = await res.json();
```

**Python**

```python
import requests

res = requests.put(
    "https://api.youraiconnector.com/v1/whatsapp-templates/profile",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={
        "phoneNumber": "+31612345678",
        "about": "We reply within a few hours",
        "email": "support@example.com",
        "websites": ["https://example.com"],
    },
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "data": "WhatsApp Business profile updated successfully"
}
```

Un `phoneNumber` manquant, une URL de site web invalide ou un `phoneNumber` non connecté sur votre compte renvoie `400` ou `404`.

### Télécharger une photo de profil

Télécharge une image à partir d'une URL que vous fournissez et l'envoie sur WhatsApp, en renvoyant un identifiant. Transmettez cet identifiant en tant que `profilePictureHandle` lors de l'appel d'enregistrement du profil ci-dessus pour la définir comme photo — ce point de terminaison télécharge uniquement l'image, il ne la définit pas lui-même.

`POST /whatsapp-templates/profile/picture`

| Champ | Requis | Description |
|---|---|---|
| `phoneNumber` | Oui | Le numéro WhatsApp auquel appartient ce profil. |
| `fileUrl` | Oui | Une URL accessible publiquement vers l'image à télécharger. |

**cURL**

```bash
curl -X POST "https://api.youraiconnector.com/v1/whatsapp-templates/profile/picture?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "phoneNumber": "+31612345678",
    "fileUrl": "https://example.com/logo.png"
  }'
```

**JavaScript**

```javascript
const res = await fetch("https://api.youraiconnector.com/v1/whatsapp-templates/profile/picture", {
  method: "POST",
  headers: {
    "X-API-Key": "YOUR_API_KEY",
    "Content-Type": "application/json",
  },
  body: JSON.stringify({
    phoneNumber: "+31612345678",
    fileUrl: "https://example.com/logo.png",
  }),
});
const data = await res.json();
```

**Python**

```python
import requests

res = requests.post(
    "https://api.youraiconnector.com/v1/whatsapp-templates/profile/picture",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={
        "phoneNumber": "+31612345678",
        "fileUrl": "https://example.com/logo.png",
    },
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "data": "1234567890123456"
}
```

`data` est l'identifiant de l'image téléchargée. Un `phoneNumber` ou `fileUrl` manquant, ou un `phoneNumber` sans jeton d'accès WhatsApp enregistré, renvoie `400` ; une `fileUrl` inaccessible ou invalide renvoie une erreur décrivant la raison de l'échec du téléchargement.

---

## Vérifier le statut d'un expéditeur

Interroge (et actualise) le statut d'envoi en direct d'un numéro WhatsApp connecté auprès du fournisseur de messagerie. Utile pour confirmer qu'un numéro est réellement capable d'envoyer des messages avant de vous y fier.

`GET /whatsapp-templates/sender-status/{phoneNumber}`

**cURL**

```bash
curl "https://api.youraiconnector.com/v1/whatsapp-templates/sender-status/+31612345678" \
  -H "X-API-Key: YOUR_API_KEY"
```

**JavaScript**

```javascript
const res = await fetch(
  "https://api.youraiconnector.com/v1/whatsapp-templates/sender-status/+31612345678",
  { headers: { "X-API-Key": "YOUR_API_KEY" } }
);
const data = await res.json();
```

**Python**

```python
import requests

res = requests.get(
    "https://api.youraiconnector.com/v1/whatsapp-templates/sender-status/+31612345678",
    headers={"X-API-Key": "YOUR_API_KEY"},
)
data = res.json()
```

**Réponse**

```json
{
  "success": true,
  "data": "ONLINE"
}
```

`data` est l'un des états suivants : `ONLINE` (envoi normal), `PENDING` (en cours de vérification) ou `DELETED` (le fournisseur ne reconnaît plus cet expéditeur — reconnectez le numéro). Un `phoneNumber` sans informations professionnelles WhatsApp enregistrées renvoie `404`.

---

## Générer des modèles de suivi avec l'IA

La plateforme peut rédiger pour vous les modèles de suivi WhatsApp d'une campagne — les relances envoyées lorsqu'une conversation s'essouffle — à partir des instructions et de l'objectif de la campagne. Il existe un point de terminaison de tâche qui s'exécute en arrière-plan, ainsi que trois anciens points de terminaison conservés pour les intégrations existantes. Tous utilisent des crédits IA.

### Démarrer une tâche de génération

`POST /campaigns/{campaignId}/template-generation`

| Champ | Requis | Description |
|---|---|---|
| `type` | Non | `all` (par défaut) rédige l'ensemble complet des suivis. `cold_only` rédige uniquement les messages pour les contacts qui n'ont jamais répondu. |

**cURL**

```bash
curl -X POST "https://api.youraiconnector.com/v1/campaigns/campaign_abc123/template-generation?apiKey=YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "type": "all" }'
```

**JavaScript**

```javascript
const res = await fetch(
  "https://api.youraiconnector.com/v1/campaigns/campaign_abc123/template-generation",
  {
    method: "POST",
    headers: {
      "X-API-Key": "YOUR_API_KEY",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ type: "all" }),
  }
);
const data = await res.json();
```

**Python**

```python
import requests

res = requests.post(
    "https://api.youraiconnector.com/v1/campaigns/campaign_abc123/template-generation",
    headers={"X-API-Key": "YOUR_API_KEY"},
    json={"type": "all"},
)
data = res.json()
```

**Réponse** (`202`)

```json
{ "success": true, "campaign_id": "campaign_abc123", "type": "all" }
```

L'appel renvoie une réponse dès que la tâche est mise en file d'attente. Lisez la campagne (`GET /campaigns/{campaignId}`, voir l'[API Campagnes](campaigns.md)) et surveillez son objet `template_generation_status` jusqu'à ce qu'elle soit terminée :

| Champ | Description |
|---|---|
| `status` | `processing` pendant l'exécution de la tâche, puis `completed` ou `failed`. |
| `progress` | De 0 à 100. |
| `current_template`, `total_templates` | Combien de modèles ont été rédigés jusqu'à présent, sur le nombre total que la tâche doit générer — 11 pour une campagne sortante ou combinée, 9 sinon. |
| `error` | Raison pour laquelle une tâche `failed` s'est arrêtée, par exemple un manque de crédits. |
| `started_at`, `completed_at` | Date et heure de début et de fin de la tâche. |

Les modèles générés sont ajoutés à la campagne comme n'importe quel autre, ils apparaissent donc dans [Lister les modèles](#list-templates) et doivent toujours passer par l'approbation WhatsApp avant de pouvoir être envoyés. Un `400` signifie que `type` était différent de `all` ou `cold_only` ; un `404` signifie que la campagne n'existe pas ou appartient à un autre compte.

Les agents disposent d'un équivalent de cet appel, `POST /agents/{agentId}/template-generation`, qui rédige les suivis pour un Agent et se termine pendant l'appel dans le cas habituel — voir [Générer des messages de suivi](agents.md#generate-follow-up-messages) dans l'API des Agents IA.

### Les anciens points de terminaison de génération

Trois points de terminaison antérieurs effectuent le même travail et sont conservés afin que les intégrations existantes continuent de fonctionner. Le nouveau code doit utiliser le point de terminaison de tâche ci-dessus.

| Point de terminaison | Ce qu'il fait |
|---|---|
| `POST /whatsapp-templates/campaign/{campaignId}/generate-async` | Démarre la génération de suivi pour la campagne en arrière-plan et renvoie `202` avec `{ "success": true, "data": { "result": "success", "message": "..." } }`. Les crédits sont débités à l'avance (ignoré sur un compte qui utilise sa propre clé IA) et l'objet `template_generation_status` de la campagne rapporte la progression exactement comme ci-dessus. |
| `POST /whatsapp-templates/campaign/{campaignId}/generate-followups` | Génère les neuf modèles de suivi pendant l'appel — pour une campagne créée avant l'existence des suivis automatiques, ou une campagne nécessitant une nouvelle rédaction — et renvoie `200` avec `templatesGenerated` dans `data`. |
| `POST /whatsapp-templates/agent/{agentId}/generate-followups` | La même génération synchrone adressée par Agent. La réponse ajoute `agent_id`, `campaign_id` et `target` : `"campaign"` lorsque les modèles ont été écrits sur la campagne de l'Agent, `"agent"` (avec `campaign_id: null`) lorsque l'Agent n'a pas de campagne et qu'ils ont été stockés sur l'Agent lui-même. Un Agent manquant ou étranger est un `404`. |

Tous les trois nécessitent que les suivis automatiques soient activés sur le compte et qu'il y ait suffisamment de crédits — un `400` indique lequel manque — et la paire adressée à la campagne renvoie `403` lorsque la campagne appartient à un autre compte.

---

## Erreurs de l'API des modèles

Les points de terminaison des modèles renvoient l'enveloppe d'erreur standard :

```json
{
  "success": false,
  "error": "Template not found"
}
```

Une `404` sur ces points de terminaison signifie généralement que la ressource est introuvable — soit elle n'existe pas, soit elle appartient à un autre compte. Quelques points de terminaison (la création/mise à jour au niveau de la campagne, et les envois vers un contact existant) renvoient `403` à la place lorsque la campagne ou le contact appartient à quelqu'un d'autre plutôt que de ne pas exister du tout. Certains points de terminaison incluent également un champ `error_code` reflétant le statut HTTP. Les codes partagés que chaque point de terminaison peut renvoyer — `400`, `401`, `403` (votre forfait n'inclut pas l'accès à l'API), `429` (limite de débit) et `500` — sont répertoriés avec des conseils de nouvelle tentative dans [Erreurs et pagination](errors-and-pagination.md).

---

## Étapes suivantes

- [Authentification](authentication.md) — les quatre méthodes pour authentifier une requête.
- [Erreurs et limites de débit](errors-and-pagination.md) — codes d'état et limite de 300 req/min.
- [API Campagnes](campaigns.md) — gérez les campagnes auxquelles les modèles sont associés.