---
title: Migrer depuis Resend
description: "Une commande déplace les données de votre compte Resend ; le SDK BillionSend et une clé API déplacent votre code."
ai:
  exclude: true
---

L'API de BillionSend a les mêmes endpoints et les mêmes formats de requête que celle de Resend : migrer revient à changer de paquet, pas à tout réécrire. Vos contacts, segments, thématiques, templates, webhooks, domaines et suppressions se déplacent avec une seule commande.

## Confiez-la à un agent

Toute la migration est écrite sous la forme d'un prompt unique qu'un agent de code peut suivre du début à la fin. Il garde Resend en lecture seule, garde les clés hors des fichiers et demande confirmation avant toute action irréversible.

**Copiez le prompt de migration et collez-le dans votre agent de code.**

> Migrez ce projet de Resend vers BillionSend. Lisez https://billionsend.com/docs/prompts/migrate-from-resend.fr.md et suivez-le pas à pas. Arrêtez-vous et demandez avant toute action irréversible, et n'affichez, n'enregistrez ni ne commitez jamais une clé API.

## 1. Déplacez votre compte

Créez une clé API `bs_` à accès complet sous **Clés API**, puis lancez sur votre machine :

```sh
npx @billionsend/cli migrate --from resend
```

L'outil demande votre clé Resend (accès complet) et votre clé BillionSend, lit votre compte Resend, affiche un plan, attend votre confirmation, l'applique et imprime un récapitulatif. Les options, les fichiers et l'usage en CI sont décrits sur la page [CLI](/docs/fr/cli).

- **Resend n'est que lu.** L'outil n'y crée, n'y modifie et n'y supprime jamais rien. Il respecte la limite de débit de Resend : 8 requêtes par seconde par défaut, modifiable avec `--rps`.
- **Vos clés restent sur votre machine.** Elles vivent en mémoire pendant l'exécution et ne sont jamais écrites dans un fichier. Il n'y a aucune télémétrie.
- **La bascule d'abord, les détails ensuite.** La première passe prend quelques minutes et se termine par **Cutover ready** : les enregistrements DNS à ajouter et la ligne d'URL de base. Vous pouvez alors basculer l'envoi transactionnel. Une seconde passe lit ensuite les abonnements aux thématiques et les propriétés de chaque contact. Suspendez les envois par thématique et les campagnes jusqu'à sa fin.
- **Sans risque à relancer.** Chaque exécution compare les deux côtés : les lignes différentes sont mises à jour, les lignes identiques sont laissées telles quelles, et les contacts sont appariés par e-mail. Relancez l'outil juste avant de basculer le trafic pour récupérer les contacts arrivés entre-temps. Appuyez sur Ctrl-C à tout moment et relancez pour reprendre.

| Ressource | Ce qui est déplacé |
| --- | --- |
| Contacts | E-mail, noms, `unsubscribed`, propriétés, abonnements aux thématiques, appartenances aux segments. Les désinscriptions sont conservées ; personne n'est réabonné. Le `unsubscribed` de Resend est global : il devient `unsubscribed: true` à l'échelle de l'équipe dans BillionSend. |
| Segments, thématiques, propriétés | Appariés par nom ou par clé : créés s'ils manquent, mis à jour s'ils diffèrent. |
| Templates | Nom, alias, objet, html, text. `from`, `reply_to` et `variables` ne peuvent pas être stockés et sont listés comme étapes manuelles. |
| Webhooks | Endpoint, événements et secret de signature, pour que votre récepteur continue de vérifier. Les événements que BillionSend n'envoie pas sont écartés webhook par webhook et listés dans le rapport. |
| Suppressions | Rebonds, plaintes et entrées manuelles, avec leur origine. |
| Domaines | Créés avec leurs paramètres de suivi. Les enregistrements DNS doivent être ajoutés de nouveau (étape 3). |
| Campagnes | Les brouillons et les campagnes planifiées arrivent comme brouillons. Les campagnes déjà envoyées sont ignorées, sauf avec `--include-sent`. |

