# Migrer depuis ZeptoMail

> Passez de ZeptoMail (désormais Zoho CPaaS) à Emailit. Faites correspondre les Agents et les send mail tokens, convertissez les appels API et les modèles Mustache, remplacez les paramètres SMTP, et transférez les webhooks et les adresses bloquées.

Ce guide fait correspondre les concepts, les appels API, les webhooks, les adresses bloquées et les modèles de ZeptoMail à leurs équivalents dans Emailit. En septembre 2026, ZeptoMail a été renommé Zoho CPaaS. Les jetons, les hôtes et les paramètres SMTP existants continuent de fonctionner : ce guide utilise donc les noms ZeptoMail que vous trouverez dans votre code. Lisez d’abord [Migrer vers Emailit](/fr/docs/migrate/) pour l’ordre général et la façon de faire fonctionner les deux fournisseurs en parallèle.

## Concepts

| ZeptoMail (Zoho CPaaS) | Emailit |
| --- | --- |
| Compte | Compte |
| Agents (anciennement Mail Agents) | [Espaces de travail](/fr/docs/workspaces/), ou un seul espace de travail avec plusieurs domaines d’envoi |
| Send mail token d’un Agent | [Clé API](/fr/docs/developers/api-keys/) **Sending Only**, éventuellement restreinte à un domaine |
| Jetons OAuth Zoho pour les API de gestion | Clé API **Full Access**. Le même type de clé envoie les e-mails et gère votre espace de travail. |
| Domaines associés aux Agents | [Domaines d’envoi](/fr/docs/domains/) |
| Agents sandbox | Les nouveaux espaces de travail sont en [mode bac à sable](/fr/docs/workspaces/production-access/) et ne livrent qu’aux membres de l’espace de travail. Il n’existe pas de mode qui accepte les e-mails sans les livrer. |
| Modèles par Agent, avec une clé et un alias | [Modèles](/fr/docs/templates/) par espace de travail, avec un alias et des versions |
| Webhooks par Agent | [Webhooks](/fr/docs/webhooks/) par espace de travail |
| Suppression list, avec des entrées d’adresses e-mail et de domaines | [Liste d’adresses bloquées](/fr/docs/suppressions/) composée d’adresses e-mail |
| E-mails traités et logs d’e-mails | **Email API → Emails** et **Email API → Logs** |
| `client_reference` | `meta` |
| Cache de fichiers (File cache) | Pièces jointes par `url` |

ZeptoMail n’envoie que des e-mails transactionnels. Dans Emailit, le même espace de travail dispose aussi de [campagnes](/fr/docs/campaigns/), de [listes de contacts](/fr/docs/audiences/) et d’[automatisations](/fr/docs/automations/), si vous voulez aussi transférer vos newsletters.

## Mettre à jour vos appels API

Le `POST /v1.1/email` de ZeptoMail devient `POST /v2/emails`. Le schéma d’autorisation change, et les adresses deviennent de simples chaînes :

```bash title="Before: ZeptoMail"
curl https://api.zeptomail.com/v1.1/email \
  -H "Authorization: Zoho-enczapikey $ZEPTOMAIL_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "from": { "address": "hello@acme.com", "name": "Acme" },
    "to": [{ "email_address": { "address": "ada@example.com" } }],
    "subject": "Your receipt",
    "textbody": "Thanks for your order.",
    "htmlbody": "<p>Thanks for your order.</p>"
  }'
```

```bash title="After: Emailit"
curl https://api.emailit.com/v2/emails \
  -H "Authorization: Bearer $EMAILIT_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "from": "Acme <hello@acme.com>",
    "to": "ada@example.com",
    "subject": "Your receipt",
    "text": "Thanks for your order.",
    "html": "<p>Thanks for your order.</p>"
  }'
```

