Resend Email

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

Resend MCP Server

Verbinde deinen KI-Agenten mit der Resend-Plattform. Sende und empfange E-Mails, verwalte Kontakte, Broadcasts, Domains und mehr – direkt aus jedem MCP-Client wie Claude, Cursor oder Claude Code.

Wir bieten sowohl einen Remote-MCP-Server, der von Resend gehostet wird, als auch einen lokalen MCP-Server (dieses Paket).

Remote-MCP-Server

Resend hostet den MCP-Server unter:

https://mcp.resend.com/mcp

Verbinde jeden MCP-Client, der Remote-Server unterstützt (Streamable HTTP). Es muss nichts installiert werden und es läuft kein lokaler Prozess – das macht es zur besten Option für webbasierte Clients wie Claude und gehostete Agentenplattformen.

Beim Verbinden öffnet dein Client ein Browserfenster, um sich bei Resend anzumelden und den Zugriff per OAuth zu genehmigen.

Claude Code

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

Führe dann /mcp in Claude Code aus und wähle resend aus, um den OAuth-Login abzuschließen.

Claude

Öffne in Claude (Web oder Desktop) Einstellungen > Connectors > Benutzerdefinierten Connector hinzufügen und gib Folgendes ein:

https://mcp.resend.com/mcp

Cursor

Öffne die Befehlspalette und wähle „Cursor-Einstellungen" > „MCP" > „Neuen globalen MCP-Server hinzufügen".

