Resend Email

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 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

Verbinde jeden MCP-Client, der Remote-Server unterstützt (Streamable HTTP). Es muss nichts installiert und kein lokaler Prozess ausgeführt werden – das macht ihn zur besten Option für webbasierte Clients wie Claude und gehostete Agent-Plattformen.

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, 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 Settings" > „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 Agents > 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), übergib 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:

• Erstelle einen API-Schlüssel
• Verifiziere deine Domain

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)

Schnellinstallation

Installiere 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 Settings" > „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 „Developer" > „Config 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 Benutzerdefinierten MCP hinzufügen. Die vollständige Schritt-für-Schritt-Anleitung findest du in der Devin-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 den von Resend 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 mit 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 Settings" > „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 Host-Validierung nur für Localhost an (DNS-Rebinding-Schutz). Wenn du hinter einem Reverse-Proxy oder Load-Balancer bereitstellst, wo der Server durch den Bearer-API-Schlüssel pro Anfrage geschützt ist, setze host auf 0.0.0.0, damit die weitergeleiteten Host des Proxys und die Health-Checks des Load-Balancers 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 vom Client verwendet)
• --sender: Standard-Absender-E-Mail-Adresse von einer verifizierten Domain
• --reply-to: Standard-Antwort-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 den 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-E-Mail-Adressen (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: Kommagetrennte Host-Zulassungsliste bei Verwendung von --http (optional)

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

MCP-Server-Tools

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

• E-Mails: E-Mails senden, auflisten, abrufen, stornieren, aktualisieren und in Stapeln senden. 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. Empfangene E-Mail-Anhänge 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, auflisten, abrufen, aktualisieren und entfernen. Unterstützt Zeitplanung, Personalisierungs-Platzhalter und Vorschautext.
• Automatisierungen: Automatisierungen erstellen, auflisten, abrufen, aktualisieren 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 und entfernen.
• Unterdrückungen: Einträge in Unterdrückungslisten auflisten, abrufen, hinzufügen und entfernen, einzeln oder in Stapeln. Harte Bounces und Spam-Beschwerden werden automatisch unterdrückt; füge Adressen manuell hinzu, um Kontaktverbotsanfragen zu berücksichtigen.
• Themen: Abonnement-Themen erstellen, auflisten, abrufen, aktualisieren und entfernen.
• Kontakteigenschaften: Benutzerdefinierte Kontaktattribute erstellen, auflisten, abrufen, aktualisieren und entfernen.
• API-Schlüssel: API-Schlüssel erstellen, auflisten und entfernen.
• Webhooks: Webhooks für Ereignisbenachrichtigungen erstellen, auflisten, abrufen, aktualisieren und entfernen.
• Protokolle: API-Anfrageprotokolle auflisten und prüfen, einschließlich vollständiger Anfrage- und Antworttexte.
• Editor: Verbinde dich mit dem visuellen Editor im Resend-Dashboard (und trenne dich), 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 in einer anderen Code 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 dem MCP-Inspector

Hinweis: Stelle sicher, dass du das Projekt zuerst gebaut 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 „List tools", 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 Schalter.
   • Klicke auf Verbinden und verwende dann „List tools", um zu überprüfen, ob der Server funktioniert.