---
title: Von Resend migrieren
description: Ein Befehl überträgt Ihre Resend-Kontodaten, das BillionSend-SDK und ein API-Schlüssel übertragen Ihren Code.
ai:
  exclude: true
---

Die API von BillionSend hat dieselben Endpunkte und Anfrageformate wie die von Resend. Die Migration ist deshalb ein Paketwechsel und keine Neuentwicklung. Ihre Kontakte, Segmente, Themen, Vorlagen, Webhooks, Domains und Sperrlisten-Einträge ziehen mit einem einzigen Befehl um.

## An einen Agenten übergeben

Die gesamte Migration steht als ein Prompt bereit, dem ein Coding-Agent von Anfang bis Ende folgen kann. Er greift auf Resend nur lesend zu, hält Schlüssel aus Dateien heraus und fragt nach, bevor etwas nicht rückgängig zu machen ist.

**Kopieren Sie den Migrations-Prompt und fügen Sie ihn in Ihren Coding-Agenten ein.**

> Migrieren Sie dieses Projekt von Resend zu BillionSend. Lesen Sie https://billionsend.com/docs/prompts/migrate-from-resend.de.md und folgen Sie der Anleitung Schritt für Schritt. Halten Sie an und fragen Sie nach, bevor Sie etwas tun, das sich nicht rückgängig machen lässt, und geben Sie einen API-Schlüssel niemals aus, protokollieren Sie ihn nicht und committen Sie ihn nicht.

## 1. Konto übertragen

Erstellen Sie unter **API-Schlüssel** einen `bs_`-API-Schlüssel mit vollem Zugriff und führen Sie dann auf Ihrem Rechner aus:

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

Das Tool fragt nach Ihrem Resend-Schlüssel (voller Zugriff) und Ihrem BillionSend-Schlüssel, liest Ihr Resend-Konto, zeigt einen Plan, wartet auf Ihre Bestätigung, wendet ihn an und gibt eine Zusammenfassung aus. Optionen, Dateien und den Einsatz in CI finden Sie auf der Seite [CLI](/docs/de/cli).

- **Resend wird nur gelesen.** Das Tool legt dort nie etwas an, ändert oder löscht nichts. Es bleibt unter dem Rate-Limit von Resend: standardmäßig 8 Anfragen pro Sekunde, mit `--rps` lässt sich der Wert ändern.
- **Ihre Schlüssel bleiben auf Ihrem Rechner.** Sie liegen während des Durchlaufs im Arbeitsspeicher und werden nie in eine Datei geschrieben. Es gibt keine Telemetrie.
- **Erst die Umstellung, dann die Details.** Der erste Durchlauf dauert Minuten und endet mit **Cutover ready**: den DNS-Einträgen, die Sie hinzufügen müssen, und der Zeile für die Basis-URL. Ab diesem Punkt können Sie den Versand von Transaktionsmails umstellen. Ein zweiter Durchlauf liest dann die Themen-Abonnements und Eigenschaften jedes Kontakts. Warten Sie mit Versand nach Themen und Newsletter-Versand, bis er fertig ist.
- **Beliebig oft wiederholbar.** Jeder Durchlauf vergleicht beide Seiten: Abweichende Einträge werden aktualisiert, übereinstimmende bleiben unverändert, Kontakte werden über die E-Mail-Adresse zugeordnet. Führen Sie ihn kurz vor der Umstellung des Datenverkehrs noch einmal aus, um zwischenzeitlich hinzugekommene Kontakte zu übernehmen. Sie können jederzeit mit Strg+C abbrechen und ihn erneut starten, um fortzufahren.

