---
title: Migrar do Resend
description: Um comando move os dados da sua conta do Resend; o SDK do BillionSend e uma chave de API movem o seu código.
ai:
  exclude: true
---

A API do BillionSend tem os mesmos endpoints e formatos de requisição do Resend, então migrar é uma troca de pacote, não uma reescrita. Seus contatos, segmentos, tópicos, templates, webhooks, domínios e supressões vêm com um comando.

## Passe para um agente

A migração inteira está escrita como um único prompt que um agente de código pode seguir do começo ao fim. Ele mantém o Resend somente leitura, mantém as chaves fora de arquivos e pergunta antes de qualquer coisa irreversível.

**Copie o prompt de migração e cole no seu agente de código.**

> Migre este projeto do Resend para o BillionSend. Leia https://billionsend.com/docs/prompts/migrate-from-resend.pt-br.md e siga-o passo a passo. Pare e pergunte antes de qualquer coisa irreversível, e nunca imprima, registre em log nem faça commit de uma chave de API.

## 1. Mova sua conta

Crie uma chave `bs_` com acesso total em **Chaves de API** e rode na sua máquina:

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

Ele pede sua chave do Resend (acesso total) e sua chave do BillionSend, lê sua conta do Resend, mostra um plano, espera sua confirmação, aplica e imprime um resumo. Flags, arquivos e uso em CI estão na página [CLI](/docs/pt-br/cli).

- **O Resend só é lido.** A ferramenta nunca cria, altera nem apaga nada lá. Ela respeita o limite de taxa do Resend: 8 requisições por segundo por padrão, e `--rps` muda isso.
- **Suas chaves ficam na sua máquina.** Elas ficam na memória durante a execução e nunca são gravadas em arquivo. Não há telemetria.
- **Virada primeiro, detalhes depois.** A primeira etapa leva minutos e termina com **Cutover ready**: os registros DNS a adicionar e a linha da URL base. Nesse ponto você já pode mover o envio transacional. Uma segunda etapa lê então as assinaturas de tópicos e as propriedades de cada contato. Segure envios por tópico e transmissões até ela terminar.
- **Pode rodar de novo.** Cada execução compara os dois lados: linhas diferentes são atualizadas, linhas iguais ficam como estão, e contatos são casados pelo e-mail. Rode de novo logo antes de trocar o tráfego para pegar os contatos que chegaram no meio tempo. Pressione Ctrl-C quando quiser e rode de novo para continuar de onde parou.

| Recurso | O que é movido |
| --- | --- |
| Contatos | E-mail, nomes, `unsubscribed`, propriedades, assinaturas de tópicos, participação em segmentos. Os descadastros são mantidos; ninguém é reinscrito. O `unsubscribed` do Resend é global, então vira `unsubscribed: true` para a equipe toda no BillionSend. |
| Segmentos, tópicos, propriedades | Casados por nome ou chave: criados quando faltam, atualizados quando diferentes. |
| Templates | Nome, alias, assunto, html, text. `from`, `reply_to` e `variables` não podem ser guardados e aparecem como passos manuais. |
| Webhooks | Endpoint, eventos e segredo de assinatura, para o seu receptor continuar verificando. Eventos que o BillionSend não envia são descartados por webhook e listados no relatório. |
| Supressões | Rejeições, reclamações e entradas manuais, com a origem de cada uma. |
| Domínios | Criados com as configurações de rastreamento. Os registros DNS precisam ser adicionados de novo (passo 3). |
| Transmissões | Rascunhos e agendadas chegam como rascunhos. As já enviadas são ignoradas, a menos que você use `--include-sent`. |

O que não é movido: **chaves de API** (o Resend só mostra os nomes, então o relatório as lista como tarefa), **registros DNS e DKIM** (as chaves pertencem a cada provedor), **caixas de entrada** com suas conversas e rascunhos, e o **histórico de e-mails**.

### Contas grandes

A segunda etapa faz duas requisições por contato, contra um limite que o seu envio em produção divide. O tempo é de cerca de `contatos × 2 ÷ taxa`:

| Contatos | A 8 req/s | A 50 req/s |
| --- | --- | --- |
| 36.685 | cerca de 2 h 30 min | cerca de 25 min |
| 160.000 | cerca de 11 h | cerca de 1 h 50 min |

Para encurtar, peça ao Resend para aumentar o seu limite e passe a nova taxa com `--rps`, ou rode fora do horário de pico. Uma segunda chave de API não ajuda, porque o limite é por equipe.

