# WhatsApp Templates API

WhatsApp-berichtsjablonen zijn vooraf geschreven berichten die zijn goedgekeurd voor verzending buiten het normale 24-uurs gespreksvenster — bijvoorbeeld een welkomstbericht, een afspraakherinnering of een herinnering om opnieuw contact op te nemen. Met deze API kun je sjablonen programmatisch weergeven, aanmaken, bewerken, indienen, controleren, verwijderen en verzenden.

Alle onderstaande paden zijn relatief ten opzichte van de API-basis-URL:

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

Elk verzoek moet worden geauthenticeerd. Zie [Authenticatie](authentication.md) voor de vier geaccepteerde methoden. De voorbeelden op deze pagina gebruiken de `X-API-Key`-header (en één query-parameter-vorm voor cURL).

::: note
**Let op:** Sjablonen maken gebruik van het WhatsApp Business API-kanaal, dus dit onderdeel van de API vereist zowel API-toegang als een abonnement dat WhatsApp-kanalen bevat. Zonder deze worden verzoeken afgewezen met een `403`.
:::


---

## Werken met subaccounts (bureaus)


---

## Goedkeuringsstatussen

Omdat berichten die buiten een open gesprek worden verzonden eerst door WhatsApp moeten worden beoordeeld, heeft elk sjabloon een goedkeurings-`status`:

| Status | Betekenis |
|---|---|
| `draft` | Aangemaakt of opgeslagen, maar nog niet ingediend voor beoordeling. Je kunt het nog bewerken. |
| `received` | Ingediend en geaccepteerd in de beoordelingswachtrij. |
| `pending` | In beoordeling. |
| `approved` | Goedgekeurd voor verzending. |
| `rejected` | Afgewezen. Het `rejection_reason`-veld legt uit waarom; pas het aan en dien het opnieuw in. |

Alleen `draft`- en `rejected`-sjablonen kunnen worden bewerkt of (opnieuw) worden ingediend. Zodra een sjabloon `approved` is, is het vergrendeld — maak een nieuwe aan als je wijzigingen nodig hebt.

> **Automatische goedkeuring:** Sommige kanalen vereisen geen externe beoordelingsstap. Sjablonen die voor een campagne op een dergelijk kanaal zijn aangemaakt of ingediend, worden onmiddellijk opgeslagen als `approved`, zonder inhouds-ID (`sid`).

---

## Sjablonen op Meta-gekoppelde accounts

Deze eindpunten werken op dezelfde manier, ongeacht op welke WhatsApp-verbinding uw account draait, maar wat er achter de schermen gebeurt, verschilt:

- Bij een **beheerde WhatsApp-verbinding** worden sjablonen geregistreerd bij de berichtprovider en is `sid` de content-ID van de provider (`HXXXXXXXX…`).
- Bij een account waarvan het nummer op een **eigen WhatsApp Business-account** draait (beide Meta-verbindingsopties), worden sjablonen aangemaakt en beoordeeld **in dat WhatsApp Business-account** en is `sid` Meta's eigen sjabloon-ID — een numerieke reeks zoals `"3394843740694756"`. `status` gebruikt nog steeds de waarden in de tabel hierboven, en `rejection_reason` bevat nog steeds de uitleg van Meta.

Hiervoor bestaan twee extra eindpunten: één om te vragen op welke verbinding u zit, en één om uw sjabloonlijst te synchroniseren met uw WhatsApp Business-account. Sjablonen die al in het WhatsApp Business-account bestaan, worden door de synchronisatie in uw bibliotheek geïmporteerd, zodat een `GET /whatsapp-templates` ze daarna weergeeft zoals elk ander sjabloon.

### Controleren op welke verbinding sjablonen draaien

`GET /whatsapp-templates/provider`

