Resend Email

offiziell

Senden Sie E-Mails direkt aus Ihrem Editor mit der Resend API.

Was kann man mit Resend Email MCP machen?

  • E-Mails senden und planen — Bitte deinen Assistenten, HTML- oder Nur-Text-E-Mails mit CC/BCC, Antwortadresse, Anhängen, Tags und geplantem Versand zu senden.
  • Kontakte und Segmente verwalten — Kontakte erstellen, aktualisieren und entfernen, Segmentzugehörigkeiten und Themenabonnements verwalten sowie CSV-Importe ausführen.
  • Broadcast-Kampagnen durchführen — Broadcasts erstellen, planen, senden oder abbrechen und anschließend Empfänger nach Ereignistyp und angeklickten Links überprüfen.
  • Eingehende E-Mails und Posteingänge verwalten — Empfangene E-Mails auflisten und lesen, Anhänge herunterladen sowie Posteingangs-Threads, Labels und Entwürfe verwalten.
  • Domains und Sperrlisten verwalten — Absenderdomains erstellen, verifizieren und konfigurieren sowie Einträge zur Sperrliste hinzufügen oder daraus entfernen.
  • Protokolle und Nutzung prüfen — API-Anforderungsprotokolle mit vollständigen Anforderungs- und Antwortinhalten überprüfen und die Kontonutzung sowie das Kontingent prüfen.

Gehosteter MCP-Server

npx add-mcp 'https://mcp.resend.com/mcp'

Installiert in Claude Code, Codex, Cursor und mehr

Dokumentation

Resend MCP Server

npm version

Verbinden Sie Ihren KI-Agenten mit der Resend-Plattform. Senden und empfangen Sie E-Mails und verwalten Sie Kontakte, Broadcasts, Domains und mehr direkt über jeden MCP-Client wie Claude, Cursor oder Claude Code.

Wir bieten sowohl einen von Resend gehosteten Remote-MCP-Server als auch einen lokalen MCP-Server (dieses Paket) an.

Remote-MCP-Server

Resend hostet den MCP-Server unter:

https://mcp.resend.com/mcp

Verbinden Sie jeden MCP-Client, der Remote-Server unterstützt (Streamable HTTP). Es muss nichts installiert und kein lokaler Prozess ausgeführt werden. Damit ist dies die beste Option für webbasierte Clients wie Claude und gehostete Agent-Plattformen.

Beim Verbinden öffnet Ihr Client ein Browserfenster, in dem Sie sich bei Resend anmelden und den Zugriff per OAuth genehmigen.

Claude Code

claude mcp add --transport http resend https://mcp.resend.com/mcp

Führen Sie anschließend /mcp in Claude Code aus und wählen Sie resend, um die OAuth-Anmeldung abzuschließen.

Claude

Öffnen Sie in Claude (Web oder Desktop) Settings > Connectors > Add custom connector und geben Sie Folgendes ein:

https://mcp.resend.com/mcp

Cursor

Öffnen Sie die Befehlspalette und wählen Sie „Cursor Settings“ > „MCP“ > „Add new global MCP server“.

{
  "mcpServers": {
    "resend": {
      "url": "https://mcp.resend.com/mcp"
    }
  }
}

Codex

codex mcp add resend --url https://mcp.resend.com/mcp

Copilot

Um GitHub Copilot in VS Code zu verwenden, fügen Sie Folgendes zu Ihrer settings.json hinzu:

{
  "mcp": {
    "servers": {
      "resend": {
        "type": "http",
        "url": "https://mcp.resend.com/mcp"
      }
    }
  }
}

Windsurf

{
  "mcpServers": {
    "resend": {
      "serverUrl": "https://mcp.resend.com/mcp"
    }
  }
}

Warp

Navigieren Sie in den Warp-Einstellungen zu Agents > MCP servers und klicken Sie auf +Add, um einen neuen Server hinzuzufügen.

{
  "resend": {
    "serverUrl": "https://mcp.resend.com/mcp"
  }
}

Authentifizierung mit einem API-Schlüssel