Ce qui n'est pas déplacé : les **clés API** (Resend n'en montre que les noms, donc le rapport les liste comme tâche à faire), les **enregistrements DNS et DKIM** (les clés appartiennent à chaque fournisseur), les **boîtes de réception** avec leurs conversations et brouillons, et l'**historique des e-mails**.

### Grands comptes

La seconde passe fait deux requêtes par contact, sur une limite que votre envoi en production partage. La durée est d'environ `contacts × 2 ÷ rate` :

| Contacts | À 8 req/s | À 50 req/s |
| --- | --- | --- |
| 36 685 | environ 2 h 30 min | environ 25 min |
| 160 000 | environ 11 h | environ 1 h 50 min |

Pour raccourcir la durée, demandez à Resend de relever votre limite et passez le nouveau débit avec `--rps`, ou lancez l'outil en heures creuses. Une seconde clé API n'aide pas, car la limite s'applique par équipe.

## 2. Pointez votre code vers BillionSend

Remplacez le paquet Resend par celui de BillionSend et donnez-lui une clé `bs_`. Chaque SDK lit `BILLIONSEND_API_KEY`, ainsi que `BILLIONSEND_BASE_URL` lorsqu'elle est définie.

```sh
BILLIONSEND_API_KEY=bs_...
```

**Node.js.** Remplacez `resend` par `@billionsend/node` :

```sh
npm uninstall resend
npm install @billionsend/node
```

```ts
import { BillionSend } from "@billionsend/node";

const bs = new BillionSend(); // reads BILLIONSEND_API_KEY

const { data, error } = await bs.emails.send({
  from: "Acme <onboarding@acme.dev>",
  to: ["success@simulator.amazonses.com"],
  subject: "Welcome to Acme",
  html: "<p>Glad you are here.</p>",
  reply_to: "support@acme.dev",
});
```