| Veld | Beschrijving |
|---|---|
| `provider` | `twilio` wanneer sjablonen zijn geregistreerd bij de beheerde berichtprovider, `meta` wanneer ze in uw eigen WhatsApp Business-account staan. |
| `lane` | Welke Meta-verbinding in gebruik is — `meta_cloud_api` (uw eigen Meta-app) of `meta_embedded` (gekoppeld via onze Meta-app). `null` bij een beheerde verbinding. |
| `waba_id` | Het WhatsApp Business-account waarin de sjablonen zijn aangemaakt, of `null`. |
| `templates_enabled` | `false` wanneer de Meta-verbinding nog niet voltooid is (geen WhatsApp Business-account of toegangstoken opgeslagen). Het aanmaken of indienen van sjablonen mislukt met een `400` totdat dit wel het geval is. |

**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()
```

**Antwoord**

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

### Sjablonen synchroniseren vanuit Meta

Vernieuwt de goedkeuringsstatus van elk sjabloon dat in uw WhatsApp Business-account staat, en importeert elk sjabloon dat daar wel bestaat maar nog niet in uw bibliotheek staat. Kan veilig zo vaak worden aangeroepen als u wilt. Bij een beheerde verbinding valt er niets te synchroniseren, dus de aanroep doet niets en rapporteert simpelweg hoeveel sjablonen u heeft.

`POST /whatsapp-templates/meta-sync`

| Veld | Beschrijving |
|---|---|
| `imported` | Sjablonen gevonden in het WhatsApp Business-account die door deze aanroep aan uw bibliotheek zijn toegevoegd. |
| `updated` | Bestaande sjablonen waarvan de status of details zijn gewijzigd. |
| `total` | Sjablonen in uw bibliotheek na de synchronisatie. |

**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()
```

**Antwoord**

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

### Direct communiceren met Meta (geavanceerd)

Als u iets nodig heeft dat de bovenstaande eindpunten niet bieden — sjabloonheaders, voetteksten, knoppen of een volledig handmatig opgebouwd sjabloon — stuurt `/v1/meta-templates` uw verzoek direct door naar de eigen sjabloon-API van Meta, zonder iets op te slaan in uw sjabloonbibliotheek. Dit werkt alleen op accounts waarvan het nummer op hun eigen WhatsApp Business-account draait; bij een beheerde verbinding retourneert elke aanroep `400` met het verzoek om eerst een Meta-app te koppelen.

| Eindpunt | Wat het doet |
|---|---|
| `GET /meta-templates` | Geeft de sjablonen in uw WhatsApp Business-account weer met hun laatste status. Voeg `?name=` toe om te filteren op één specifieke sjabloonnaam. Retourneert `{ "success": true, "templates": [...] }`. |
| `POST /meta-templates` | Maakt een sjabloon aan en dient het in één stap in voor beoordeling door Meta. Vereist `name`, `language` en `body` (of een volledige `components`-array in plaats van `body`). Optioneel: `variables` (array van strings), `category` (`MARKETING`, `UTILITY` of `AUTHENTICATION`), `header`, `footer`, `buttons`. Retourneert `201` met `{ "success": true, "template": {...} }`. |
| `DELETE /meta-templates/{name}` | Verwijdert het sjabloon op basis van de Meta-naam — **elke taal** ervan. Voeg `?hsm_id=` toe met de sjabloon-ID van Meta om slechts één taal te verwijderen. Retourneert `{ "success": true, "name": "..." }`. |

Een sjabloon dat door Meta wordt geweigerd, retourneert `400` met de eigen uitleg van Meta in `error`.

---

## Sjablonen weergeven

Geeft alle sjablonen in je account terug, met een beknopte samenvatting van elk.

`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()
```

**Antwoord**

```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."
    }
  ]
}
```

---

## Een sjabloon ophalen

Geeft de volledige details van een enkel sjabloon terug, inclusief de variabelen, status en tijdstempels.

`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()
```

**Antwoord**

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

Een sjabloon dat niet bestaat in uw account geeft `404` terug met `{ "success": false, "error": "Template not found" }`.

---

## Een sjabloon maken

Maakt een sjabloon voor het openingsbericht van een campagne en dient dit in één stap in voor goedkeuring.

`POST /whatsapp-templates`

