Resend Email

Resend Email MCP-Server

Verbinden Sie Ihren KI-Agenten mit der Resend-Plattform. Senden und empfangen Sie E-Mails, verwalten Sie Kontakte, Broadcasts, Domains und mehr – direkt von 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

Verbinden Sie jeden MCP-Client, der Remote-Server unterstützt (Streamable HTTP). Es gibt nichts zu installieren und keinen lokalen Prozess auszuführen, was es zur besten Option für webbasierte Clients wie Claude und gehostete Agentenplattformen macht.

Wenn Sie sich verbinden, öffnet Ihr Client ein Browserfenster, um sich bei Resend anzumelden und den Zugriff mittels OAuth zu genehmigen.

Claude Code

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

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

Claude

Öffnen Sie in Claude (Web oder Desktop) Einstellungen > Konnektoren > Benutzerdefinierten Konnektor hinzufügen und geben Sie ein:

https://mcp.resend.com/mcp

Cursor

Öffnen Sie die Befehlspalette und wählen Sie „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ü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 Agenten > MCP-Server und klicken Sie auf +Hinzufügen, um einen neuen Server hinzuzufügen.

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

Authentifizierung mit einem API-Schlüssel

Wenn Ihr Client in einer Umgebung läuft, in der eine Browser-Anmeldung nicht möglich ist (ein Server, CI oder ein headless Agent), übergeben Sie 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ü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 betreiben möchten, können Sie ihn mit npx in jeden unterstützten MCP-Client integrieren. Sie müssen:

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

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)

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

Öffnen Sie die Befehlspalette und wählen Sie „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

Öffnen Sie 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ü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

Zur opencode.json-Konfiguration hinzufügen:

{
  "$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 Einstellungen > Verbindungen > MCP-Server und klicken Sie auf Benutzerdefiniertes MCP hinzufügen. 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 Ihrem 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 mittels 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-Einstellungen“ > „MCP“ > „Neuen globalen MCP-Server hinzufügen“.

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

Verwendung als Bibliothek

Der HTTP-Transport wird auch 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). Bei der Bereitstellung hinter einem Reverse-Proxy oder Load-Balancer, wo der Server durch den Bearer-API-Schlüssel pro Anfrage geschützt ist, setzen Sie host auf 0.0.0.0, damit der weitergeleitete Host des Proxys und die Load-Balancer-Health-Checks 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

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

• --key: Ihr Resend-API-Schlüssel (nur 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-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). 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)

Umgebungsvariablen:

• RESEND_API_KEY: Ihr Resend-API-Schlüssel (erforderlich für stdio, optional für HTTP, da Clients ihn über Bearer-Token übergeben)
• SENDER_EMAIL_ADDRESS: Standard-Absender-E-Mail-Adresse von einer verifizierten Domain (optional)
• REPLY_TO_EMAIL_ADDRESSES: Durch Kommas getrennte 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: Durch Kommas getrennte Host-Zulassungsliste bei Verwendung von --http (optional)

[!NOTE] Wenn Sie keine Absender-E-Mail-Adresse angeben, werden Sie vom MCP-Server bei jedem Aufruf des Tools aufgefordert, eine anzugeben.

MCP-Server-Tools

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

• E-Mails: Senden, auflisten, abrufen, stornieren, aktualisieren und Batch-Versand von E-Mails. Unterstützt HTML, Klartext, Anhänge (lokale Datei, URL oder base64), CC/BCC, Antwort-an, Planung, 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}}}-Platzhaltern.
• Kontakte: Kontakte erstellen, auflisten, abrufen, aktualisieren und entfernen. Segmentmitgliedschaften, Themenabonnements und CSV-Kontaktimporte verwalten. Unterstützt benutzerdefinierte Kontakteigenschaften.
• Broadcasts: Broadcast-Kampagnen erstellen, senden, auflisten, abrufen, aktualisieren und entfernen. Unterstützt Planung, Personalisierungsplatzhalter und Vorschautext.
• Automatisierungen: Automatisierungen erstellen, auflisten, abrufen, aktualisieren und entfernen. Die Durchläufe 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 und Sende-/Empfangsfunktionen konfigurieren. Domainansprüche erstellen und verifizieren.
• Segmente: Zielgruppensegmente erstellen, auflisten, abrufen und entfernen.
• Unterdrückungen: Einträge der Unterdrückungsliste einzeln oder im Batch auflisten, abrufen, hinzufügen und entfernen. Harte Bounces und Spam-Beschwerden werden automatisch unterdrückt; fügen Sie Adressen manuell hinzu, um Kontaktverbotsanfragen 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 und entfernen.
• Webhooks: Webhooks für Ereignisbenachrichtigungen erstellen, auflisten, abrufen, aktualisieren und entfernen.
• Protokolle: API-Anforderungsprotokolle auflisten und überprüfen, einschließlich vollständiger Anforderungs- und Antworttexte.
• Editor: Mit dem visuellen Editor im Resend-Dashboard verbinden (und die Verbindung trennen) und den Inhalt eines Entwurfs lesen, während Sie an Broadcasts und Vorlagen zusammenarbeiten.

Lokale Entwicklung

1. Klonen Sie dieses Projekt und erstellen Sie es:

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

2. 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, während Sie Code in einer anderen bearbeiten.

Die Idee: Führen Sie tsc --watch aus, um dist/ kontinuierlich neu zu erstellen, und verweisen Sie einen separaten MCP-Client aus einem anderen Verzeichnis auf die erstellte dist/index.js. Wenn Sie Codeänderungen übernehmen möchten, starten Sie die MCP-Client-Sitzung neu (MCP-Server sind langlebige stdio-Prozesse, die kein Hot-Reload durchführen).

Beispiel mit Claude Code:

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

   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. Nachdem Sie Codeänderungen vorgenommen haben, starten Sie eine neue Claude Code-Sitzung, um den neuen Build zu übernehmen.

Das gleiche 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).

Verwendung des Stdio-Transports

1. Setzen Sie Ihren API-Schlüssel:

   export RESEND_API_KEY=re_your_key_here
   

2. Starten Sie den Inspector:

   pnpm inspector
   

3. Im Browser (Inspector-Benutzeroberfläche):

   • 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 ihn bereits im selben Terminal exportiert haben).
   • Klicken Sie auf Verbinden und verwenden Sie dann „Tools auflisten“, um zu überprüfen, ob der Server funktioniert.

Verwendung des HTTP-Transports

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-Benutzeroberfläche):

   • 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 Verbinden und verwenden Sie dann „Tools auflisten“, um zu überprüfen, ob der Server funktioniert.