# Migrer depuis SMTP2GO

> Passez de SMTP2GO à Emailit. Remplacez les utilisateurs et les hôtes SMTP, convertissez les appels à l’API email/send et les modèles, et transférez webhooks, adresses bloquées et domaines d’expéditeur.

Ce guide fait correspondre les concepts, les paramètres SMTP, les appels API, les webhooks, les adresses bloquées et les modèles de SMTP2GO à leurs équivalents dans Emailit. 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

| SMTP2GO | Emailit |
| --- | --- |
| Compte principal et sous-comptes | Compte et [espaces de travail](/fr/docs/workspaces/). Chaque espace de travail a ses propres domaines, clés, membres et crédits. |
| Utilisateurs SMTP | Votre clé API, utilisée comme mot de passe SMTP. Créez une clé par application ou par serveur. |
| Clés API avec droits par endpoint | [Clés API](/fr/docs/developers/api-keys/) : **Full Access**, ou **Sending Only**, éventuellement restreinte à un domaine |
| Authentification par IP et par adresse | Non disponible. Chaque connexion SMTP s’authentifie avec une clé API. |
| Domaines d’expéditeur (sender domains) | [Domaines d’envoi](/fr/docs/domains/) |
| Adresses d’expéditeur individuelles (single sender emails) | Non disponible. Chaque adresse d’expéditeur doit se trouver sur un domaine vérifié. |
| Statut sandbox d’un utilisateur SMTP ou d’une clé API | 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. |
| Réglages de suivi et de pied de page de désinscription par utilisateur SMTP ou par clé API | [Suivi](/fr/docs/tracking/) par domaine d’envoi. Emailit n’ajoute pas de pied de page de désinscription aux e-mails envoyés par l’API ou par SMTP. |
| Modèles | [Modèles](/fr/docs/templates/) avec un alias et des versions, dont le rendu est effectué avec [Temple](/fr/docs/templates/temple/) |
| Webhooks | [Webhooks](/fr/docs/webhooks/) |
| Blocage d’adresses et de domaines | [Blocage](/fr/docs/suppressions/) d’adresses |
| Rapports et activité | **Email API → Emails** et **Email API → Logs** |
| IP dédiées et pools d’IP | [IP dédiées](/fr/docs/deliverability/dedicated-ips/) sur demande |