| Veld | Verplicht | Beschrijving |
|---|---|---|
| `campaign_id` | Ja | De campagne waartoe het sjabloon behoort. |
| `name` | Ja | Een naam voor het sjabloon. |
| `language` | Ja | Taalkode, bijvoorbeeld `en`, `es`, `de`, `pt_BR`, `zh_CN`. |
| `body` | Ja | De berichttekst, tot 1024 tekens. |
| `variables` | Nee | Geordende lijst met variabelenamen die in de hoofdtekst worden gebruikt. |

Variabele-placeholders kunnen worden geschreven als `{{first_name}}`, `{first_name}` of `[first_name]` — ze worden allemaal genormaliseerd naar de vorm met dubbele accolades.

Het resultaat hangt af van de kanalen van de campagne:

- **WhatsApp Business API-campagne:** de inhoud wordt verzonden voor WhatsApp-beoordeling. Het antwoord bevat `campaign_status` (`received` of `pending`) en een `template_sid`.
- **Een kanaal zonder externe beoordelingsstap:** het sjabloon wordt opgeslagen en automatisch goedgekeurd (`campaign_status: "approved"`, `template_sid: null`).
- **Geen WhatsApp-kanaal in de campagne:** er wordt niets aangemaakt en `campaign_status` is `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()
```

**Antwoord** (ingediend voor beoordeling)

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

---

## Een zelfstandig sjabloon maken

Hiermee maakt u een sjabloon in uw sjabloonbibliotheek zonder deze te koppelen aan het openingsbericht van een campagne. Dit is de aanmaakstap van de levenscyclus die de rest van deze pagina volgt: maak het hier aan, bewerk het, dien het in voor beoordeling, vraag de status op en verwijder het wanneer u het niet meer nodig heeft.

`POST /whatsapp-templates/docs`

| Veld | Vereist | Beschrijving |
|---|---|---|
| `name` | Ja | Een naam voor het sjabloon. |
| `language` | Ja | Taalkode, bijvoorbeeld `en`, `es`, `de`, `pt_BR`, `zh_CN`. |
| `body` | Ja | De berichttekst, maximaal 1024 tekens. |
| `variables` | Nee | Geordende lijst met variabelenamen die in de body worden gebruikt. |
| `status` | Nee | `draft` (standaard) slaat het op zonder in te dienen; `submitted` plaatst het direct in de wachtrij voor WhatsApp-beoordeling. |
| `type` | Nee | `general` (standaard) of `smart_followup`. |
| `category` | Nee | `marketing`, `utility`, `authentication` of `authentication-international`. |
| `campaign_id` | Nee | Koppelt het sjabloon aan een van uw campagnes. |