Les appels se résolvent toujours en `{ data, error }`. Les noms de méthodes suivent la [référence de l'API](/docs/fr/api-reference) (`emails.send`, `emails.batch`, `broadcasts.send`), et les champs de requête gardent les noms de l'API : `reply_to`, `scheduled_at` et `segment_id`, là où le paquet Resend attend `replyTo`, `scheduledAt` et `segmentId`. Vérifiez les livraisons de webhook avec `verifyWebhook`, du même paquet ; les secrets de signature ont suivi vos webhooks, donc le secret `whsec_` que détient votre récepteur continue de fonctionner. Voir [SDK Node.js](/docs/fr/sdks/node).

**Python.** Remplacez `resend` par `billionsend` :

```sh
pip uninstall resend
pip install billionsend
```

```python
from billionsend import BillionSend

client = BillionSend()  # reads BILLIONSEND_API_KEY

email = client.emails.send(
    {
        "from": "Acme <onboarding@acme.dev>",
        "to": ["success@simulator.amazonses.com"],
        "subject": "Welcome to Acme",
        "html": "<p>Glad you are here.</p>",
    }
)
```

Les appels passent du module (`resend.Emails.send(...)`) à un objet client (`client.emails.send(...)`), et un appel en échec lève une sous-classe de `BillionSendError`. Voir [SDK Python](/docs/fr/sdks/python).

**Go.** Remplacez `github.com/resend/resend-go/v4` par `github.com/billionsend/billionsend-go` (`go get github.com/billionsend/billionsend-go`). `billionsend.NewClient()` lit `BILLIONSEND_API_KEY` ; chaque méthode prend d'abord un `context.Context`, et les champs facultatifs sont des pointeurs créés avec `billionsend.String` et ses équivalents. Voir [SDK Go](/docs/fr/sdks/go).

**Ruby.** Remplacez `resend` par `billionsend` (`gem install billionsend`, ou `gem "billionsend"` dans le Gemfile). Au lieu de définir `Resend.api_key` et d'appeler des méthodes de classe comme `Resend::Emails.send(params)`, créez un client : `BillionSend::Client.new` lit `BILLIONSEND_API_KEY`, et `client.emails.send({...})` prend le même hash ; une clé d'idempotence passe de `options: { idempotency_key: ... }` à l'argument nommé `idempotency_key:`. Les réponses sont des Hashes à clés chaîne (`email["id"]`), et un appel en échec lève une sous-classe de `BillionSend::Error` là où l'ancien gem levait `Resend::Error`. Le gem n'a pas de méthode de livraison pour Action Mailer : une application Rails avec `delivery_method = :resend` pointe Action Mailer vers le [relais SMTP](/docs/fr/smtp). Voir [SDK Ruby](/docs/fr/sdks/ruby).

**PHP.** Remplacez `resend/resend-php` par `billionsend/billionsend-php` (`composer require billionsend/billionsend-php`). `new BillionSend\Client()` lit `BILLIONSEND_API_KEY`, et les appels comme `$client->emails->send([...])` prennent les mêmes tableaux ; un appel en échec lève une sous-classe de `BillionSendError`. Voir [SDK PHP](/docs/fr/sdks/php).

**Rust.** Remplacez `resend-rs` par `billionsend` (`cargo add billionsend`). `BillionSend::from_env()` lit `BILLIONSEND_API_KEY`, et les ressources sont des méthodes plutôt que des champs : `resend.emails.send(email)` devient `bs.emails().send(&body).await?`. Les constructeurs d'options typés comme `CreateEmailBaseOptions::new(from, to, subject).with_html(html)` cèdent la place à n'importe quel corps `serde::Serialize` avec les noms de champs de l'API, le plus souvent une valeur `json!` ; les réponses sont des `serde_json::Value`, ou votre propre type via `.json::<T>()`, et un appel en échec est un `billionsend::Error` avec une variante par type d'erreur. Voir [SDK Rust](/docs/fr/sdks/rust).

**Java.** Remplacez `com.resend:resend-java` par `com.billionsend:billionsend-java` (`implementation("com.billionsend:billionsend-java:0.1.2")`, ou les mêmes coordonnées dans Maven). `new BillionSend()` lit `BILLIONSEND_API_KEY`, là où `new Resend(key)` recevait la clé. Les appels gardent leur forme, `client.emails().send(...)`, mais prennent une `Map` (ou toute valeur que Jackson sait écrire) avec les noms de champs de l'API, comme `reply_to`, à la place de `CreateEmailOptions.builder()...build()`, et répondent un `JsonNode` (`sent.get("id").asText()`) à la place de `CreateEmailResponse`. Un appel en échec lève une sous-classe non vérifiée de `BillionSendException` au lieu de l'exception vérifiée `ResendException`, donc les blocs `catch (ResendException e)` disparaissent. Voir [SDK Java](/docs/fr/sdks/java).

**.NET.** Remplacez le paquet `Resend` par `BillionSend` (`dotnet remove package Resend`, puis `dotnet add package BillionSend --version 0.1.0`). `new BillionSendClient()` lit `BILLIONSEND_API_KEY`, là où le client Resend recevait son jeton par `ResendClientOptions`, et un même client peut être partagé sans risque : enregistrez-le donc une seule fois comme singleton. Les appels suivent les identifiants d'opération de la [référence de l'API](/docs/fr/api-reference) avec le suffixe `Async`, `client.Emails.SendAsync(...)`, et prennent tout objet que `System.Text.Json` sait écrire, comme un objet anonyme avec les noms de champs de l'API (`from`, `to`, `reply_to`), à la place d'un `EmailMessage` ; les réponses sont des arbres `JsonNode` (`sent?["id"]`), et un appel en échec lève une sous-classe de `BillionSendException`, avec `ValidationException`, `NotFoundException` et `RateLimitException` pour les statuts courants. Voir [SDK .NET](/docs/fr/sdks/dotnet).