Si vous comptez sur le pied de page de désinscription de SMTP2GO pour vos newsletters, ajoutez votre propre lien de désinscription et vos propres en-têtes `List-Unsubscribe`, ou envoyez-les sous forme de [campagnes](/fr/docs/campaigns/) Emailit, qui ajoutent les en-têtes pour vous. Dans les campagnes, ajoutez le lien visible avec `{{unsubscribe_url}}`. Consultez [En-têtes SMTP](/fr/docs/smtp/headers/#add-list-unsubscribe-yourself).

## Changer les paramètres SMTP

| Paramètre | SMTP2GO | Emailit |
| --- | --- | --- |
| Hôte | `mail.smtp2go.com`, ou un hôte régional comme `mail-eu.smtp2go.com` | `smtp.emailit.com` |
| Port | `2525`, `587`, `25`, `8025` ou `80` (STARTTLS), `465`, `8465` ou `443` (TLS) | `587`, `2587`, `2525` ou `25` (STARTTLS), `465` (TLS) |
| Nom d’utilisateur | Le nom d’utilisateur de l’utilisateur SMTP | `emailit` |
| Mot de passe | Le mot de passe de l’utilisateur SMTP | Votre clé API Emailit |

Emailit n’écoute pas sur les ports `80`, `443`, `8025` ni `8465`. Si votre réseau bloque `25` et `587`, utilisez `2525` ou `2587`. Dans Emailit, chaque destinataire devient un e-mail distinct, et la réponse `250` liste leurs ID, ou seulement le premier ID quand il y a beaucoup de destinataires. Consultez [Paramètres SMTP](/fr/docs/smtp/settings/) et [En-têtes et réponses SMTP](/fr/docs/smtp/headers/).

## Mettre à jour vos appels API

Le `POST /v3/email/send` de SMTP2GO devient `POST /v2/emails`. Les adresses restent des chaînes, mais les noms de champs changent :

```bash title="Before: SMTP2GO"
curl https://api.smtp2go.com/v3/email/send \
  -H "X-Smtp2go-Api-Key: $SMTP2GO_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "sender": "Acme <hello@acme.com>",
    "to": ["ada@example.com"],
    "subject": "Your receipt",
    "text_body": "Thanks for your order.",
    "html_body": "<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>"
  }'
```

| SMTP2GO | Emailit |
| --- | --- |
| En-tête `X-Smtp2go-Api-Key`, `api_key` dans le corps, ou `Authorization: Bearer api-…` | `Authorization: Bearer secret_…` |
| `sender` | `from` |
| `to`, `cc`, `bcc` | `to`, `cc`, `bcc`, 50 adresses au maximum pour chacun |
| `custom_headers` avec `Reply-To` | `reply_to` |
| `custom_headers: [{ "header": "…", "value": "…" }]` | `headers: { "Name": "Value" }` |
| `subject` | `subject` |
| `text_body`, `html_body` | `text`, `html` |
| `attachments[]` avec `filename`, `fileblob` ou `url`, et `mimetype` | `attachments[]` avec `filename`, `content` ou `url`, et `content_type` |
| `inlines[]` | `attachments[]` avec un `content_id`, référencé par `cid:` dans le HTML |
| `template_id` et `template_data` | `template` (un alias ou un ID) et `variables` |
| `schedule` (3 jours à l’avance au maximum) | `scheduled_at` (ISO 8601 ou anglais courant) |
| `fastaccept` | Inutile. Emailit met chaque e-mail en file d’attente pour la livraison et répond sans attendre celle-ci. |
| `POST /v3/email/batch` (1 000 e-mails au maximum) | Non disponible. Envoyez une requête par message. |
| `POST /v3/email/mime` | Envoyez le message MIME via le [relais SMTP](/fr/docs/smtp/) |
| `200` avec `email_id`, `succeeded`, `failed` et `failures` | `200` avec `id` (`em_…`), `status: "accepted"` et, pour plusieurs destinataires, `ids` avec un ID par destinataire. Les erreurs utilisent les codes de statut HTTP. |

SMTP2GO n’a ni métadonnées ni réglages de suivi par e-mail. Dans Emailit, ajoutez `meta` pour récupérer vos propres valeurs dans les événements webhook, et `tracking: { "loads": true, "clicks": true }` pour remplacer le réglage de suivi du domaine. Ajoutez un en-tête `Idempotency-Key` pour sécuriser les relances. Consultez [Envoyer un e-mail](/fr/docs/email-api/send-email/).

## Faire correspondre les événements webhook

| Événement SMTP2GO | Événement Emailit |
| --- | --- |
| `processed` | `email.accepted` (API uniquement) |
| `delivered` | `email.delivered` |
| `bounce` avec `bounce` `soft` | `email.attempted` pendant qu’Emailit réessaie, puis `email.bounced` si toutes les nouvelles tentatives échouent |
| `bounce` avec `bounce` `hard` | `email.bounced` |
| `reject` | `email.suppressed` quand l’adresse a un blocage de type `recipient`. Les autres rejets, comme un expéditeur non vérifié, sont des erreurs dans la réponse de l’API ou dans la réponse SMTP. |
| `spam` | `email.complained` |
| `open` | `email.loaded` |
| `click` | `email.clicked` |
| `unsubscribe` | `email.unsubscribed`, pour les e-mails de campagne uniquement |

Le format des requêtes change :

- SMTP2GO envoie un événement par requête, sous forme de champs de formulaire par défaut ou de JSON plat. Emailit envoie un tableau JSON de 100 événements au maximum : parcourez donc le corps avec une boucle.
- Le nom de l’événement passe de `event` à `type`, et l’e-mail se trouve dans `data.object`. Utilisez `data.object.id`, l’ID `em_` de la réponse d’envoi ou de la réponse SMTP, au lieu de `email_id`, et `data.object.to` au lieu de `rcpt`. Les valeurs que vous avez transmises dans `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`.
- SMTP2GO ne signe pas les webhooks. Emailit signe chaque requête : vérifiez `X-Emailit-Signature` à l’aide de `X-Emailit-Timestamp` et de 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 vos adresses bloquées depuis **Reports > Suppressions** avec **Export**, ou parcourez les pages de `POST /v3/suppression/view`. L’API ne renvoie qu’environ les 30 derniers jours, sauf si vous définissez `start_date` : définissez-le donc pour couvrir tout votre historique.

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

   | Motif SMTP2GO | Type Emailit |
   | --- | --- |
   | `bounce`, `spam`, `manual` | `recipient`, qui bloque les envois par l’API, par SMTP et par les campagnes |
   | `unsubscribe` | `unsubscribe`, qui arrête les campagnes mais laisse passer les e-mails transactionnels. Utilisez `recipient` si la personne s’est désinscrite de tout ce que vous envoyez. |

```csv
email,type,reason
old-address@example.com,recipient,smtp2go bounce
left@example.com,unsubscribe,smtp2go unsubscribe
```

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 blocages de domaines ne peuvent donc pas être importés. Répétez l’export pour chaque sous-compte et importez-le dans l’espace de travail correspondant. Consultez [Gérer les adresses bloquées](/fr/docs/suppressions/manage/).

## Transférer les modèles

Récupérez le HTML de chaque modèle avec `POST /v3/template/view`, qui renvoie `html_body`, `text_body` et `subject`, ou copiez-le depuis **Settings > Templates**. 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’ID du modèle SMTP2GO comme alias s’il respecte le format des alias : lettres minuscules, chiffres, `-` et `_`.

SMTP2GO ignore `subject` quand vous envoyez un modèle. Emailit utilise l’objet du modèle, sauf si la requête en contient un : omettez donc `subject` pour conserver celui du modèle.

Les modèles SMTP2GO utilisent Handlebars. Temple couvre les usages courants :

| SMTP2GO (Handlebars) | Emailit (Temple) |
| --- | --- |
| `{{ username }}`, `{{ user.name }}` | `{{username}}`, `{{user.name}}` |
| `{{{ html_block }}}` | `{{html_block}}`. Temple n’échappe jamais le HTML : échappez vous-même les saisies des utilisateurs. |
| `{{#if plan}}…{{else}}…{{/if}}` | Identique |
| `{{#each items}}…{{/each}}` | 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 | `{{username\|"there"}}` ajoute une valeur de repli |
| `template_data` | `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 le CNAME DKIM `s<number>._domainkey` de SMTP2GO, ni avec son CNAME de return-path `em<number>` ou son CNAME de suivi `link`. Conservez votre enregistrement DMARC. Consultez [Enregistrements DNS](/fr/docs/domains/dns-records/).

Après la bascule, supprimez les CNAME de SMTP2GO, ainsi que `include:spf.smtp2go.com` si votre enregistrement SPF le contient encore.

## Étapes suivantes

- [Liste de contrôle avant la mise en production](/fr/docs/get-started/go-live/)
- [Dépannage SMTP](/fr/docs/smtp/troubleshooting/)
- [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/smtp2go/