Wenn Ihr Client an einem Ort ausgeführt wird, an dem keine Browseranmeldung möglich ist (einem Server, in CI oder mit einem Headless-Agenten), übergeben Sie stattdessen einen Resend-API-Schlüssel als Bearer-Token und verwenden Sie kein OAuth.

Claude Code:

claude mcp add --transport http resend https://mcp.resend.com/mcp --header "Authorization: Bearer re_xxxxxxxxx"

JSON-Konfiguration (Cursor, Windsurf und andere): Fügen Sie einen Authorization-Header hinzu:

{
  "mcpServers": {
    "resend": {
      "url": "https://mcp.resend.com/mcp",
      "headers": {
        "Authorization": "Bearer re_xxxxxxxxx"
      }
    }
  }
}

Lokaler MCP-Server

Der gehostete Server führt denselben Open-Source-Code aus, der auf NPM als resend-mcp verfügbar ist. Wenn Sie den Server lieber selbst ausführen möchten, können Sie ihn mithilfe von npx in jeden unterstützten MCP-Client integrieren. Sie benötigen Folgendes:

Der lokale Server unterstützt zwei Transportmodi: stdio (Standard) und HTTP.

Wählen Sie unten Ihren bevorzugten Modus und Client aus, um loszulegen. Denken Sie daran, re_xxxxxxxxx durch Ihren tatsächlichen API-Schlüssel zu ersetzen.

Stdio-Transport (Standard)

Schnellstart

Für alle erkannten/ausgewählten Agenten und Editoren installieren:

npx add-mcp resend-mcp --name resend --env "RESEND_API_KEY=re_xxxxxxxxx"

Claude Code

claude mcp add resend -e RESEND_API_KEY=re_xxxxxxxxx -- npx -y resend-mcp

Codex

codex mcp add resend \
  --env RESEND_API_KEY=re_xxxxxxxxx \
  -- npx -y resend-mcp

Cursor

Öffnen Sie die Befehlspalette und wählen Sie „Cursor Settings“ > „MCP“ > „Add new global MCP server“.

{
  "mcpServers": {
    "resend": {
      "command": "npx",
      "args": ["-y", "resend-mcp"],
      "env": {
        "RESEND_API_KEY": "re_xxxxxxxxx"
      }
    }
  }
}

Claude Desktop

Öffnen Sie die Claude-Desktop-Einstellungen > Registerkarte „Developer“ > „Edit Config“.

{
  "mcpServers": {
    "resend": {
      "command": "npx",
      "args": ["-y", "resend-mcp"],
      "env": {
        "RESEND_API_KEY": "re_xxxxxxxxx"
      }
    }
  }
}

Copilot

Um GitHub Copilot in VS Code zu verwenden, fügen Sie Folgendes zu Ihrer settings.json hinzu:

{
  "mcp": {
    "servers": {
      "resend": {
        "command": "npx",
        "args": ["-y", "resend-mcp"],
        "env": {
          "RESEND_API_KEY": "re_xxxxxxxxx"
        }
      }
    }
  }
}

Gemini CLI

{
  "mcpServers": {
    "resend": {
      "command": "npx",
      "args": ["-y", "resend-mcp"],
      "env": {
        "RESEND_API_KEY": "re_xxxxxxxxx"
      }
    }
  }
}

OpenCode

Fügen Sie Folgendes zu Ihrer opencode.json-Konfiguration hinzu:

{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "resend": {
      "type": "local",
      "command": ["npx", "-y", "resend-mcp"],
      "enabled": true,
      "environment": {
        "RESEND_API_KEY": "re_xxxxxxxxx"
      }
    }
  }
}

Windsurf

{
  "mcpServers": {
    "resend": {
      "command": "npx",
      "args": ["-y", "resend-mcp"],
      "env": {
        "RESEND_API_KEY": "re_xxxxxxxxx"
      }
    }
  }
}

Devin

Öffnen Sie in Devin Settings > Connections > MCP Servers und klicken Sie auf Add a custom MCP. Eine vollständige Schritt-für-Schritt-Anleitung finden Sie im Devin-Leitfaden.