## 2. Aponte seu código para o BillionSend

Troque o pacote do Resend pelo do BillionSend e dê a ele uma chave `bs_`. Cada SDK lê `BILLIONSEND_API_KEY` e, quando definida, `BILLIONSEND_BASE_URL`.

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

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

```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: ["ana@example.com"],
  subject: "Welcome to Acme",
  html: "<p>Glad you are here.</p>",
  reply_to: "support@acme.dev",
});
```

As chamadas continuam resolvendo para `{ data, error }`. Os nomes dos métodos seguem a [referência da API](/docs/pt-br/api-reference) (`emails.send`, `emails.batch`, `broadcasts.send`), e os campos da requisição mantêm os nomes da própria API: `reply_to`, `scheduled_at` e `segment_id`, onde o pacote do Resend recebe `replyTo`, `scheduledAt` e `segmentId`. Verifique as entregas de webhook com `verifyWebhook` do mesmo pacote; os segredos de assinatura vieram junto com os seus webhooks, então o segredo `whsec_` que o seu receptor guarda continua funcionando. Veja [SDK para Node.js](/docs/pt-br/sdks/node).

**Python.** Substitua `resend` por `billionsend` 0.1.1:

```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": ["ana@example.com"],
        "subject": "Welcome to Acme",
        "html": "<p>Glad you are here.</p>",
    }
)
```

As chamadas passam do módulo (`resend.Emails.send(...)`) para um objeto cliente (`client.emails.send(...)`), e uma chamada que falha lança uma subclasse de `BillionSendError`. Veja [SDK para Python](/docs/pt-br/sdks/python).

**Go.** Troque `github.com/resend/resend-go/v4` por `github.com/billionsend/billionsend-go` 0.1.3 (`go get github.com/billionsend/billionsend-go@v0.1.3`). `billionsend.NewClient()` lê `BILLIONSEND_API_KEY`; todo método recebe primeiro um `context.Context`, e os campos opcionais são ponteiros criados com `billionsend.String` e afins. Veja [SDK para Go](/docs/pt-br/sdks/go).

**Ruby.** Troque `resend` por `billionsend` 0.1.0 (`gem install billionsend`, ou `gem "billionsend", "~> 0.1"` no Gemfile). Em vez de definir `Resend.api_key` e chamar métodos de classe como `Resend::Emails.send(params)`, crie um cliente: `BillionSend::Client.new` lê `BILLIONSEND_API_KEY`, e `client.emails.send({...})` recebe o mesmo hash; uma chave de idempotência passa de `options: { idempotency_key: ... }` para o argumento nomeado `idempotency_key:`. As respostas são Hashes com chaves string (`email["id"]`), e uma chamada que falha lança uma subclasse de `BillionSend::Error` onde a gem antiga lançava `Resend::Error`. A gem não tem método de entrega para o Action Mailer: um app Rails com `delivery_method = :resend` aponta o Action Mailer para o [relay SMTP](/docs/pt-br/smtp). Veja [SDK para Ruby](/docs/pt-br/sdks/ruby).

**PHP.** Troque `resend/resend-php` por `billionsend/billionsend-php` 0.1.2 (`composer require billionsend/billionsend-php:^0.1`). `new BillionSend\Client()` lê `BILLIONSEND_API_KEY`, e chamadas como `$client->emails->send([...])` recebem os mesmos arrays; uma chamada que falha lança uma subclasse de `BillionSendError`. Veja [SDK para PHP](/docs/pt-br/sdks/php).

**Rust.** Troque `resend-rs` por `billionsend` 0.1.2 (`cargo add billionsend@0.1.2`). `BillionSend::from_env()` lê `BILLIONSEND_API_KEY`, e os recursos são métodos em vez de campos: `resend.emails.send(email)` vira `bs.emails().send(&body).await?`. Construtores de opções tipados como `CreateEmailBaseOptions::new(from, to, subject).with_html(html)` dão lugar a qualquer corpo `serde::Serialize` com os nomes de campo da própria API, em geral um valor `json!`; as respostas são `serde_json::Value`, ou o seu próprio tipo via `.json::<T>()`, e uma chamada que falha é um `billionsend::Error` com uma variante para cada tipo. Veja [SDK para Rust](/docs/pt-br/sdks/rust).