| ZeptoMail | Emailit |
| --- | --- |
| `Authorization: Zoho-enczapikey <token>` | `Authorization: Bearer secret_…` |
| Hôtes régionaux comme `api.zeptomail.eu` ou `cpaas.zoho.eu` | Un seul hôte, `api.emailit.com` |
| `from: { address, name }` | `from: "Name "` |
| `to[]`, `cc[]`, `bcc[]` avec `email_address: { address, name }` | `to`, `cc`, `bcc` sous forme de chaîne ou de tableau, 50 adresses au maximum pour chacun |
| `reply_to: [{ address, name }]` | `reply_to` |
| `subject` | `subject` |
| `htmlbody`, `textbody` | `html`, `text` |
| `mime_headers` | `headers` |
| `attachments[]` avec `content`, `mime_type`, `name` | `attachments[]` avec `content`, `content_type`, `filename` |
| `attachments[]` avec `file_cache_key` | `attachments[]` avec une `url` qu’Emailit télécharge, ou le `content` en base64 |
| `inline_images[]` avec `cid` | `attachments[]` avec un `content_id`, référencé sous la forme `cid:` dans le HTML |
| `client_reference` | `meta`, par exemple `meta: { "reference": "order-12345" }`, renvoyé dans les événements webhook |
| `track_opens`, `track_clicks` | `tracking: { "loads": true, "clicks": true }` |
| `POST /v1.1/email/template` avec `template_key` ou `template_alias` et `merge_info` | Le même `POST /v2/emails` avec `template` (un alias ou un ID) et `variables` |
| `POST /v1.1/email/batch` et `/email/template/batch` | Non disponible. Envoyez une requête par destinataire avec ses propres `variables`. |
| Réponse avec `request_id`, et un `email_reference` par e-mail dans les webhooks et les logs | `200` avec `id` (`em_…`), `status: "accepted"` et, pour plusieurs destinataires, `ids` avec un ID par destinataire |

Emailit prend aussi en charge la programmation avec `scheduled_at` et les relances sûres avec un en-tête `Idempotency-Key`, ce que ZeptoMail ne propose pas à l’envoi. Consultez [Envoyer un e-mail](/fr/docs/email-api/send-email/).

## Changer les paramètres SMTP

| Paramètre | ZeptoMail | Emailit |
| --- | --- | --- |
| Hôte | `smtp.zeptomail.com`, ou un hôte régional | `smtp.emailit.com` |
| Port | `587` (STARTTLS), `465` (TLS) | `587`, `2587`, `2525` ou `25` (STARTTLS), `465` (TLS) |
| Nom d’utilisateur | `emailapikey` | `emailit` |
| Mot de passe | Le send mail token de l’Agent, sans `Zoho-enczapikey` | Votre clé API Emailit |

Emailit ne lit pas les en-têtes `X-TM-*` comme `X-TM-CLIENT-REF`, `X-TM-OPEN-TRACK`, `X-TM-CLICK-TRACK` ou `X-TM-FILE-KEY`. Supprimez-les. Réglez le suivi au niveau du domaine, et utilisez l’API quand vous avez besoin de métadonnées. Consultez [Paramètres SMTP](/fr/docs/smtp/settings/).

## Faire correspondre les événements webhook

| Événement ZeptoMail | Événement Emailit |
| --- | --- |
| Delivered | `email.delivered` |
| Soft bounce (`softbounce`) | `email.attempted` pendant qu’Emailit réessaie, puis `email.bounced` si toutes les nouvelles tentatives échouent |
| Hard bounce (`hardbounce`) | `email.bounced` |
| Open (`email_open`), première ouverture uniquement | `email.loaded`, envoyé à chaque chargement |
| Click (`email_link_click`) | `email.clicked`, envoyé à chaque clic |
| Feedback loop (`fbl_complaint`) | `email.complained` |

Emailit envoie aussi des événements pour lesquels ZeptoMail n’a pas de webhook, comme `email.accepted` quand l’API accepte un e-mail et `email.suppressed` quand un blocage `recipient` arrête l’envoi vers une adresse. Consultez [Types d’événements](/fr/docs/webhooks/event-types/).

Le format des requêtes change :

- ZeptoMail envoie (POST) `event_name` et une liste `event_message`, avec l’e-mail dans `email_info` et les détails dans `event_data`. Emailit envoie un tableau JSON de 100 événements au maximum, chacun avec le nom dans `type` et l’e-mail dans `data.object`.
- Utilisez `data.object.id`, l’ID `em_` de la réponse d’envoi, au lieu de `email_reference` ou `request_id`. Chaque e-mail Emailit a un seul destinataire, `data.object.to` : vous n’avez donc pas besoin de `bounced_recipient`. Vos valeurs `meta` se trouvent dans `data.object.meta`.
- Pour `email.loaded` et `email.clicked`, `data.object` est le chargement ou le clic. Utilisez `data.object.email_id` pour l’ID de l’e-mail, et `data.object.email.rcpt_to` et `data.object.email.meta` pour le destinataire et vos valeurs `meta`.
- ZeptoMail signe avec HMAC-SHA256 dans un en-tête `producer-signature` qui contient `ts` et un `s` en base64. Emailit envoie `X-Emailit-Timestamp`, en secondes, et `X-Emailit-Signature`, le HMAC-SHA256 en hexadécimal de `<timestamp>.<raw body>`, calculé avec votre secret `whsec_`. Consultez [Signature des requêtes](/fr/docs/webhooks/request-signature/).