{
  "mcpServers": {
    "resend": {
      "command": "npx",
      "args": ["-y", "resend-mcp"],
      "env": {
        "RESEND_API_KEY": "re_xxxxxxxxx",
        "SENDER_EMAIL_ADDRESS": "onboarding@resend.dev"
      }
    }
  }
}

HTTP-Transport

Führen Sie den Server über HTTP für Remote- oder webbasierte Integrationen aus, beispielsweise hinter einem eigenen Tunnel oder Reverse-Proxy, anstatt Resends gehosteten Remote-MCP-Server zu verwenden. Im HTTP-Modus authentifiziert sich jeder Client, indem er seinen Resend-API-Schlüssel als Bearer-Token im Authorization-Header übergibt.

Starten Sie den Server:

npx -y resend-mcp --http --port 3000

Der Server lauscht auf http://127.0.0.1:3000 und stellt den MCP-Endpunkt unter /mcp über Streamable HTTP bereit.

Claude Code

claude mcp add resend --transport http http://127.0.0.1:3000/mcp --header "Authorization: Bearer re_xxxxxxxxx"

Cursor

Öffnen Sie die Befehlspalette und wählen Sie „Cursor Settings“ > „MCP“ > „Add new global MCP server“.

{
  "mcpServers": {
    "resend": {
      "url": "http://127.0.0.1:3000/mcp",
      "headers": {
        "Authorization": "Bearer re_xxxxxxxxx"
      }
    }
  }
}

Sie können den Port auch über die Umgebungsvariable MCP_PORT festlegen:

MCP_PORT=3000 npx -y resend-mcp --http

Als Bibliothek verwenden

Der HTTP-Transport wird ebenfalls exportiert, sodass er in einen anderen Dienst eingebettet werden kann, anstatt über die CLI ausgeführt zu werden. Jeder verbindende Client authentifiziert sich mit seinem eigenen Resend-API-Schlüssel, der als Bearer-Token übergeben wird.

import { runHttp } from 'resend-mcp/http';

// Options are optional — pass `senderEmailAddress` / `replierEmailAddresses`
// to set defaults. Binds the port and returns the Node http.Server, exposing
// the MCP endpoint at POST/GET/DELETE /mcp and a GET /health check.
const server = await runHttp({}, 3000);

Standardmäßig wendet der Server eine auf localhost beschränkte Host-Validierung an (Schutz vor DNS-Rebinding). Bei der Bereitstellung hinter einem Reverse-Proxy oder Load-Balancer, wenn der Server durch den Bearer-API-Schlüssel pro Anfrage geschützt ist, setzen Sie host auf 0.0.0.0, damit die weitergeleiteten Host-Header des Proxys und die Health-Checks des Load-Balancers nicht mit 403 Invalid Host abgewiesen werden:

const server = await runHttp({}, 3000, { host: '0.0.0.0' });
// or pin specific hostnames instead of disabling validation:
const server = await runHttp({}, 3000, { allowedHosts: ['mcp.example.com'] });

Über die CLI entspricht dies --host / --allowed-hosts (oder MCP_HOST / MCP_ALLOWED_HOSTS).

Optionen

Sie können zusätzliche Argumente übergeben, um den lokalen Server zu konfigurieren:

  • --key: Ihr Resend-API-Schlüssel (nur im stdio-Modus, da der HTTP-Modus das Bearer-Token des Clients verwendet)
  • --sender: Standard-Absender-E-Mail-Adresse einer verifizierten Domain
  • --reply-to: Standard-Antwortadresse (kann mehrfach angegeben werden)
  • --http: HTTP-Transport anstelle von stdio verwenden (Standard: stdio)
  • --port: HTTP-Port bei Verwendung von --http (Standard: 3000 oder Umgebungsvariable MCP_PORT)
  • --host: Host für den DNS-Rebinding-Schutz bei Verwendung von --http (Standard: 127.0.0.1 oder MCP_HOST). Auf 0.0.0.0 setzen, um die Host-Validierung hinter einem Proxy/Load-Balancer zu deaktivieren.
  • --allowed-hosts: Durch Kommas getrennte Host-Zulassungsliste bei Verwendung von --http (oder MCP_ALLOWED_HOSTS)
  • --allowed-file-dirs: Durch Kommas getrennte Verzeichnisse, aus denen lokale Dateianhänge und CSV-Importe gelesen werden dürfen (oder MCP_ALLOWED_FILE_DIRS). Bei nicht gesetzter Option in stdio uneingeschränkt; über --http immer deaktiviert, sofern nicht gesetzt.