| Ressource | Was übernommen wird |
| --- | --- |
| Kontakte | E-Mail-Adresse, Namen, `unsubscribed`, Eigenschaften, Themen-Abonnements, Segment-Zugehörigkeiten. Abmeldungen bleiben erhalten, niemand wird neu angemeldet. Das `unsubscribed` von Resend gilt global und wird deshalb zum teamweiten `unsubscribed: true` von BillionSend. |
| Segmente, Themen, Eigenschaften | Zugeordnet über Name oder Schlüssel: Fehlende werden angelegt, abweichende aktualisiert. |
| Vorlagen | Name, Alias, Betreff, html, text. `from`, `reply_to` und `variables` lassen sich nicht speichern und werden als manuelle Schritte aufgelistet. |
| Webhooks | Endpunkt, Ereignisse und Signing Secret, damit Ihr Empfänger weiter verifiziert. Ereignisse, die BillionSend nicht sendet, entfallen je Webhook und stehen im Bericht. |
| Sperrlisten-Einträge | Bounces, Beschwerden und manuelle Einträge samt Herkunft. |
| Domains | Werden mit ihren Tracking-Einstellungen angelegt. Die DNS-Einträge müssen erneut hinzugefügt werden (Schritt 3). |
| Newsletter-Versand (Broadcasts) | Entwürfe und geplante Sendungen kommen als Entwürfe an. Bereits versendete werden übersprungen, außer Sie übergeben `--include-sent`. |

Nicht übernommen werden: **API-Schlüssel** (Resend zeigt nur ihre Namen, deshalb führt der Bericht sie als To-do auf), **DNS- und DKIM-Einträge** (die Schlüssel gehören jeweils dem Anbieter), **Postfächer** samt Threads und Entwürfen sowie der **E-Mail-Verlauf**.

### Große Konten

Der zweite Durchlauf stellt zwei Anfragen pro Kontakt, gegen ein Limit, das Ihr produktiver Versand mitnutzt. Die Dauer beträgt etwa `contacts × 2 ÷ rate`:

| Kontakte | Bei 8 Anfr./s | Bei 50 Anfr./s |
| --- | --- | --- |
| 36.685 | etwa 2 h 30 min | etwa 25 min |
| 160.000 | etwa 11 h | etwa 1 h 50 min |

Um es zu verkürzen, bitten Sie Resend, Ihr Limit zu erhöhen, und übergeben Sie die neue Rate mit `--rps`, oder laufen Sie außerhalb der Stoßzeiten. Ein zweiter API-Schlüssel hilft nicht, weil das Limit pro Team gilt.

## 2. Code auf BillionSend umstellen

Tauschen Sie das Resend-Paket gegen das von BillionSend aus und geben Sie ihm einen `bs_`-Schlüssel. Jedes SDK liest `BILLIONSEND_API_KEY` und, wenn gesetzt, `BILLIONSEND_BASE_URL`.

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

**Node.js.** Ersetzen Sie `resend` durch `@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",
});
```

Aufrufe liefern weiterhin `{ data, error }`. Die Methodennamen folgen der [API-Referenz](/docs/de/api-reference) (`emails.send`, `emails.batch`, `broadcasts.send`), und die Anfragefelder behalten die Namen der API: `reply_to`, `scheduled_at` und `segment_id`, wo das Resend-Paket `replyTo`, `scheduledAt` und `segmentId` verwendet. Webhook-Zustellungen verifizieren Sie mit `verifyWebhook` aus demselben Paket. Die Signing Secrets sind mit Ihren Webhooks umgezogen, das `whsec_`-Secret in Ihrem Empfänger funktioniert also weiter. Siehe [Node.js-SDK](/docs/de/sdks/node).

**Python.** Ersetzen Sie `resend` durch `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>",
    }
)
```

Aufrufe wechseln vom Modul (`resend.Emails.send(...)`) zu einem Client-Objekt (`client.emails.send(...)`), und ein fehlgeschlagener Aufruf löst eine Unterklasse von `BillionSendError` aus. Siehe [Python-SDK](/docs/de/sdks/python).

**Go.** Ersetzen Sie `github.com/resend/resend-go/v4` durch `github.com/billionsend/billionsend-go` (`go get github.com/billionsend/billionsend-go`). `billionsend.NewClient()` liest `BILLIONSEND_API_KEY`. Jede Methode erwartet zuerst einen `context.Context`, und optionale Felder sind Zeiger, die mit `billionsend.String` und ähnlichen Funktionen erzeugt werden. Siehe [Go-SDK](/docs/de/sdks/go).