> **Sjablonen voor authenticatie (eenmalige code).** WhatsApp accepteert geen vrije-tekst-authenticatiesjablonen: de berichtinhoud is vooraf ingesteld door WhatsApp en het sjabloon moet een "code kopiëren"-knop bevatten. Wanneer u een sjabloon maakt met `category: "authentication"`, dienen wij deze in die vaste vorm voor u in. Uw `body` wordt bewaard als het voorbeeld dat in de app wordt getoond, maar de tekst die uw contactpersoon ontvangt is de eigen bewoording van WhatsApp (de code, een beveiligingsherinnering en een melding dat deze na 10 minuten verloopt). Declareer precies één variabele, bijvoorbeeld `["code"]`, en geef de code door wanneer u verzendt (zie het veld `variables` op [Een sjabloon naar een contactpersoon sturen](#send-a-template-to-a-contact)). De code moet korter zijn dan 15 tekens.

> **Welke 'create' moet ik gebruiken?** Gebruik deze wanneer u een sjabloon wilt dat u zelf kunt bewerken en indienen. Gebruik `POST /whatsapp-templates` (hierboven) wanneer u het openingsbericht van een campagne wilt instellen — die vereist `campaign_id` en schrijft direct naar de campagne.

Een sjabloon dat is aangemaakt als `submitted` wordt op de achtergrond verzonden voor WhatsApp-beoordeling. Controleer daarom het status-eindpunt voor het resultaat in plaats van dit in het antwoord te verwachten.

**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()
```

**Antwoord**

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

Een ontbrekende `name`, `language` of `body`, een niet-ondersteunde taal, een `status` anders dan `draft` of `submitted`, een onbekende `type` of `category`, of een body van meer dan 1024 tekens resulteert in `400` met een verklarende `error`. Een `campaign_id` die niet een van uw campagnes is, resulteert in `404`.

---

## Een sjabloon bijwerken

Bewerkt een sjabloon dat nog niet is goedgekeurd. Alleen sjablonen met status `draft` of `rejected` kunnen worden bewerkt. Geef een willekeurige combinatie van `name`, `body`, `language` en `variables` op — alleen de velden die u verzendt, worden gewijzigd.

`PUT /whatsapp-templates/{templateId}`

> Bewerken zorgt er **niet** voor dat de sjabloon opnieuw wordt ingediend voor beoordeling. Gebruik daarna het submit-eindpunt.

**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()
```

**Antwoord**

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

Het proberen te bewerken van een sjabloon die al `approved` is (of anderszins niet bewerkbaar), het niet verzenden van velden of het verzenden van een ongeldige waarde resulteert in `400` met een verklarende `error`.

---

## Een sjabloon indienen voor goedkeuring

Dient een `draft` of `rejected` sjabloon in voor beoordeling. Sjablonen op een kanaal waarvoor geen externe beoordeling vereist is, worden onmiddellijk goedgekeurd; alle andere worden naar WhatsApp verzonden en de geretourneerde `status` (meestal `received` of `pending`) wordt opgeslagen bij de sjabloon.

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

> **Follow-up sjablonen** moeten hun vereiste variabelen declareren en gebruiken voordat ze kunnen worden ingediend: een voornaam-placeholder, plus een persoonlijke-context-placeholder voor slimme follow-ups.

**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()
```

**Antwoord**

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

---

## Goedkeuringsstatus controleren

Een lichtgewicht eindpunt voor het pollen van de huidige status van een sjabloon. De status wordt gelezen uit het opgeslagen record, dat periodiek op de achtergrond wordt vernieuwd, dus een zeer recente goedkeuring of afwijzing kan even duren voordat deze zichtbaar is.

`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()
```

**Antwoord**

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

---

## Een sjabloon verwijderen

Verwijdert het sjabloonrecord uit uw account.

`DELETE /whatsapp-templates/{templateId}`

::: warning
**Belangrijk:** Bij een beheerde verbinding wordt alleen het opgeslagen record verwijderd — inhoud die WhatsApp al heeft goedgekeurd, kan geregistreerd blijven bij de messaging-provider. Bij een account dat op een eigen WhatsApp Business-account draait, wordt de sjabloon ook uit dat account verwijderd. Hoe dan ook, als een campagne deze sjabloon nog gebruikt, wijs die campagne dan **vóór** het verwijderen naar een andere sjabloon, anders zullen verzendingen die ervan afhankelijk zijn mislukken.
:::


**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()
```

**Antwoord**

```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."
}
```

---

## Een sjabloon naar een contactpersoon sturen

Verstuurt een goedgekeurde sjabloon naar een contactpersoon, zelfs als er geen open gesprek is — dit heropent de chatsessie. Je kunt de contactpersoon targeten via `contactId` of via `phoneNumber`, en de sjabloon kiezen via `whatsappTemplateId` of via `templateName`.

`POST /whatsapp-templates/send`

| Veld | Vereist | Beschrijving |
|---|---|---|
| `contactId` | Een van deze twee | Het ID van de contactpersoon. |
| `phoneNumber` | Een van deze twee | Het telefoonnummer van de contactpersoon (met landcode, zonder spaties). Wordt opgezocht of aangemaakt indien nodig. |
| `whatsappTemplateId` | Een van deze twee | Het ID van het sjabloon. |
| `templateName` | Een van deze twee | De naam van het sjabloon, zoals getoond in de app. |
| `firstName` | Nee | Wordt gebruikt om een nieuw aangemaakte contactpersoon in te vullen. |
| `lastName` | Nee | Wordt gebruikt om een nieuw aangemaakte contactpersoon in te vullen. |
| `email` | Nee | Wordt gebruikt om een nieuw aangemaakte contactpersoon in te vullen. |
| `variables` | Nee | Expliciete waarden voor de variabelen van het sjabloon, gesleuteld op variabelenaam, bijvoorbeeld `{ "code": "482913" }`. Een waarde die hier wordt opgegeven, krijgt voorrang op de velden van de contactpersoon voor die variabele; variabelen die u weglaat, worden nog steeds ingevuld vanuit de contactpersoon zoals hieronder beschreven. Dit is hoe u een eenmalige code doorgeeft aan een authenticatiesjabloon. |

De hoofdtekst van de sjabloon ondersteunt geavanceerde variabele-substitutie:

- **Basisvariabelen:** `{{first_name}}`, `{{email}}`, `{{company}}`
- **Standaardwaarden:** `{{first_name|there}}` toont `there` als het veld leeg is
- **Transformaties:** `{{company|uppercase}}`, `{{name|lowercase}}`, `{{name|capitalize}}`
- **Gecombineerd:** `{{company|Your Company|uppercase}}`

> **Credits:** Het versturen van een sjabloon verbruikt credits. De exacte kosten hangen af van het land van de ontvanger en de categorie van de sjabloon.

**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()
```

**Antwoord**

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

Een verzoek waarbij zowel een contact-ID als beide sjabloon-ID's ontbreken, retourneert `400`. Als je account niet beschikt over de messaging-inloggegevens die nodig zijn om te verzenden, is het antwoord `403`.

---

## Een live sjabloon voor een campagne maken of bijwerken

Een tweede paar eindpunten voor het openingssjabloon van een campagne, gespecificeerd via het pad in plaats van via een `campaign_id` in de body. Deze zijn bedoeld voor een campagne die al live is: in tegenstelling tot [Een sjabloon maken](#create-a-template) hierboven, zorgt het bijwerken hier er ook voor dat de vervolgconcepten van de campagne opnieuw ter beoordeling worden ingediend, zodat het openingssjabloon en de vervolgberichten synchroon blijven.

`POST /whatsapp-templates/campaign/{campaignId}` maakt het openingssjabloon van de campagne aan. `PUT /whatsapp-templates/campaign/{campaignId}` bewerkt het — de campagne moet al een sjabloon hebben, anders wordt `400` geretourneerd.

| Veld | Vereist | Beschrijving |
|---|---|---|
| `name` | Ja | Een naam voor het sjabloon. |
| `language` | Ja | Taalcode, bijvoorbeeld `en`, `es`, `de`, `pt_BR`, `zh_CN`. |
| `body` | Ja | De berichttekst, maximaal 1024 tekens. |
| `variables` | Ja | Geordende lijst met variabelenamen die in de body worden gebruikt. Geef een lege array door als het sjabloon er geen gebruikt. |

**cURL** (maken)

```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()
```

**Antwoord**

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

Om te bewerken, wijzigt u de methode naar `PUT` en gebruikt u dezelfde velden — dit dient het openingssjabloon (en de vervolgconcepten van de campagne, bij een WhatsApp API-campagne) opnieuw in voor beoordeling.

Een campagne die niet bij uw account hoort, retourneert `404`; een campagne die bij een ander account hoort waarvoor u niet geautoriseerd bent, retourneert `403`. Het bewerken van een campagne zonder bestaand sjabloon retourneert `400`.

---

## Een sjabloon naar een bestaande contactpersoon sturen

Een eenvoudiger, pad-gebaseerd alternatief voor [Een sjabloon naar een contactpersoon sturen](#send-a-template-to-a-contact) hierboven: zowel het sjabloon als de contactpersoon moeten al bestaan — er wordt niets op naam opgezocht of ter plekke aangemaakt.

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

| Veld | Vereist | Beschrijving |
|---|---|---|
| `contactId` | Ja | Het ID van de contactpersoon. Moet bij uw account horen. |

**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()
```

**Antwoord**

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

> **Credits:** Het verzenden verbruikt credits, geprijsd op dezelfde manier als het bovenstaande eindpunt. Een `contactId` die ontbreekt of niet bij uw account hoort, retourneert `403`; een `templateId` die niet bestaat, retourneert `404`.

---

## Een sjabloon in bulk verzenden

Verzend één sjabloon naar vele contactpersonen in één aanroep, met een kostenoverzicht dat u kunt tonen voordat u bevestigt.

### Eerst de kosten schatten

Geeft de kosten van verzending terug, uitgesplitst per land van bestemming, zonder iets te verzenden of credits te verbruiken. De prijs voor sjablonen is per land van bestemming, dus dit moet aan de serverzijde worden berekend op basis van de werkelijke contacten in plaats van aan de clientzijde te worden geschat.

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

| Veld | Vereist | Beschrijving |
|---|---|---|
| `contactIds` | Ja | Contacten om te prijzen, maximaal 500 per aanroep. Duplicaten worden eenmaal geteld. |

**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()
```

**Antwoord**

```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` telt id's die ontbraken, niet van jou waren of geen telefoonnummer bevatten — de schatting dekt alleen de rest, dus een waarde die niet nul is, betekent dat de werkelijke verzending minder contacten zal bereiken dan je hebt geselecteerd.

### De batch verzenden

Verzendt het sjabloon naar elk contact in de lijst, waarbij eventuele slimme variabelen per contact worden opgelost en credits per verzending in rekening worden gebracht.

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

| Veld | Vereist | Beschrijving |
|---|---|---|
| `contactIds` | Ja | Contacten om naar te verzenden, maximaal 5000 per aanroep. |

**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()
```

**Antwoord**

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

Een contact dat faalt (niet gevonden, niet op je account of een verzendfout) wordt overgeslagen en geteld in `failed` in plaats van de batch te stoppen. Een lege `contactIds`, meer dan 5000 id's bij een verzending (500 bij een schatting) of een ontbrekende `templateId` retourneert `400`.

---

## Een mislukt bericht opnieuw proberen

Twee eindpunten voor het opnieuw verzenden van een mislukt bericht, zonder een nieuw berichtrecord aan te maken of opnieuw credits te verbruiken.

`POST /whatsapp-templates/messages/{contactId}/{messageId}/retry-template` probeert specifiek een mislukt sjabloonbericht opnieuw — het lost de sjablooninhoud opnieuw op vanuit de campagne als het mislukte bericht deze nog niet bevat. Alleen berichten met status `failed` en type `template` kunnen op deze manier opnieuw worden geprobeerd.

`POST /whatsapp-templates/messages/{contactId}/{messageId}/retry` is kanaalonafhankelijk en werkt voor elk mislukt niet-sjabloonbericht (bijvoorbeeld WhatsApp Web), waarbij het wordt verzonden naar het juiste verzendpad op basis van het kanaal van het bericht. Het accepteert status `failed`, `failed_connection`, `limit_exceeded` of `queued_retry`.

Geen van beide eindpunten vereist een aanvraagbody.

**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()
```

**Antwoord**

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

Voor de kanaalonafhankelijke versie, wissel het pad naar `.../msg_abc789/retry`. Een bericht waarvan de status niet in aanmerking komt voor een nieuwe poging, of (op het sjablooneindpunt) dat geen sjabloonbericht is, retourneert `400`. Een ontbrekend contact of bericht retourneert `404`.

---

## WhatsApp Business-profiel

Beheer het WhatsApp Business-profiel (over, adres, beschrijving, e-mail, websites, bedrijfscategorie en logo) dat aan contacten op WhatsApp wordt getoond. Werkt zowel op een beheerde verbinding als op een account dat een eigen WhatsApp Business-account gebruikt.

### Het profiel opslaan

`PUT /whatsapp-templates/profile`

| Veld | Vereist | Beschrijving |
|---|---|---|
| `phoneNumber` | Ja | Het WhatsApp-nummer waar dit profiel bij hoort. Moet verbonden zijn met uw account. |
| `about` | Nee | Korte "Over"-tekst die op het profiel wordt getoond. |
| `address` | Nee | Bedrijfsadres. |
| `description` | Nee | Langere bedrijfsbeschrijving. |
| `email` | Nee | Contact-e-mailadres dat op het profiel wordt getoond. |
| `websites` | Nee | Array van website-URL's. Elke URL moet geldig zijn. |
| `vertical` | Nee | Bedrijfscategorie, bijvoorbeeld `Retail` of `Professional Services`. |
| `profilePictureHandle` | Nee | De handle die wordt geretourneerd door het onderstaande endpoint voor het uploaden van afbeeldingen, om de profielfoto in te stellen. |

**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()
```

**Antwoord**

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

Een ontbrekende `phoneNumber`, een ongeldige website-URL of een `phoneNumber` die niet is verbonden met uw account resulteert in `400` of `404`.

### Een profielfoto uploaden

Downloadt een afbeelding van een URL die u opgeeft en uploadt deze naar WhatsApp, waarbij een handle wordt geretourneerd. Geef die handle door als `profilePictureHandle` bij de bovenstaande aanroep voor het opslaan van het profiel om deze als foto in te stellen — dit endpoint uploadt de afbeelding alleen, het stelt deze niet zelf in.

`POST /whatsapp-templates/profile/picture`

| Veld | Vereist | Beschrijving |
|---|---|---|
| `phoneNumber` | Ja | Het WhatsApp-nummer waar dit profiel bij hoort. |
| `fileUrl` | Ja | Een publiek toegankelijke URL naar de afbeelding die geüpload moet worden. |

**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()
```

**Antwoord**

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

`data` is de handle van de geüploade afbeelding. Een ontbrekende `phoneNumber` of `fileUrl`, of een `phoneNumber` zonder WhatsApp-toegangstoken in het bestand, resulteert in `400`; een onbereikbare of ongeldige `fileUrl` resulteert in een foutmelding die beschrijft waarom het downloaden is mislukt.

---

## De status van een afzender controleren

Pollt (en ververst) de live verzendstatus van een verbonden WhatsApp-nummer bij de messaging-provider. Handig om te bevestigen dat een nummer daadwerkelijk kan verzenden voordat u erop vertrouwt.

`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()
```

**Antwoord**

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

`data` is een van `ONLINE` (verzendt normaal), `PENDING` (wordt nog geverifieerd) of `DELETED` (de provider herkent deze afzender niet langer — verbind het nummer opnieuw). Een `phoneNumber` zonder WhatsApp-bedrijfsinformatie in het bestand resulteert in `404`.

---

## Genereer follow-up-sjablonen met AI

Het platform kan de WhatsApp follow-up-sjablonen van een campagne voor je schrijven — de herinneringen die worden verstuurd wanneer een gesprek stilvalt — op basis van de instructies en het doel van de campagne zelf. Er is één taak-endpoint dat op de achtergrond draait, plus drie oudere endpoints die behouden zijn voor bestaande integraties. Ze verbruiken allemaal AI-credits.

### Start een generatietaak

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

| Veld | Vereist | Beschrijving |
|---|---|---|
| `type` | Nee | `all` (de standaard) schrijft de volledige set follow-ups. `cold_only` schrijft alleen de berichten voor contacten die nooit hebben gereageerd. |

**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()
```

**Antwoord** (`202`)

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

De aanroep keert terug zodra de taak in de wachtrij staat. Lees de campagne (`GET /campaigns/{campaignId}`, zie de [Campaigns API](campaigns.md)) en houd het `template_generation_status`-object in de gaten totdat deze is voltooid:

| Veld | Beschrijving |
|---|---|
| `status` | `processing` terwijl de taak draait, daarna `completed` of `failed`. |
| `progress` | 0 tot 100. |
| `current_template`, `total_templates` | Hoeveel sjablonen er tot nu toe zijn geschreven, van het totaal aantal dat de taak zal schrijven — 11 voor een uitgaande of gecombineerde campagne, anders 9. |
| `error` | Waarom een `failed`-taak is gestopt, bijvoorbeeld door onvoldoende credits. |
| `started_at`, `completed_at` | Wanneer de taak begon en eindigde. |

De gegenereerde sjablonen komen net als alle andere op de campagne terecht, dus ze verschijnen in [Sjablonen weergeven](#list-templates) en moeten nog steeds door WhatsApp-goedkeuring voordat ze kunnen worden verzonden. Een `400` betekent dat `type` iets anders was dan `all` of `cold_only`; een `404` betekent dat de campagne niet bestaat of bij een ander account hoort.

Agents hebben een tegenhanger van deze aanroep, `POST /agents/{agentId}/template-generation`, die de follow-ups voor een Agent schrijft en in het normale geval tijdens de aanroep wordt voltooid — zie [Follow-up-berichten genereren](agents.md#generate-follow-up-messages) in de AI Agents API.

### De oudere generatie-endpoints

Drie eerdere endpoints doen hetzelfde werk en worden behouden zodat bestaande integraties blijven werken. Nieuwe code moet het bovenstaande taak-endpoint gebruiken.

| Endpoint | Wat het doet |
|---|---|
| `POST /whatsapp-templates/campaign/{campaignId}/generate-async` | Start de follow-up-generatie voor de campagne op de achtergrond en retourneert `202` met `{ "success": true, "data": { "result": "success", "message": "..." } }`. Credits worden vooraf in rekening gebracht (overgeslagen bij een account dat een eigen AI-sleutel meebrengt) en het `template_generation_status` van de campagne rapporteert de voortgang precies zoals hierboven. |
| `POST /whatsapp-templates/campaign/{campaignId}/generate-followups` | Genereert alle negen follow-up-sjablonen tijdens de aanroep — voor een campagne die is aangemaakt voordat automatische follow-ups bestonden, of een campagne die opnieuw moet worden geschreven — en retourneert `200` met `templatesGenerated` in `data`. |
| `POST /whatsapp-templates/agent/{agentId}/generate-followups` | Dezelfde synchrone generatie als geadresseerd door Agent. Het antwoord voegt `agent_id`, `campaign_id` en `target` toe: `"campaign"` wanneer de sjablonen op de campagne van de Agent zijn geschreven, `"agent"` (met `campaign_id: null`) wanneer de Agent geen campagne heeft en ze op de Agent zelf zijn opgeslagen. Een ontbrekende of vreemde Agent is een `404`. |

Alle drie vereisen automatische follow-ups op het account en voldoende credits — een `400` benoemt welke ontbreekt — en het paar dat op de campagne is gericht, retourneert `403` wanneer de campagne bij een ander account hoort.

---

## Fouten in de Templates API

Template-endpoints retourneren de standaard fouten-envelop:

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

Een `404` op deze eindpunten betekent meestal dat de resource niet is gevonden — ofwel deze bestaat niet, ofwel deze behoort tot een ander account. Een paar eindpunten (het aanmaken/bijwerken met campagne-scope, en verzendingen naar een bestaand contact) retourneren in plaats daarvan `403` wanneer de campagne of het contact toebehoort aan iemand anders in plaats van helemaal niet te bestaan. Sommige eindpunten bevatten ook een `error_code`-veld dat de HTTP-status weerspiegelt. De gedeelde codes die elk eindpunt kan retourneren — `400`, `401`, `403` (uw abonnement bevat geen API-toegang), `429` (snelheidslimiet) en `500` — worden vermeld met richtlijnen voor opnieuw proberen in [Fouten & Paginering](errors-and-pagination.md).

---

## Volgende stappen

- [Authenticatie](authentication.md) — de vier manieren om een verzoek te authenticeren.
- [Fouten & Snelheidslimieten](errors-and-pagination.md) — statuscodes en de limiet van 300 verzoeken per minuut.
- [Campagnes API](campaigns.md) — beheer de campagnes waaraan sjablonen zijn gekoppeld.