Umgebungsvariablen:

  • RESEND_API_KEY: Ihr Resend-API-Schlüssel (erforderlich für stdio, optional für HTTP, da Clients ihn als Bearer-Token übergeben)
  • SENDER_EMAIL_ADDRESS: Standard-Absender-E-Mail-Adresse einer verifizierten Domain (optional)
  • REPLY_TO_EMAIL_ADDRESSES: Durch Kommas getrennte Antwortadressen (optional)
  • MCP_PORT: HTTP-Port bei Verwendung von --http (optional)
  • MCP_HOST: Host für den DNS-Rebinding-Schutz bei Verwendung von --http (optional)
  • MCP_ALLOWED_HOSTS: Durch Kommas getrennte Host-Zulassungsliste bei Verwendung von --http (optional)
  • MCP_ALLOWED_FILE_DIRS: Durch Kommas getrennte Verzeichnisse, aus denen lokale Dateien gelesen werden dürfen (optional)

[!NOTE] Wenn Sie keine Absender-E-Mail-Adresse angeben, fordert der MCP-Server Sie bei jedem Tool-Aufruf dazu auf.

[!WARNING] send-email (attachments[].filePath) und create-contact-import (filePath) lesen lokale Dateien. Über --http ist dies standardmäßig deaktiviert, damit Remote-Clients nicht auf die Festplatte des Servers zugreifen können. Verwenden Sie --allowed-file-dirs, um bestimmte Verzeichnisse freizugeben. Legen Sie bei stdio --allowed-file-dirs fest, damit ein durch Prompt-Injection manipulierter Agent keine Dateien außerhalb der von Ihnen ausgewählten Ordner anhängen kann.

MCP-Server-Tools