**Ruby.** Ersetzen Sie `resend` durch `billionsend` (`gem install billionsend` oder `gem "billionsend"` im Gemfile). Statt `Resend.api_key` zu setzen und Klassenmethoden wie `Resend::Emails.send(params)` aufzurufen, erzeugen Sie einen Client: `BillionSend::Client.new` liest `BILLIONSEND_API_KEY`, und `client.emails.send({...})` nimmt denselben Hash entgegen. Ein Idempotenzschlüssel wandert von `options: { idempotency_key: ... }` zum Schlüsselwortargument `idempotency_key:`. Antworten sind Hashes mit String-Schlüsseln (`email["id"]`), und ein fehlgeschlagener Aufruf löst eine Unterklasse von `BillionSend::Error` aus, wo das alte Gem `Resend::Error` ausgelöst hat. Das Gem bringt keine Zustellmethode für Action Mailer mit: Eine Rails-App mit `delivery_method = :resend` richtet Action Mailer auf das [SMTP-Relay](/docs/de/smtp). Siehe [Ruby-SDK](/docs/de/sdks/ruby).

**PHP.** Ersetzen Sie `resend/resend-php` durch `billionsend/billionsend-php` (`composer require billionsend/billionsend-php`). `new BillionSend\Client()` liest `BILLIONSEND_API_KEY`, und Aufrufe wie `$client->emails->send([...])` nehmen dieselben Arrays entgegen. Ein fehlgeschlagener Aufruf wirft eine Unterklasse von `BillionSendError`. Siehe [PHP-SDK](/docs/de/sdks/php).

**Rust.** Ersetzen Sie `resend-rs` durch `billionsend` (`cargo add billionsend`). `BillionSend::from_env()` liest `BILLIONSEND_API_KEY`, und Ressourcen sind Methoden statt Felder: Aus `resend.emails.send(email)` wird `bs.emails().send(&body).await?`. Typisierte Options-Builder wie `CreateEmailBaseOptions::new(from, to, subject).with_html(html)` weichen einem beliebigen `serde::Serialize`-Body mit den Feldnamen der API, meist ein `json!`-Wert. Antworten sind `serde_json::Value` oder Ihr eigener Typ über `.json::<T>()`, und ein fehlgeschlagener Aufruf ist ein `billionsend::Error` mit einer Variante je Art. Siehe [Rust-SDK](/docs/de/sdks/rust).

**Java.** Ersetzen Sie `com.resend:resend-java` durch `com.billionsend:billionsend-java` (`implementation("com.billionsend:billionsend-java:0.1.2")` oder dieselben Koordinaten in Maven). `new BillionSend()` liest `BILLIONSEND_API_KEY`, wo `new Resend(key)` den Schlüssel übergeben bekam. Aufrufe behalten ihre Form, `client.emails().send(...)`, nehmen aber eine `Map` (oder jeden Wert, den Jackson schreiben kann) mit den Feldnamen der API entgegen, etwa `reply_to`, statt `CreateEmailOptions.builder()...build()`, und liefern einen `JsonNode` (`sent.get("id").asText()`) statt `CreateEmailResponse`. Ein fehlgeschlagener Aufruf wirft eine ungeprüfte Unterklasse von `BillionSendException` statt der geprüften `ResendException`, die `catch (ResendException e)`-Blöcke entfallen also. Siehe [Java-SDK](/docs/de/sdks/java).

**.NET.** Ersetzen Sie das Paket `Resend` durch `BillionSend` (`dotnet remove package Resend`, dann `dotnet add package BillionSend --version 0.1.0`). `new BillionSendClient()` liest `BILLIONSEND_API_KEY`, wo der Resend-Client sein Token über `ResendClientOptions` bekam, und ein Client lässt sich gefahrlos teilen, registrieren Sie ihn also einmal als Singleton. Aufrufe folgen den Operations-IDs der [API-Referenz](/docs/de/api-reference) mit dem Suffix `Async`, `client.Emails.SendAsync(...)`, und nehmen jedes Objekt entgegen, das `System.Text.Json` schreiben kann, etwa ein anonymes Objekt mit den Feldnamen der API (`from`, `to`, `reply_to`), statt einer `EmailMessage`. Antworten sind `JsonNode`-Bäume (`sent?["id"]`), und ein fehlgeschlagener Aufruf wirft eine Unterklasse von `BillionSendException`, mit `ValidationException`, `NotFoundException` und `RateLimitException` für die häufigen Status. Siehe [.NET-SDK](/docs/de/sdks/dotnet).