**Elixir.** Remplacez le paquet communautaire `resend` par `billionsend` (`{:billionsend, "~> 0.1"}` dans `mix.exs`). `BillionSend.client()` lit `BILLIONSEND_API_KEY`, et les fonctions prennent d'abord le client, puis le corps sous forme de map avec les noms de champs de l'API : `BillionSend.Emails.send(client, %{from: ..., to: [...], subject: ..., html: ...})` renvoie `{:ok, answer}` ou `{:error, error}`, où la réponse est une map à clés chaîne (`sent["id"]`) et l'erreur une struct d'exception comme `BillionSend.NotFoundError`. Une clé d'idempotence se passe dans les options, `idempotency_key: "welcome/ana"`, et chaque envoi en porte une de toute façon. Les livraisons de webhook se vérifient avec `BillionSend.verify_webhook/4`. Voir [SDK Elixir](/docs/fr/sdks/elixir).

**Autres langages.** Appelez directement l'API REST ; la page [SDKs](/docs/fr/sdks) donne la forme cURL.

Ce qui diffère de ce qu'une intégration Resend peut supposer :

- **Une seule adresse par champ d'adresse.** `from`, `to`, `cc` et `bcc` acceptent chacun une adresse, comme `ada@example.com` ou `Ada <ada@example.com>`. Un nom affiché contenant une virgule doit être entre guillemets (`"Ada, Inc." <ada@example.com>`). Sans guillemets, il est lu comme deux adresses et l'envoi échoue avec `422`.
- **Abonnements aux thématiques.** `PATCH /contacts/{id}/topics` prend un simple tableau JSON de `{ "id": "<topic-id>", "subscription": "opt_in" | "opt_out" }`.
- **Contacts en masse.** Il n'y a pas d'endpoint d'import CSV. Utilisez `POST /contacts/batch?on_conflict=upsert` avec du JSON, jusqu'à 1 000 contacts par appel. Ajoutez `x-batch-validation: permissive` pour conserver les lignes valides lorsque certaines échouent.
- **Adresses qui ne pourront jamais recevoir d'e-mail.** Un destinataire comme `x@example.com`, `x@foo.test` ou `x@gmail.con` est refusé avec `422 validation_error`, de même qu'un nouveau contact à cette adresse.
- **Les désinscriptions appartiennent au domaine d'envoi.** Un destinataire qui clique sur désinscription ne quitte que le domaine qui a envoyé l'e-mail. Le champ `unsubscribed` du contact reste votre interrupteur à l'échelle de l'équipe : le code qui vérifie qui est parti doit donc lire `unsubscribed` et `unsubscribed_domains`. Pour reprendre une liste de désinscriptions d'un autre fournisseur, importez-la sous **Contacts → Désinscriptions** ou envoyez-la à `POST /unsubscribes`. Voir [Désinscriptions](/docs/fr/concepts/unsubscribes).
- **Envois entièrement supprimés.** Un envoi dont toutes les adresses `to` sont supprimées répond `422 all_recipients_suppressed`, là où Resend répond `200`. Traitez-le comme « non envoyé », pas comme un échec à retenter. Voir [Suppressions](/docs/fr/concepts/suppressions).
- **Les pièces jointes** n'acceptent que `content` en base64 intégré ; une URL `path` distante répond `422`.
- **Pas d'audiences.** Les contacts appartiennent à l'équipe, et les endpoints d'audience fonctionnent comme des alias des [segments](/docs/fr/concepts/segments).
- **Les en-têtes sont soumis à une liste d'autorisation** : tout nom `X-*` (sauf `X-SES-*` et `X-BillionSend-*`), les en-têtes de fil de discussion et de priorité, et la paire `List-Unsubscribe`. Tout autre en-tête répond `422`.
- **Les suppressions en masse** acceptent jusqu'à 1 000 adresses par requête, là où Resend en accepte 100.
- **Les paramètres non pris en charge** répondent `422` au lieu d'être ignorés.