Der MCP-Server von Resend ermöglicht Ihrem KI-Agenten über eine einzige Integration nativen Zugriff auf die gesamte Resend-Plattform. Sie können alle Aspekte Ihrer E-Mail-Infrastruktur in natürlicher Sprache verwalten.

  • E-Mails: E-Mails senden, auflisten, abrufen, abbrechen, aktualisieren, teilen und stapelweise versenden. Zustellungs- und Interaktionsmetriken abrufen. Unterstützt HTML, Nur-Text, Anhänge (lokale Datei, URL oder Base64), CC/BCC, Antwortadressen, geplanten Versand, Tags, benutzerdefinierte Header, themenbasierten Versand und Idempotenzschlüssel.
  • Empfangene E-Mails: Eingehende E-Mails auflisten und lesen. Anhänge empfangener E-Mails auflisten und herunterladen.
  • Posteingänge: Posteingänge erstellen, auflisten, abrufen, aktualisieren und entfernen. Agenteneinstellungen des Posteingangs lesen und aktualisieren. Threads auflisten, suchen, abrufen, aktualisieren und entfernen sowie ihre Labels hinzufügen, festlegen oder entfernen. Thread-E-Mails auflisten und abrufen sowie mit Anhängen und benutzerdefinierten Headern darauf antworten oder sie weiterleiten. Labels erstellen, auflisten, aktualisieren und entfernen. Entwürfe erstellen, auflisten, abrufen, aktualisieren, entfernen und versenden; Anhänge können aus Base64-Inhalten oder über eine URL hinzugefügt werden. Neue E-Mails aus einem Posteingang senden, um einen Thread zu starten. Unterstützt Idempotenzschlüssel beim Antworten, Weiterleiten, Erstellen und Versenden von Entwürfen sowie beim Senden neuer E-Mails.
  • Vorlagen: E-Mail-Vorlagen erstellen, auflisten, abrufen, aktualisieren, veröffentlichen, duplizieren und entfernen. Unterstützt das Verfassen von Vorlageninhalten und {{{VARIABLE}}}-Platzhalter.
  • Kontakte: Kontakte erstellen, auflisten, abrufen, aktualisieren und entfernen. Segmentzugehörigkeiten, Themenabonnements und CSV-Kontaktimporte verwalten. Unterstützt benutzerdefinierte Kontakteigenschaften.
  • Broadcasts: Broadcast-Kampagnen erstellen, versenden, abbrechen, duplizieren, auflisten, abrufen, aktualisieren und entfernen. Die angeklickten Links eines Broadcasts sowie seine Empfänger nach Ereignistyp auflisten (gesendet, zugestellt, geöffnet, angeklickt, zurückgewiesen, beanstandet, abgemeldet, unterdrückt). Unterstützt geplanten Versand, Personalisierungsplatzhalter und Vorschautext.
  • Automatisierungen: Automatisierungen erstellen, auflisten, abrufen, aktualisieren, duplizieren und entfernen. Ausführungen einer Automatisierung überprüfen.
  • Ereignisse: Ereignisse senden, um Automatisierungen für einen Kontakt auszulösen. Ereignisdefinitionen erstellen, aktualisieren und entfernen.
  • Domains: Absenderdomains erstellen, auflisten, abrufen, aktualisieren, entfernen und verifizieren. Tracking, TLS sowie Sende- und Empfangsfunktionen konfigurieren. Domain-Ansprüche erstellen und verifizieren.
  • Segmente: Zielgruppensegmente erstellen, auflisten, abrufen, aktualisieren und entfernen.
  • Unterdrückungen: Einträge in der Unterdrückungsliste einzeln oder stapelweise auflisten, abrufen, hinzufügen und entfernen. Hard Bounces und Spam-Beschwerden werden automatisch unterdrückt; fügen Sie Adressen manuell hinzu, um Kontaktverbote zu berücksichtigen.
  • Themen: Abonnementthemen erstellen, auflisten, abrufen, aktualisieren und entfernen.
  • Kontakteigenschaften: Benutzerdefinierte Kontaktattribute erstellen, auflisten, abrufen, aktualisieren und entfernen.
  • API-Schlüssel: API-Schlüssel erstellen, auflisten, aktualisieren und entfernen.
  • Webhooks: Webhooks für Ereignisbenachrichtigungen erstellen, auflisten, abrufen, aktualisieren und entfernen sowie ihren Zustellungsverlauf einsehen – die an einen Webhook gesendeten Ereignisse, die Nutzdaten eines Ereignisses und die Zustellversuche. Ein Ereignis erneut abspielen, um eine weitere Zustellung in die Warteschlange einzureihen, und das Signaturgeheimnis eines Webhooks rotieren.
  • Protokolle: API-Anforderungsprotokolle einschließlich vollständiger Anforderungs- und Antwortinhalte auflisten und einsehen.
  • Nutzung: Nutzungs- und Kontingentinformationen auf Kontoebene abrufen: E-Mails, Kontakte, Segmente, Broadcasts, KI-Credits, Automatisierungsausführungen, Domains und API-Ratenlimit.
  • Editor: Verbindung zum visuellen Editor im Resend-Dashboard herstellen und trennen sowie den Inhalt eines Entwurfs lesen, während Sie gemeinsam an Broadcasts und Vorlagen arbeiten.

Lokale Entwicklung

  1. Klonen Sie dieses Projekt und erstellen Sie den Build:
git clone https://github.com/resend/resend-mcp.git
pnpm install
pnpm run build
  1. Um den lokalen Build zu verwenden, ersetzen Sie den Befehl npx durch den Pfad zu Ihrem lokalen Build:

Claude Code (stdio):

claude mcp add resend -e RESEND_API_KEY=re_xxxxxxxxx -- node ABSOLUTE_PATH_TO_PROJECT/dist/index.js

Claude Code (HTTP):

claude mcp add resend --transport http http://127.0.0.1:3000/mcp --header "Authorization: Bearer re_xxxxxxxxx"