**Elixir.** Ersetzen Sie das Community-Paket `resend` durch `billionsend` (`{:billionsend, "~> 0.1"}` in `mix.exs`). `BillionSend.client()` liest `BILLIONSEND_API_KEY`, und Funktionen nehmen zuerst den Client entgegen, dann den Body als Map mit den Feldnamen der API: `BillionSend.Emails.send(client, %{from: ..., to: [...], subject: ..., html: ...})` liefert `{:ok, answer}` oder `{:error, error}`, wobei die Antwort eine Map mit String-Schlüsseln ist (`sent["id"]`) und der Fehler eine Exception-Struct wie `BillionSend.NotFoundError`. Ein Idempotenzschlüssel gehört in die Optionen, `idempotency_key: "welcome/ana"`, und jeder Versand trägt ohnehin einen. Webhook-Zustellungen prüfen Sie mit `BillionSend.verify_webhook/4`. Siehe [Elixir-SDK](/docs/de/sdks/elixir).

**Andere Sprachen.** Rufen Sie die REST-API direkt auf. Die cURL-Form steht unter [SDKs](/docs/de/sdks).

Was sich von dem unterscheidet, was eine Resend-Integration annehmen könnte:

- **Eine Mailbox pro Adressfeld.** `from`, `to`, `cc` und `bcc` nehmen je eine Mailbox entgegen, etwa `ada@example.com` oder `Ada <ada@example.com>`. Ein Anzeigename mit Komma muss in Anführungszeichen stehen (`"Ada, Inc." <ada@example.com>`). Ohne Anführungszeichen wird er als zwei Adressen gelesen, und der Versand scheitert mit `422`.
- **Themen-Abonnements.** `PATCH /contacts/{id}/topics` erwartet ein nacktes JSON-Array aus `{ "id": "<topic-id>", "subscription": "opt_in" | "opt_out" }`.
- **Kontakte in großer Zahl.** Es gibt keinen CSV-Import-Endpunkt. Nutzen Sie `POST /contacts/batch?on_conflict=upsert` mit JSON, bis zu 1.000 Kontakte pro Aufruf. Fügen Sie `x-batch-validation: permissive` hinzu, um die gültigen Zeilen zu behalten, wenn einige fehlschlagen.
- **Adressen, die nie Mails empfangen können.** Ein Empfänger wie `x@example.com`, `x@foo.test` oder `x@gmail.con` wird mit `422 validation_error` abgelehnt, ebenso ein neuer Kontakt mit einer solchen Adresse.
- **Abmeldungen gehören zur Absenderdomain.** Ein Empfänger, der auf „Abmelden“ klickt, verlässt nur die Domain, die die E-Mail gesendet hat. Das Feld `unsubscribed` des Kontakts bleibt Ihr teamweiter Schalter. Code, der prüft, wer gegangen ist, sollte daher `unsubscribed` und `unsubscribed_domains` lesen. Um eine Abmeldeliste von einem anderen Anbieter zu übernehmen, importieren Sie sie unter **Kontakte → Abmeldungen** oder senden Sie sie an `POST /unsubscribes`. Siehe [Abmeldungen](/docs/de/concepts/unsubscribes).
- **Vollständig gesperrte Sendungen.** Ein Versand, bei dem jede `to`-Adresse gesperrt ist, antwortet mit `422 all_recipients_suppressed`, wo Resend mit `200` antwortet. Behandeln Sie das als „nicht gesendet“, nicht als Fehler, der einen erneuten Versuch verlangt. Siehe [Sperrliste](/docs/de/concepts/suppressions).
- **Anhänge** nehmen nur Inline-`content` in Base64 entgegen. Eine `path`-URL auf eine entfernte Datei antwortet mit `422`.
- **Keine Audiences.** Kontakte gehören zum Team, und die Audience-Endpunkte funktionieren als Aliase der [Segmente](/docs/de/concepts/segments).
- **Header sind über eine Positivliste zugelassen**: jeder `X-*`-Name (außer `X-SES-*` und `X-BillionSend-*`), Threading- und Prioritäts-Header sowie das Paar `List-Unsubscribe`. Alles andere antwortet mit `422`.
- **Sperrlisten-Einträge in großer Zahl** nehmen bis zu 1.000 Adressen pro Anfrage entgegen, wo Resend 100 nimmt.
- **Nicht unterstützte Einstellungen** antworten mit `422`, statt ignoriert zu werden.

## 3. Checkliste abarbeiten

