---
title: Migrar desde Resend
description: Un comando traslada los datos de tu cuenta de Resend; el SDK de BillionSend y una clave de API trasladan tu código.
ai:
  exclude: true
---

La API de BillionSend tiene los mismos endpoints y formatos de petición que la de Resend, así que migrar desde Resend es cambiar de paquete, no reescribir. Tus contactos, segmentos, temas, plantillas, webhooks, dominios y supresiones se trasladan con un comando.

## Pásalo a un agente

La migración completa está escrita como un único prompt que un agente de código puede seguir de principio a fin. Mantiene Resend en solo lectura, mantiene las claves fuera de los archivos y pregunta antes de hacer cualquier cosa irreversible.

**Copia el prompt de migración y pégalo en tu agente de código.**

> Migra este proyecto de Resend a BillionSend. Lee https://billionsend.com/docs/prompts/migrate-from-resend.es.md y síguelo paso a paso. Detente y pregunta antes de hacer cualquier cosa irreversible, y no imprimas, registres ni subas con commit nunca una clave de API.

## 1. Migra tu cuenta desde Resend

Crea una clave `bs_` de acceso completo en **Claves de API** y ejecuta en tu máquina:

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

Te pide tu clave de Resend (acceso completo) y tu clave de BillionSend, lee tu cuenta de Resend, muestra un plan, espera tu confirmación, lo aplica e imprime un resumen. Las opciones, los archivos y el uso en CI están en la página de la [CLI](/docs/es/cli).

- **Resend solo se lee.** La herramienta nunca crea, cambia ni elimina nada allí. Respeta el límite de tasa de Resend: 8 peticiones por segundo por defecto, y `--rps` lo cambia.
- **Tus claves se quedan en tu máquina.** Viven en memoria durante la ejecución y nunca se escriben en un archivo. No hay telemetría.
- **Primero el traspaso, después los detalles.** La primera pasada tarda minutos y termina con **Cutover ready**: los registros DNS que añadir y la línea de la URL base. En ese punto ya puedes trasladar el envío transaccional. Después, una segunda pasada lee las suscripciones a temas y las propiedades de cada contacto. Retén los envíos por tema y los envíos masivos hasta que termine.
- **Se puede repetir sin riesgo.** Cada ejecución compara ambos lados: las filas que difieren se actualizan, las que coinciden se dejan como están, y los contactos se emparejan por email. Ejecútala otra vez justo antes de cambiar el tráfico para recoger los contactos que hayan llegado entretanto. Pulsa Ctrl-C en cualquier momento y vuelve a ejecutarla para continuar.

| Recurso | Qué se traslada |
| --- | --- |
| Contactos | Email, nombres, `unsubscribed`, propiedades, suscripciones a temas, pertenencia a segmentos. Las bajas se mantienen; nadie se vuelve a suscribir. El `unsubscribed` de Resend es global, así que pasa a ser `unsubscribed: true` para todo el equipo en BillionSend. |
| Segmentos, temas, propiedades | Se emparejan por nombre o clave: se crean si faltan y se actualizan si difieren. |
| Plantillas | Nombre, alias, asunto, html, text. `from`, `reply_to` y `variables` no se pueden guardar y aparecen como pasos manuales. |
| Webhooks | Endpoint, eventos y secreto de firma, para que tu receptor siga verificando. Los eventos que BillionSend no envía se descartan por webhook y se enumeran en el informe. |
| Supresiones | Rebotes, quejas y entradas manuales, con su origen. |
| Dominios | Se crean con su configuración de seguimiento. Los registros DNS hay que añadirlos de nuevo (paso 3). |
| Envíos masivos | Los borradores y los programados llegan como borradores. Los ya enviados se omiten salvo que pases `--include-sent`. |

Lo que no se traslada: las **claves de API** (Resend solo muestra sus nombres, así que el informe las enumera como tarea pendiente), los **registros DNS y DKIM** (las claves pertenecen a cada proveedor), las **bandejas de entrada** con sus hilos y borradores, y el **historial de emails**.

### Cuentas grandes

La segunda pasada hace dos peticiones por contacto, contra un límite que comparte tu envío en producción. El tiempo es de unos `contactos × 2 ÷ tasa`:

| Contactos | A 8 pet/s | A 50 pet/s |
| --- | --- | --- |
| 36.685 | unas 2 h 30 min | unos 25 min |
| 160.000 | unas 11 h | unas 1 h 50 min |