Cursor / Claude Desktop (stdio):

{
  "mcpServers": {
    "resend": {
      "command": "node",
      "args": ["ABSOLUTE_PATH_TO_PROJECT/dist/index.js"],
      "env": {
        "RESEND_API_KEY": "re_xxxxxxxxx"
      }
    }
  }
}

Cursor (HTTP):

{
  "mcpServers": {
    "resend": {
      "url": "http://127.0.0.1:3000/mcp",
      "headers": {
        "Authorization": "Bearer re_xxxxxxxxx"
      }
    }
  }
}

Live-Tests mit einem MCP-Client

Während der Entwicklung können Sie Änderungen in einer echten MCP-Client-Sitzung testen und gleichzeitig den Code in einer anderen Sitzung bearbeiten.

Die Idee: Führen Sie tsc --watch aus, um dist/ kontinuierlich neu zu erstellen, und richten Sie einen separaten MCP-Client aus einem anderen Verzeichnis auf den erstellten dist/index.js aus. Um Codeänderungen zu übernehmen, starten Sie die MCP-Client-Sitzung neu (MCP-Server sind langlebige stdio-Prozesse, die nicht automatisch neu geladen werden).

Beispiel mit Claude Code:

  1. Führen Sie den TypeScript-Watcher aus, damit bei jedem Speichern automatisch ein neuer Build erstellt wird:

    pnpm tsc --watch
    
  2. Erstellen Sie in einem separaten Verzeichnis eine .mcp.json, die auf die Build-Ausgabe verweist:

    mkdir -p /tmp/mcp-test
    
    // /tmp/mcp-test/.mcp.json
    {
      "mcpServers": {
        "resend-dev": {
          "command": "node",
          "args": ["/absolute/path/to/resend-mcp/dist/index.js"],
          "env": {
            "RESEND_API_KEY": "re_xxxxxxxxx"
          }
        }
      }
    }
    
  3. Starten Sie Claude Code aus diesem Verzeichnis und verwenden Sie die MCP-Tools. Starten Sie nach Codeänderungen eine neue Claude-Code-Sitzung, um den neuen Build zu übernehmen.

Dasselbe Prinzip gilt für jeden MCP-Client: Trennen Sie Ihre Testumgebung von Ihrer Entwicklungsumgebung, verwenden Sie einen absoluten Pfad zu dist/index.js und verbinden Sie den MCP-Server nach dem Neuerstellen erneut.

Testen mit MCP Inspector

Hinweis: Stellen Sie sicher, dass Sie das Projekt zuerst erstellt haben (siehe Abschnitt Lokale Entwicklung oben).

Stdio-Transport verwenden

  1. Legen Sie Ihren API-Schlüssel fest:

    export RESEND_API_KEY=re_your_key_here
    
  2. Starten Sie den Inspector:

    pnpm inspector
    
  3. Im Browser (Inspector-UI):

    • Wählen Sie stdio (einen Prozess starten).
    • Befehl: node
    • Argumente: dist/index.js (oder den vollständigen Pfad zu dist/index.js)
    • Umgebung: RESEND_API_KEY=re_your_key_here (oder leer lassen, wenn Sie die Variable bereits im selben Terminal exportiert haben).
    • Klicken Sie auf Connect und verwenden Sie anschließend „List tools“, um zu überprüfen, ob der Server funktioniert.

HTTP-Transport verwenden

  1. Starten Sie den HTTP-Server in einem Terminal:

    node dist/index.js --http --port 3000
    
  2. Starten Sie den Inspector in einem anderen Terminal:

    pnpm inspector
    
  3. Im Browser (Inspector-UI):

    • Wählen Sie Streamable HTTP (mit URL verbinden).
    • URL: http://127.0.0.1:3000/mcp
    • Fügen Sie einen benutzerdefinierten Header hinzu: Authorization: Bearer re_your_key_here und aktivieren Sie den Schalter.
    • Klicken Sie auf Connect und verwenden Sie anschließend „List tools“, um zu überprüfen, ob der Server funktioniert.