Die Zusammenfassung endet mit einer Checkliste. Drei Punkte stehen immer darauf:

- **DNS-Einträge für jede Domain hinzufügen.** BillionSend verwendet eigene DKIM-Schlüssel, die Einträge sind also auch für eine Domain neu, die bereits über Resend sendet. Der Bericht gibt sie je Domain aus, und sie stehen auch auf der Seite der Domain unter **Domains**. Beide Anbieter können nebeneinander verifiziert bleiben.
- **Code auf BillionSend umstellen**, in jeder Umgebung, die sendet. Die Zusammenfassung gibt die Zeile für die Basis-URL aus, falls Sie ein Resend-Paket behalten. Mit dem BillionSend-SDK setzen Sie stattdessen `BILLIONSEND_API_KEY` (Schritt 2).
- **API-Schlüssel erstellen**, einen für jeden Namen, den der Bericht auflistet, unter **API-Schlüssel**.

Zwei weitere erscheinen, wenn sie zutreffen: `from`- und `reply_to`-Werte von Vorlagen, die Sie pro Versand setzen müssen, und Webhook-Ereignisse, die BillionSend nicht sendet. `{{{RESEND_UNSUBSCRIBE_URL}}}` in einem Newsletter-Versand funktioniert weiter als Alias von `{{{UNSUBSCRIBE_URL}}}`.

Legen Sie vor Ihrem ersten Newsletter-Versand für jede Domain die eigene Abmeldeseite fest und, wenn Sie Links unter Ihrem eigenen Namen wollen, eine Abmelde-Subdomain. Bis dahin sehen Empfänger den gemeinsamen Host und die Standardseite Ihres Teams. Siehe [Abmeldungen](/docs/de/concepts/unsubscribes).

**Empfangen Sie auch bei Resend Mails?** Verifizieren Sie die Domain hier und wählen Sie dann auf ihrer Seite **Empfang aktivieren**. Resend nimmt Mails an jeder Adresse einer Domain an. Hier entscheiden Sie: Schalten Sie **Catch-all** ein (bezahlte Tarife) oder erstellen Sie je Adresse ein [Postfach](/docs/de/inboxes). Ersetzen Sie dann den MX-Eintrag der Domain durch zwei mit derselben Priorität, `mx1.billionsend-dns.com` und `mx2.billionsend-dns.com`. Mails gehen an die MX-Einträge mit dem niedrigsten Prioritätswert, diese Änderung ist also die Umstellung. Mails, die Resend bereits empfangen hat, bleiben dort. Handler für `email.received` brauchen keine Änderung, und empfangene Mails lesen Sie mit `emails.receiving` in den [SDKs](/docs/de/sdks). Siehe [Empfang](/docs/de/receiving).

**Nutzen Sie die Postfächer von Resend?** Erstellen Sie jedes Postfach mit derselben Adresse neu (`bs.inboxes.create()`, `POST /inboxes` oder **Postfächer → Postfach erstellen**). Threads und Entwürfe bleiben bei Resend. `kind` ist standardmäßig `agent`, mit eingeschalteten Schutzfunktionen von BillionSend. Postfächer, die Menschen lesen, erstellen Sie mit `kind: "human"`. Wo sich die Postfächer von BillionSend von denen bei Resend unterscheiden:

- Das Erstellen eines Postfachs oder eines Entwurfs antwortet mit dem ganzen Objekt, von dem das `{ object, id }` von Resend ein Teil ist.
- `POST /inboxes/{id}/emails` startet eine neue Unterhaltung in einem Aufruf, und `GET /inboxes/events` sowie `GET /inboxes/{id}/events` streamen Postfach-Ereignisse. Resend hat keines von beidem.
- `inbox.expired` und `inbox.email.quarantined` sind eigene Webhook-Ereignisse von BillionSend. `inbox.thread.assigned` und `inbox.thread.unassigned` werden nicht gesendet.

Siehe [Postfächer](/docs/de/inboxes).

Senden Sie eine E-Mail über die neue Basis-URL und sehen Sie zu, wie sie auf der Seite **E-Mails** den Status **Zugestellt** erreicht. Damit ist die Migration abgeschlossen.

---

Resend ist eine eingetragene Marke von Plus Five Five, Inc. BillionSend steht in keiner Verbindung zu Resend und wird von Resend nicht empfohlen.