```javascript
for (const event of req.body) {
  const email = event.data.object;
  if (event.type === 'email.bounced') markBounced(email.to, email.id);
  if (event.type === 'email.complained') unsubscribe(email.to);
}
```

## Transférer les adresses bloquées

1. Exportez votre liste d’adresses bloquées. L’export depuis le tableau de bord couvre les 60 derniers jours, avec 5 000 entrées au maximum par fichier : utilisez donc l’API des adresses bloquées (`GET /v1.1/suppressions/email`) pour les entrées plus anciennes.

2. Constituez un seul CSV avec les colonnes `email,type,reason` :

```csv
email,type,reason
old-address@example.com,recipient,zeptomail hard bounce
blocked@example.com,recipient,zeptomail suppression
```

   Utilisez le type `recipient` pour les adresses avec l’action `suppress` ou `reject`. Il bloque les envois par l’API, par SMTP et par les campagnes. Les entrées avec `suppress_tracking` n’ont pas d’équivalent : laissez-les donc de côté.

3. Dans **Email API → Suppressions**, sélectionnez **Import** et chargez le fichier. Chaque fichier peut contenir 10 000 lignes et peser 8 Mo au maximum. Les doublons sont ignorés.

Emailit bloque des adresses exactes : les entrées de domaine comme `example.com` ne peuvent donc pas être importées. Consultez [Gérer les adresses bloquées](/fr/docs/suppressions/manage/).

## Transférer les modèles

Copiez le HTML de chaque modèle depuis l’éditeur de ZeptoMail, ou récupérez-le avec l’API des modèles de ZeptoMail, qui le renvoie dans `htmlbody`. Importez-le dans **Email Marketing → Templates** ou créez-le avec l’[API des modèles](/fr/docs/api-reference/templates/create/), et utilisez l’alias du modèle ZeptoMail comme alias Emailit s’il respecte le format des alias : lettres minuscules, chiffres, `-` et `_`.

Les modèles ZeptoMail utilisent Mustache. Temple couvre les usages courants :

| ZeptoMail (Mustache) | Emailit (Temple) |
| --- | --- |
| `{{name}}`, `{{order.total}}` | Identique |
| `{{{html_block}}}` | `{{html_block}}`. Temple n’échappe jamais le HTML : échappez vous-même les saisies des utilisateurs. |
| `{{#plan}}…{{/plan}}` | `{{#if plan}}…{{/if}}` |
| `{{^plan}}…{{/plan}}` | `{{#if plan}}{{else}}…{{/if}}` |
| `{{#items}}…{{/items}}` sur une liste | Non pris en charge. Générez la liste dans votre code et transmettez-la comme une seule variable. |
| Pas de valeur par défaut intégrée | `{{name\|"there"}}` ajoute une valeur de repli |
| `merge_info` | `variables` |

Consultez [Temple](/fr/docs/templates/temple/) et [Importer et exporter des modèles](/fr/docs/templates/import-export/).

## Modifier le DNS

Ajoutez votre domaine dans **Email API → Domains** et publiez les enregistrements Emailit. Ils utilisent leurs propres noms (`emailit._domainkey`, `emailit.<domain>`, et éventuellement `go` et `inbound`) : ils n’entrent donc pas en conflit avec l’enregistrement DKIM de ZeptoMail, son CNAME de rebond ni son CNAME de suivi. Conservez votre enregistrement DMARC. Consultez [Enregistrements DNS](/fr/docs/domains/dns-records/).

Après la bascule, supprimez les enregistrements DKIM, de rebond et de suivi de ZeptoMail, ainsi que `include:zeptomail.net` si vous l’avez ajouté à votre enregistrement SPF.

## Étapes suivantes

- [Liste de contrôle avant la mise en production](/fr/docs/get-started/go-live/)
- [Configurer des webhooks](/fr/docs/webhooks/set-up/)
- [Migration prioritaire](/fr/docs/programs/priority-migration/) : laissez les ingénieurs d’Emailit effectuer la migration avec vous

---
Source: https://emailit.com/fr/docs/migrate/zeptomail/