Para acortarlo, pide a Resend que suba tu límite y pasa la nueva tasa con `--rps`, o ejecútalo fuera de las horas punta. Una segunda clave de API no ayuda, porque el límite es por equipo.

## 2. Apunta tu código a BillionSend

Cambia el paquete de Resend por el de BillionSend y dale una clave `bs_`. Cada SDK lee `BILLIONSEND_API_KEY` y, si está definida, `BILLIONSEND_BASE_URL`.

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

**Node.js.** Sustituye `resend` por `@billionsend/node`:

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

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

const bs = new BillionSend(); // lee 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",
});
```

Las llamadas siguen resolviéndose en `{ data, error }`. Los nombres de los métodos siguen la [referencia de la API](/docs/es/api-reference) (`emails.send`, `emails.batch`, `broadcasts.send`), y los campos de la petición mantienen los nombres de la propia API: `reply_to`, `scheduled_at` y `segment_id`, donde el paquete de Resend recibe `replyTo`, `scheduledAt` y `segmentId`. Verifica las entregas de webhook con `verifyWebhook` del mismo paquete; los secretos de firma se trasladaron con tus webhooks, así que el secreto `whsec_` que guarda tu receptor sigue funcionando. Consulta el [SDK de Node.js](/docs/es/sdks/node).

**Python.** Sustituye `resend` por `billionsend`:

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

```python
from billionsend import BillionSend