## 3. Terminez la liste de contrôle

Le récapitulatif se termine par une liste de contrôle. Trois éléments y figurent toujours :

- **Ajoutez les enregistrements DNS de chaque domaine.** BillionSend utilise ses propres clés DKIM : les enregistrements sont donc nouveaux, même pour un domaine qui envoie déjà via Resend. Le rapport les imprime par domaine, et ils figurent aussi sur la page du domaine sous **Domaines**. Les deux fournisseurs peuvent rester vérifiés côte à côte.
- **Pointez votre code vers BillionSend** dans chaque environnement qui envoie. Le récapitulatif imprime la ligne d'URL de base pour un paquet Resend que vous conservez ; avec le SDK BillionSend, définissez plutôt `BILLIONSEND_API_KEY` (étape 2).
- **Créez les clés API**, une pour chaque nom que le rapport liste, sous **Clés API**.

Deux autres apparaissent lorsqu'ils s'appliquent : les valeurs `from` et `reply_to` des templates à définir à chaque envoi, et les événements de webhook que BillionSend n'envoie pas. `{{{RESEND_UNSUBSCRIBE_URL}}}` dans une campagne continue de fonctionner comme alias de `{{{UNSUBSCRIBE_URL}}}`.

Avant votre première campagne, définissez la page de désinscription propre à chaque domaine et, si vous voulez des liens à votre nom, un sous-domaine de désinscription. D'ici là, les destinataires voient l'hôte partagé et la page par défaut de votre équipe. Voir [Désinscriptions](/docs/fr/concepts/unsubscribes).

**Vous recevez aussi du courrier chez Resend ?** Vérifiez le domaine ici, puis choisissez **Activer la réception** sur sa page. Resend reçoit le courrier à toutes les adresses d'un domaine. Ici, vous choisissez : activez le **Catch-all** (forfaits payants) ou créez une [boîte de réception](/docs/fr/inboxes) par adresse. Remplacez ensuite l'enregistrement MX du domaine par deux enregistrements de même priorité, `mx1.billionsend-dns.com` et `mx2.billionsend-dns.com`. Le courrier va aux enregistrements MX de priorité la plus basse : ce changement est donc la bascule. Le courrier déjà reçu par Resend y reste. Les gestionnaires d'`email.received` n'ont pas besoin de changer, et le courrier reçu se lit avec `emails.receiving` dans les [SDKs](/docs/fr/sdks). Voir [Réception](/docs/fr/receiving).

**Vous utilisez les Inboxes de Resend ?** Recréez chaque boîte avec la même adresse (`bs.inboxes.create()`, `POST /inboxes`, ou **Boîtes de réception → Créer une boîte de réception**). Les conversations et les brouillons restent chez Resend. `kind` vaut `agent` par défaut, avec les protections de BillionSend activées ; créez les boîtes que des personnes lisent avec `kind: "human"`. Ce en quoi les boîtes de réception de BillionSend diffèrent de celles de Resend :

- Créer une boîte ou un brouillon répond avec l'objet entier, dont le `{ object, id }` de Resend n'est qu'une partie.
- `POST /inboxes/{id}/emails` ouvre une nouvelle conversation en un seul appel, et `GET /inboxes/events` et `GET /inboxes/{id}/events` diffusent les événements des boîtes ; Resend n'a ni l'un ni l'autre.
- `inbox.expired` et `inbox.email.quarantined` sont des événements de webhook propres à BillionSend ; `inbox.thread.assigned` et `inbox.thread.unassigned` ne sont pas envoyés.

Voir [Boîtes de réception](/docs/fr/inboxes).

Envoyez un e-mail par la nouvelle URL de base et regardez-le passer à **Distribué** sur la page **E-mails**. La migration se résume à cela.

---

Resend est une marque déposée de Plus Five Five, Inc. BillionSend n'est ni affilié à Resend ni approuvé par lui.
