Aller au contenu
Esc
↑↓naviguer↵ouvrir⌘Japerçu
Sur cette page

Migrer depuis Resend

Une commande déplace les données de votre compte Resend ; le SDK BillionSend et une clé API déplacent votre code.

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.

1. Déplacez votre compte

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

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.

  • 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.

BILLIONSEND_API_KEY=bs_...

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

npm uninstall resend
npm install @billionsend/node
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 (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.

Python. Remplacez resend par billionsend :

pip uninstall resend
pip install billionsend
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.

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.

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. Voir SDK 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.

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.

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.

.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 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.

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.

Autres langages. Appelez directement l’API REST ; la page 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.
  • 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.
  • 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.
  • 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.

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 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. Voir Réception.

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.

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.

Cette page vous a-t-elle été utile ?