client = BillionSend()  # lee 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>",
    }
)
```

Las llamadas pasan del módulo (`resend.Emails.send(...)`) a un objeto cliente (`client.emails.send(...)`), y una llamada que falla lanza una subclase de `BillionSendError`. Consulta el [SDK de Python](/docs/es/sdks/python).

**Go.** Cambia `github.com/resend/resend-go/v4` por `github.com/billionsend/billionsend-go` (`go get github.com/billionsend/billionsend-go`). `billionsend.NewClient()` lee `BILLIONSEND_API_KEY`; todos los métodos reciben primero un `context.Context`, y los campos opcionales son punteros creados con `billionsend.String` y similares. Consulta el [SDK de Go](/docs/es/sdks/go).

**Ruby.** Cambia `resend` por `billionsend` (`gem install billionsend`, o `gem "billionsend"` en el Gemfile). En lugar de definir `Resend.api_key` y llamar a métodos de clase como `Resend::Emails.send(params)`, crea un cliente: `BillionSend::Client.new` lee `BILLIONSEND_API_KEY`, y `client.emails.send({...})` recibe el mismo hash; una clave de idempotencia pasa de `options: { idempotency_key: ... }` al argumento con nombre `idempotency_key:`. Las respuestas son Hashes con claves string (`email["id"]`), y una llamada que falla lanza una subclase de `BillionSend::Error` donde la gema anterior lanzaba `Resend::Error`. La gema no tiene método de entrega para Action Mailer: una app de Rails con `delivery_method = :resend` apunta Action Mailer al [SMTP relay](/docs/es/smtp). Consulta el [SDK de Ruby](/docs/es/sdks/ruby).

**PHP.** Cambia `resend/resend-php` por `billionsend/billionsend-php` (`composer require billionsend/billionsend-php`). `new BillionSend\Client()` lee `BILLIONSEND_API_KEY`, y llamadas como `$client->emails->send([...])` reciben los mismos arrays; una llamada que falla lanza una subclase de `BillionSendError`. Consulta el [SDK de PHP](/docs/es/sdks/php).

**Rust.** Cambia `resend-rs` por `billionsend` (`cargo add billionsend`). `BillionSend::from_env()` lee `BILLIONSEND_API_KEY`, y los recursos son métodos en lugar de campos: `resend.emails.send(email)` pasa a ser `bs.emails().send(&body).await?`. Los constructores de opciones tipados como `CreateEmailBaseOptions::new(from, to, subject).with_html(html)` dan paso a cualquier cuerpo `serde::Serialize` con los nombres de campo de la propia API, normalmente un valor `json!`; las respuestas son `serde_json::Value`, o tu propio tipo mediante `.json::<T>()`, y una llamada que falla es un `billionsend::Error` con una variante para cada tipo. Consulta el [SDK de Rust](/docs/es/sdks/rust).

**Java.** Cambia `com.resend:resend-java` por `com.billionsend:billionsend-java` (`implementation("com.billionsend:billionsend-java:0.1.2")`, o las mismas coordenadas en Maven). `new BillionSend()` lee `BILLIONSEND_API_KEY`, donde `new Resend(key)` recibía la clave. Las llamadas mantienen su forma, `client.emails().send(...)`, pero reciben un `Map` (o cualquier valor que Jackson pueda escribir) con los nombres de campo de la propia API, como `reply_to`, en lugar de `CreateEmailOptions.builder()...build()`, y responden un `JsonNode` (`sent.get("id").asText()`) en lugar de `CreateEmailResponse`. Una llamada que falla lanza una subclase no comprobada de `BillionSendException` en lugar de la excepción comprobada `ResendException`, así que los bloques `catch (ResendException e)` desaparecen. Consulta el [SDK de Java](/docs/es/sdks/java).

**.NET.** Cambia el paquete `Resend` por `BillionSend` (`dotnet remove package Resend` y después `dotnet add package BillionSend --version 0.1.0`). `new BillionSendClient()` lee `BILLIONSEND_API_KEY`, donde el cliente de Resend recibía su token mediante `ResendClientOptions`, y un mismo cliente se puede compartir con seguridad, así que regístralo una sola vez como singleton. Las llamadas siguen los ids de operación de la [referencia de la API](/docs/es/api-reference) con el sufijo `Async`, `client.Emails.SendAsync(...)`, y reciben cualquier objeto que `System.Text.Json` pueda escribir, como un objeto anónimo con los nombres de campo de la propia API (`from`, `to`, `reply_to`), en lugar de un `EmailMessage`; las respuestas son árboles `JsonNode` (`sent?["id"]`), y una llamada que falla lanza una subclase de `BillionSendException`, con `ValidationException`, `NotFoundException` y `RateLimitException` para los estados más habituales. Consulta el [SDK de .NET](/docs/es/sdks/dotnet).

**Elixir.** Cambia el paquete `resend` de la comunidad por `billionsend` (`{:billionsend, "~> 0.1"}` en `mix.exs`). `BillionSend.client()` lee `BILLIONSEND_API_KEY`, y las funciones reciben primero el cliente y después el cuerpo como un map con los nombres de campo de la propia API: `BillionSend.Emails.send(client, %{from: ..., to: [...], subject: ..., html: ...})` devuelve `{:ok, answer}` o `{:error, error}`, donde la respuesta es un map con claves de cadena (`sent["id"]`) y el error una struct de excepción como `BillionSend.NotFoundError`. Una clave de idempotencia va en las opciones, `idempotency_key: "welcome/ana"`, y todo envío lleva una de todos modos. Las entregas de webhook se comprueban con `BillionSend.verify_webhook/4`. Consulta el [SDK de Elixir](/docs/es/sdks/elixir).

**Otros lenguajes.** Llama directamente a la API REST; la página de [SDKs](/docs/es/sdks) muestra la forma con cURL.

Lo que difiere de lo que una integración con Resend puede dar por supuesto:

- **Un buzón por campo de dirección.** `from`, `to`, `cc` y `bcc` admiten un buzón cada uno, como `ada@example.com` o `Ada <ada@example.com>`. Un nombre para mostrar con coma debe ir entre comillas (`"Ada, Inc." <ada@example.com>`). Sin comillas, se lee como dos direcciones y el envío falla con `422`.
- **Suscripciones a temas.** `PATCH /contacts/{id}/topics` recibe un array JSON simple de `{ "id": "<topic-id>", "subscription": "opt_in" | "opt_out" }`.
- **Contactos en masa.** No hay un endpoint de importación de CSV. Usa `POST /contacts/batch?on_conflict=upsert` con JSON, hasta 1000 contactos por llamada. Añade `x-batch-validation: permissive` para conservar las filas válidas cuando algunas fallen.
- **Direcciones que nunca pueden recibir correo.** Un destinatario como `x@example.com`, `x@foo.test` o `x@gmail.con` se rechaza con `422 validation_error`, y también un contacto nuevo con una de esas direcciones.
- **Las bajas pertenecen al dominio de envío.** Quien hace clic en darse de baja sale solo del dominio que envió el email. El campo `unsubscribed` del contacto sigue siendo tu interruptor para todo el equipo, así que el código que comprueba quién se ha ido debe leer `unsubscribed` y `unsubscribed_domains`. Para traer una lista de bajas de otro proveedor, impórtala en **Contactos → Bajas** o envíala a `POST /unsubscribes`. Consulta [Bajas](/docs/es/concepts/unsubscribes).
- **Envíos totalmente suprimidos.** Un envío en el que todas las direcciones de `to` están suprimidas responde `422 all_recipients_suppressed`, donde Resend responde `200`. Trátalo como «no enviado», no como un fallo que reintentar. Consulta [Supresiones](/docs/es/concepts/suppressions).
- **Los adjuntos** admiten solo `content` en base64 incrustado; una URL `path` remota responde `422`.
- **Sin audiencias.** Los contactos pertenecen al equipo, y los endpoints de audiencia funcionan como alias de los [segmentos](/docs/es/concepts/segments).
- **Las cabeceras tienen lista permitida**: cualquier nombre `X-*` (salvo `X-SES-*` y `X-BillionSend-*`), cabeceras de hilos y prioridad, y el par `List-Unsubscribe`. Cualquier otra responde `422`.
- **Las supresiones en lote** admiten hasta 1000 direcciones por petición, donde Resend admite 100.
- **Los ajustes sin soporte** responden `422` en lugar de ignorarse.

## 3. Termina la lista de tareas

El resumen termina con una lista de tareas. Tres elementos aparecen siempre:

- **Añade los registros DNS de cada dominio.** BillionSend usa sus propias claves DKIM, así que los registros son nuevos incluso para un dominio que ya envía por Resend. El informe los imprime por dominio, y también están en la página del dominio en **Dominios**. Ambos proveedores pueden seguir verificados en paralelo.
- **Apunta tu código a BillionSend** en cada entorno que envía. El resumen imprime la línea de la URL base para un paquete de Resend que mantengas; con el SDK de BillionSend, define `BILLIONSEND_API_KEY` en su lugar (paso 2).
- **Crea las claves de API**, una por cada nombre que el informe enumera, en **Claves de API**.

Aparecen dos más cuando corresponden: los valores `from` y `reply_to` de las plantillas, que hay que definir en cada envío, y los eventos de webhook que BillionSend no envía. `{{{RESEND_UNSUBSCRIBE_URL}}}` en un envío masivo sigue funcionando como alias de `{{{UNSUBSCRIBE_URL}}}`.

Antes de tu primer envío masivo, configura la página de baja de cada dominio y, si quieres enlaces con tu propio nombre, un subdominio de baja. Hasta entonces, los destinatarios ven el host compartido y la página predeterminada de tu equipo. Consulta [Bajas](/docs/es/concepts/unsubscribes).

**¿Recibes correo también en Resend?** Verifica el dominio aquí y elige **Activar la recepción** en su página. Resend recibe correo en todas las direcciones de un dominio. Aquí eliges: activa el **Catch-all** (planes de pago) o crea una [bandeja de entrada](/docs/es/inboxes) por dirección. Después sustituye el registro MX del dominio por dos con la misma prioridad, `mx1.billionsend-dns.com` y `mx2.billionsend-dns.com`. El correo va a los registros MX de menor prioridad, así que ese cambio es el traspaso. El correo que Resend ya recibió se queda allí. Los handlers de `email.received` no necesitan cambios, y el correo recibido se lee con `emails.receiving` en los [SDKs](/docs/es/sdks). Consulta [Recepción](/docs/es/receiving).

**¿Usas las Inboxes de Resend?** Crea cada bandeja de nuevo con la misma dirección (`bs.inboxes.create()`, `POST /inboxes`, o **Bandejas de entrada → Crear bandeja de entrada**). Los hilos y borradores se quedan en Resend. `kind` es `agent` por defecto, con las protecciones de BillionSend activadas; crea las bandejas que leen personas con `kind: "human"`. En qué se diferencian las bandejas de entrada de BillionSend de las de Resend:

- Crear una bandeja o un borrador responde el objeto completo, del que el `{ object, id }` de Resend es una parte.
- `POST /inboxes/{id}/emails` inicia una conversación nueva en una sola llamada, y `GET /inboxes/events` y `GET /inboxes/{id}/events` transmiten los eventos de las bandejas; Resend no tiene ninguno de los dos.
- `inbox.expired` e `inbox.email.quarantined` son eventos de webhook propios de BillionSend; `inbox.thread.assigned` e `inbox.thread.unassigned` no se envían.

Consulta [Bandejas de entrada](/docs/es/inboxes).

Envía un email por la nueva URL base y míralo llegar a **Entregado** en la página **Emails**. Eso es toda la migración.

---

Resend es una marca registrada de Plus Five Five, Inc. BillionSend no está afiliado a Resend ni cuenta con su respaldo.