**Java.** Troque `com.resend:resend-java` por `com.billionsend:billionsend-java` 0.1.2 (`implementation("com.billionsend:billionsend-java:0.1.2")`, ou as mesmas coordenadas no Maven). `new BillionSend()` lê `BILLIONSEND_API_KEY`, onde `new Resend(key)` recebia a chave. As chamadas mantêm a forma, `client.emails().send(...)`, mas recebem um `Map` (ou qualquer valor que o Jackson consiga escrever) com os nomes de campo da própria API, como `reply_to`, no lugar de `CreateEmailOptions.builder()...build()`, e respondem um `JsonNode` (`sent.get("id").asText()`) no lugar de `CreateEmailResponse`. Uma chamada que falha lança uma subclasse não verificada de `BillionSendException` em vez da exceção verificada `ResendException`, então os blocos `catch (ResendException e)` saem. Veja [SDK para Java](/docs/pt-br/sdks/java).

**.NET.** Troque o pacote `Resend` por `BillionSend` 0.1.0 (`dotnet remove package Resend` e depois `dotnet add package BillionSend --version 0.1.0`). `new BillionSendClient()` lê `BILLIONSEND_API_KEY`, onde o cliente do Resend recebia o token por `ResendClientOptions`, e um cliente é seguro para compartilhar, então registre-o uma só vez como singleton. As chamadas seguem os ids de operação da [referência da API](/docs/pt-br/api-reference) com o sufixo `Async`, `client.Emails.SendAsync(...)`, e recebem qualquer objeto que o `System.Text.Json` consiga escrever, como um objeto anônimo com os nomes de campo da própria API (`from`, `to`, `reply_to`), no lugar de um `EmailMessage`; as respostas são árvores `JsonNode` (`sent?["id"]`), e uma chamada que falha lança uma subclasse de `BillionSendException`, com `ValidationException`, `NotFoundException` e `RateLimitException` para os status mais comuns. Veja [SDK para .NET](/docs/pt-br/sdks/dotnet).

**Elixir.** Troque o pacote `resend` da comunidade por `billionsend` 0.1.0 (`{:billionsend, "~> 0.1"}` no `mix.exs`). `BillionSend.client()` lê `BILLIONSEND_API_KEY`, e as funções recebem o cliente primeiro e depois o corpo como um mapa com os nomes de campo da própria API: `BillionSend.Emails.send(client, %{from: ..., to: [...], subject: ..., html: ...})` devolve `{:ok, answer}` ou `{:error, error}`, onde a resposta é um mapa com chaves string (`sent["id"]`) e o erro é uma struct de exceção como `BillionSend.NotFoundError`. Uma chave de idempotência vai nas opções, `idempotency_key: "welcome/ana"`, e todo envio já leva uma de qualquer jeito. As entregas de webhook são conferidas com `BillionSend.verify_webhook/4`. Veja [SDK para Elixir](/docs/pt-br/sdks/elixir).

**Outras linguagens.** Chame a API REST diretamente; a página [SDKs](/docs/pt-br/sdks) mostra a forma com cURL.

O que difere do que uma integração com o Resend pode supor:

- **Uma caixa por campo de endereço.** `from`, `to`, `cc` e `bcc` aceitam uma caixa cada, como `ada@example.com` ou `Ada <ada@example.com>`. Um nome de exibição com vírgula precisa de aspas (`"Ada, Inc." <ada@example.com>`). Sem aspas, ele é lido como dois endereços e o envio falha com `422`.
- **Assinaturas de tópicos.** `PATCH /contacts/{id}/topics` recebe um array JSON simples de `{ "id": "<topic-id>", "subscription": "opt_in" | "opt_out" }`.
- **Contatos em massa.** Não há endpoint de importação de CSV. Use `POST /contacts/batch?on_conflict=upsert` com JSON, até 1.000 contatos por chamada. Acrescente `x-batch-validation: permissive` para manter as linhas válidas quando algumas falharem.
- **Endereços que nunca podem receber e-mail.** Um destinatário como `x@example.com`, `x@foo.test` ou `x@gmail.con` é recusado com `422 validation_error`, e um novo contato nesse endereço também.
- **Descadastros pertencem ao domínio remetente.** Quem clica em descadastrar sai apenas do domínio que enviou o e-mail. O campo `unsubscribed` do contato continua sendo a sua chave para a equipe toda, então o código que verifica quem saiu deve ler `unsubscribed` e `unsubscribed_domains`. Para trazer uma lista de descadastros de outro provedor, importe-a em **Contatos → Descadastros** ou envie-a a `POST /unsubscribes`. Veja [Marcas e descadastros](/docs/pt-br/concepts/unsubscribes).
- **Envios totalmente suprimidos.** Um envio em que todos os endereços de `to` estão suprimidos responde `422 all_recipients_suppressed`, onde o Resend responde `200`. Trate como "não enviado", não como falha para tentar de novo. Veja [Supressões](/docs/pt-br/concepts/suppressions).
- **Anexos** aceitam apenas `content` em base64 embutido; uma URL `path` remota responde `422`.
- **Sem audiências.** Os contatos pertencem à equipe, e os endpoints de audiência funcionam como aliases de [segmentos](/docs/pt-br/concepts/segments).
- **Os cabeçalhos têm lista permitida**: qualquer nome `X-*` (exceto `X-SES-*` e `X-BillionSend-*`), cabeçalhos de encadeamento e prioridade, e o par `List-Unsubscribe`. Qualquer outro responde `422`.
- **Supressões em lote** aceitam até 1.000 endereços por requisição, onde o Resend aceita 100.
- **Configurações sem suporte** respondem `422` em vez de serem ignoradas.