{
  "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üge Folgendes zu deiner settings.json hinzu:

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

Windsurf

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

Warp

Navigiere in den Warp-Einstellungen zu Agenten > MCP-Server und klicke auf +Hinzufügen, um einen neuen Server hinzuzufügen.

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

Authentifizierung mit einem API-Schlüssel

Wenn dein Client an einem Ort läuft, an dem ein Browser-Login nicht möglich ist (ein Server, CI oder ein Headless-Agent), übergebe einen Resend-API-Schlüssel als Bearer-Token anstelle von 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üge einen Authorization-Header hinzu:

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

Lokaler MCP-Server

Der gehostete Server läuft mit demselben Open-Source-Code, der auf NPM als resend-mcp verfügbar ist. Wenn du den Server lieber selbst betreiben möchtest, kannst du ihn mit npx in jeden unterstützten MCP-Client integrieren. Du benötigst:

• Einen API-Schlüssel erstellen
• Deine Domain verifizieren

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

Wähle unten deinen bevorzugten Modus und Client, um loszulegen. Denke daran, re_xxxxxxxxx durch deinen tatsächlichen API-Schlüssel zu ersetzen.

Stdio-Transport (Standard)

Schnelleinrichtung

Installation für alle erkannten/ausgewählten Agenten und Editoren:

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

Öffne die Befehlspalette und wähle „Cursor-Einstellungen" > „MCP" > „Neuen globalen MCP-Server hinzufügen".

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

Claude Desktop

Öffne die Claude-Desktop-Einstellungen > Registerkarte „Entwickler" > „Konfiguration bearbeiten".

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

Copilot

Um GitHub Copilot in VS Code zu verwenden, füge Folgendes zu deiner 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üge zu deiner 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

Öffne in Devin Einstellungen > Verbindungen > MCP-Server und klicke auf Benutzerdefiniertes MCP hinzufügen. Siehe die Devin-Anleitung für die vollständige Schritt-für-Schritt-Anleitung.

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

HTTP-Transport

Führe den Server über HTTP für Remote- oder webbasierte Integrationen aus, zum Beispiel hinter deinem 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.

Starte 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

Öffne die Befehlspalette und wähle „Cursor-Einstellungen" > „MCP" > „Neuen globalen MCP-Server hinzufügen".

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

Du kannst 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 verbundene 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 Nur-Localhost-Host-Validierung an (DNS-Rebinding-Schutz). Wenn du hinter einem Reverse-Proxy oder Load Balancer bereitstellst, wo der Server durch den Pro-Request-Bearer-API-Schlüssel geschützt ist, setze host auf 0.0.0.0, damit die weitergeleiteten Host- und Load-Balancer-Health-Checks des Proxys nicht mit 403 Invalid Host abgelehnt 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

Du kannst zusätzliche Argumente übergeben, um den lokalen Server zu konfigurieren:

• --key: Dein Resend-API-Schlüssel (nur im Stdio-Modus, da der HTTP-Modus das Bearer-Token des Clients verwendet)
• --sender: Standard-Absender-E-Mail-Adresse von einer verifizierten Domain
• --reply-to: Standard-Antwort-an-E-Mail-Adresse (kann mehrfach angegeben werden)
• --http: HTTP-Transport anstelle von stdio verwenden (Standard: stdio)
• --port: HTTP-Port bei Verwendung von --http (Standard: 3000 oder MCP_PORT-Umgebungsvariable)
• --host: Host für DNS-Rebinding-Schutz bei Verwendung von --http (Standard: 127.0.0.1 oder MCP_HOST). Setze auf 0.0.0.0, um die Host-Validierung hinter einem Proxy/Load Balancer zu deaktivieren.
• --allowed-hosts: Kommagetrennte Host-Zulassungsliste bei Verwendung von --http (oder MCP_ALLOWED_HOSTS)

Umgebungsvariablen:

• RESEND_API_KEY: Dein Resend-API-Schlüssel (erforderlich für stdio, optional für HTTP, da Clients ihn über das Bearer-Token übergeben)
• SENDER_EMAIL_ADDRESS: Standard-Absender-E-Mail-Adresse von einer verifizierten Domain (optional)
• REPLY_TO_EMAIL_ADDRESSES: Kommagetrennte Antwort-an-E-Mail-Adressen (optional)
• MCP_PORT: HTTP-Port bei Verwendung von --http (optional)
• MCP_HOST: Host für DNS-Rebinding-Schutz bei Verwendung von --http (optional)
• MCP_ALLOWED_HOSTS: Kommagetrennte Host-Zulassungsliste bei Verwendung von --http (optional)

[!HINWEIS] Wenn du keine Absender-E-Mail-Adresse angibst, fordert dich der MCP-Server bei jedem Aufruf des Tools auf, eine anzugeben.

MCP-Server-Tools

Resends MCP-Server gibt deinem KI-Agenten nativen Zugriff auf die gesamte Resend-Plattform über eine einzige Integration. Du kannst alle Aspekte deiner E-Mail-Infrastruktur in natürlicher Sprache verwalten.

• E-Mails: Senden, auflisten, abrufen, stornieren, aktualisieren, teilen und E-Mails in Stapeln senden. Zustell- und Engagement-Metriken abrufen. Unterstützt HTML, Klartext, Anhänge (lokale Datei, URL oder base64), CC/BCC, Antwort-an, Zeitplanung, Tags, benutzerdefinierte Header, themenbasiertes Senden und Idempotenzschlüssel.
• Empfangene E-Mails: Eingehende E-Mails auflisten und lesen. Anhänge empfangener E-Mails auflisten und herunterladen.
• 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. Segmentmitgliedschaften, Themenabonnements und CSV-Kontaktimporte verwalten. Unterstützt benutzerdefinierte Kontakteigenschaften.
• Broadcasts: Broadcast-Kampagnen erstellen, senden, stornieren, duplizieren, auflisten, abrufen, aktualisieren und entfernen. Geklickte Links eines Broadcasts und seine Empfänger nach Ereignistyp auflisten (gesendet, zugestellt, geöffnet, geklickt, abgewiesen, beschwert, abbestellt, unterdrückt). Unterstützt Zeitplanung, Personalisierungsplatzhalter und Vorschautext.
• Automatisierungen: Automatisierungen erstellen, auflisten, abrufen, aktualisieren, duplizieren und entfernen. Die Läufe einer Automatisierung überprüfen.
• Ereignisse: Ereignisse senden, um Automatisierungen für einen Kontakt auszulösen. Ereignisdefinitionen erstellen, aktualisieren und entfernen.
• Domains: Absender-Domains erstellen, auflisten, abrufen, aktualisieren, entfernen und verifizieren. Tracking, TLS und Sende-/Empfangsfunktionen konfigurieren. Domain-Ansprüche erstellen und verifizieren.
• Segmente: Zielgruppensegmente erstellen, auflisten, abrufen, aktualisieren und entfernen.
• Unterdrückungen: Unterdrückungslisteneinträge einzeln oder in Stapeln auflisten, abrufen, hinzufügen und entfernen. Harte Abweisungen und Spam-Beschwerden werden automatisch unterdrückt; füge Adressen manuell hinzu, um Nicht-Kontakt-Anfragen zu respektieren.
• 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 und deren Zustellverlauf überprüfen – die an einen Webhook gesendeten Ereignisse, die Nutzlast eines Ereignisses und die Versuche, es zuzustellen. Ein Ereignis erneut abspielen, um eine weitere Zustellung in die Warteschlange zu stellen, und das Signing-Secret eines Webhooks rotieren.
• Protokolle: API-Anfrageprotokolle auflisten und überprüfen, einschließlich vollständiger Anfrage- und Antworttexte.
• Nutzung: Kontobezogene Nutzungs- und Kontingentinformationen abrufen: E-Mails, Kontakte, Segmente, Broadcasts, KI-Guthaben, Automatisierungsläufe, Domains und das API-Ratenlimit.
• Editor: Verbinde dich mit dem visuellen Editor im Resend-Dashboard (und trenne dich davon) und lies den Inhalt eines Entwurfs, während du an Broadcasts und Vorlagen zusammenarbeitest.

Lokale Entwicklung

1. Klone dieses Projekt und baue es:

git clone https://github.com/resend/resend-mcp.git
pnpm install
pnpm run build

2. Um den lokalen Build zu verwenden, ersetze den npx-Befehl durch den Pfad zu deinem 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 kannst du Änderungen in einer echten MCP-Client-Sitzung testen, während du Code in einem anderen Editor bearbeitest.

Die Idee: Führe tsc --watch aus, um dist/ kontinuierlich neu zu erstellen, und richte einen separaten MCP-Client auf das erstellte dist/index.js aus einem anderen Verzeichnis. Wenn du Codeänderungen übernehmen möchtest, starte die MCP-Client-Sitzung neu (MCP-Server sind langlebige stdio-Prozesse, die kein Hot-Reload unterstützen).

Beispiel mit Claude Code:

1. Führe den TypeScript-Watcher aus, um beim Speichern automatisch neu zu erstellen:

   pnpm tsc --watch
   

2. Erstelle in einem separaten Verzeichnis eine .mcp.json, die auf die Build-Ausgabe zeigt:

   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. Starte Claude Code aus diesem Verzeichnis und verwende die MCP-Tools. Starte nach Codeänderungen eine neue Claude-Code-Sitzung, um den neuen Build zu übernehmen.

Das gleiche Prinzip gilt für jeden MCP-Client – trenne deine Testumgebung von deiner Entwicklungsumgebung, verwende einen absoluten Pfad zu dist/index.js und verbinde den MCP-Server nach dem Neuerstellen neu.

Testen mit MCP Inspector

Hinweis: Stelle sicher, dass du das Projekt zuerst erstellt hast (siehe Abschnitt Lokale Entwicklung oben).

Verwendung des Stdio-Transports

1. Setze deinen API-Schlüssel:

   export RESEND_API_KEY=re_your_key_here
   

2. Starte den Inspector:

   pnpm inspector
   

3. Im Browser (Inspector-UI):

   • Wähle stdio (Prozess starten).
   • Befehl: node
   • Argumente: dist/index.js (oder den vollständigen Pfad zu dist/index.js)
   • Env: RESEND_API_KEY=re_your_key_here (oder leer lassen, wenn du es bereits im selben Terminal exportiert hast).
   • Klicke auf Verbinden und verwende dann „Tools auflisten", um zu überprüfen, ob der Server funktioniert.

Verwendung des HTTP-Transports

1. Starte den HTTP-Server in einem Terminal:

   node dist/index.js --http --port 3000
   

2. Starte den Inspector in einem anderen Terminal:

   pnpm inspector
   

3. Im Browser (Inspector-UI):

   • Wähle Streamable HTTP (mit URL verbinden).
   • URL: http://127.0.0.1:3000/mcp
   • Füge einen benutzerdefinierten Header hinzu: Authorization: Bearer re_your_key_here und aktiviere den Umschalter.
   • Klicke auf Verbinden und verwende dann „Tools auflisten", um zu überprüfen, ob der Server funktioniert.