## 3. Conclua a lista de tarefas

O resumo termina com uma lista de tarefas. Três itens sempre aparecem:

- **Adicione os registros DNS de cada domínio.** O BillionSend usa suas próprias chaves DKIM, então os registros são novos mesmo para um domínio que já envia pelo Resend. O relatório os imprime por domínio, e eles também estão na página do domínio em **Domínios**. Os dois provedores podem ficar verificados lado a lado.
- **Aponte seu código para o BillionSend** em todo ambiente que envia. O resumo imprime a linha da URL base para um pacote do Resend que você mantém; com o SDK do BillionSend, defina `BILLIONSEND_API_KEY` no lugar (passo 2).
- **Crie as chaves de API**, uma para cada nome que o relatório lista, em **Chaves de API**.

Mais dois aparecem quando se aplicam: valores de `from` e `reply_to` dos templates para definir a cada envio, e eventos de webhook que o BillionSend não envia. `{{{RESEND_UNSUBSCRIBE_URL}}}` em uma transmissão continua funcionando como alias de `{{{UNSUBSCRIBE_URL}}}`.

Antes da sua primeira transmissão, defina a página de descadastro de cada domínio e, se quiser links com o seu nome, um subdomínio de descadastro. Até lá, os destinatários veem o host compartilhado e a página padrão da sua equipe. Veja [Marcas e descadastros](/docs/pt-br/concepts/unsubscribes).

**Recebe e-mail pelo Resend também?** Verifique o domínio aqui e escolha **Ativar recebimento** na página dele. O Resend recebe em todos os endereços de um domínio. Aqui você escolhe: ative o **Catch-all** (planos pagos) ou crie uma [caixa de entrada](/docs/pt-br/inboxes) por endereço. Depois troque o registro MX do domínio por dois com a mesma prioridade, `mx1.billionsend-dns.com` e `mx2.billionsend-dns.com`. O e-mail vai para os registros MX de menor prioridade, então essa mudança é a virada. O que o Resend já recebeu fica lá. Os handlers de `email.received` não precisam de mudança, e o e-mail recebido é lido com `emails.receiving` nos [SDKs](/docs/pt-br/sdks). Veja [Recebimento](/docs/pt-br/receiving).

**Usa as Inboxes do Resend?** Crie cada caixa de novo com o mesmo endereço (`bs.inboxes.create()`, `POST /inboxes`, ou **Caixas de entrada → Criar caixa de entrada**). Conversas e rascunhos ficam no Resend. `kind` é `agent` por padrão, com as proteções do BillionSend ativas; crie as caixas que pessoas leem com `kind: "human"`. Onde as caixas de entrada do BillionSend diferem das do Resend:

- Criar uma caixa ou um rascunho responde o objeto inteiro, do qual o `{ object, id }` do Resend faz parte.
- `POST /inboxes/{id}/emails` inicia uma nova conversa numa única chamada, e `GET /inboxes/events` e `GET /inboxes/{id}/events` transmitem os eventos das caixas; o Resend não tem nenhum dos dois.
- `inbox.expired` e `inbox.email.quarantined` são eventos de webhook próprios do BillionSend; `inbox.thread.assigned` e `inbox.thread.unassigned` não são enviados.

Veja [Caixas de entrada](/docs/pt-br/inboxes).

Envie um e-mail pela nova URL base e veja-o chegar a **Delivered** na página **E-mails**. A migração é isso.

---

Resend é uma marca registrada da Plus Five Five, Inc. O BillionSend não é afiliado nem endossado pelo Resend.
