Resend Email

Serveur MCP Resend

Connectez votre agent IA à la plateforme Resend. Envoyez et recevez des e-mails, gérez les contacts, les diffusions, les domaines, et plus encore, directement depuis n'importe quel client MCP comme Claude, Cursor ou Claude Code.

Nous proposons à la fois un serveur MCP distant hébergé par Resend et un serveur MCP local (ce package).

Serveur MCP distant

Resend héberge le serveur MCP à l'adresse :

https://mcp.resend.com/mcp

Connectez n'importe quel client MCP compatible avec les serveurs distants (Streamable HTTP). Rien à installer et aucun processus local à exécuter, ce qui en fait la meilleure option pour les clients Web comme Claude et les plateformes d'agents hébergés.

Lors de la connexion, votre client ouvre une fenêtre de navigateur pour vous connecter à Resend et approuver l'accès via OAuth.

Claude Code

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

Ensuite, exécutez /mcp dans Claude Code et sélectionnez resend pour terminer la connexion OAuth.

Claude

Dans Claude (Web ou bureau), ouvrez Paramètres > Connecteurs > Ajouter un connecteur personnalisé et saisissez :

https://mcp.resend.com/mcp

Cursor

Ouvrez la palette de commandes et choisissez « 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

Pour utiliser GitHub Copilot dans VS Code, ajoutez ce qui suit à votre settings.json :

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

Windsurf

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

Warp

Dans les paramètres de Warp, accédez à Agents > MCP servers, puis cliquez sur +Add pour ajouter un nouveau serveur.

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

Authentification avec une clé API

Si votre client s'exécute dans un environnement où la connexion via navigateur n'est pas possible (un serveur, CI ou un agent headless), transmettez une clé API Resend comme jeton Bearer au lieu d'utiliser OAuth.

Claude Code :

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

Configuration JSON (Cursor, Windsurf, et autres), ajoutez un en-tête Authorization :

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

Serveur MCP local

Le serveur hébergé exécute le même code open source disponible sur NPM sous le nom resend-mcp. Si vous préférez exécuter le serveur vous-même, vous pouvez l'intégrer à n'importe quel client MCP pris en charge en utilisant npx. Vous aurez besoin de :

• Créer une clé API
• Vérifier votre domaine

Le serveur local prend en charge deux modes de transport : stdio (par défaut) et HTTP.

Choisissez votre mode et votre client préférés ci-dessous pour commencer. N'oubliez pas de remplacer re_xxxxxxxxx par votre clé API réelle.

Transport Stdio (par défaut)

Configuration rapide

Installez pour tous les agents/éditeurs détectés/sélectionnés :

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

Ouvrez la palette de commandes et choisissez « Cursor Settings » > « MCP » > « Add new global MCP server ».

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

Claude Desktop

Ouvrez les paramètres de Claude Desktop > onglet « Developer » > « Edit Config ».

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

Copilot

Pour utiliser GitHub Copilot dans VS Code, ajoutez ce qui suit à votre settings.json :

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

Ajoutez à votre configuration opencode.json :

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

Dans Devin, ouvrez Paramètres > Connexions > Serveurs MCP et cliquez sur Ajouter un MCP personnalisé. Consultez le guide Devin pour les instructions complètes.

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

Transport HTTP

Exécutez le serveur via HTTP pour les intégrations distantes ou Web, par exemple derrière votre propre tunnel ou proxy inverse, au lieu d'utiliser le serveur MCP distant hébergé de Resend. En mode HTTP, chaque client s'authentifie en transmettant sa clé API Resend comme jeton Bearer dans l'en-tête Authorization.

Démarrez le serveur :

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

Le serveur écoutera sur http://127.0.0.1:3000 et exposera le point de terminaison MCP à /mcp en utilisant Streamable HTTP.

Claude Code

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

Cursor

Ouvrez la palette de commandes et choisissez « Cursor Settings » > « MCP » > « Add new global MCP server ».

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

Vous pouvez également définir le port via la variable d'environnement MCP_PORT :

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

Utilisation en tant que bibliothèque

Le transport HTTP est également exporté afin de pouvoir être intégré dans un autre service au lieu d'être exécuté via la CLI. Chaque client qui se connecte s'authentifie avec sa propre clé API Resend transmise comme jeton Bearer.

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

Par défaut, le serveur applique une validation Host limitée à localhost (protection contre le rebinding DNS). Lors du déploiement derrière un proxy inverse ou un équilibreur de charge, où le serveur est protégé par la clé API Bearer par requête, définissez host sur 0.0.0.0 afin que le Host transféré par le proxy et les vérifications de santé de l'équilibreur de charge ne soient pas rejetés avec 403 Invalid Host :

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'] });

Via la CLI, cela correspond à --host / --allowed-hosts (ou MCP_HOST / MCP_ALLOWED_HOSTS).

Options

Vous pouvez passer des arguments supplémentaires pour configurer le serveur local :

• --key : Votre clé API Resend (uniquement en mode stdio, car le mode HTTP utilise le jeton Bearer du client)
• --sender : Adresse e-mail d'expéditeur par défaut provenant d'un domaine vérifié
• --reply-to : Adresse e-mail de réponse par défaut (peut être spécifiée plusieurs fois)
• --http : Utiliser le transport HTTP au lieu de stdio (défaut : stdio)
• --port : Port HTTP lors de l'utilisation de --http (défaut : 3000, ou variable d'environnement MCP_PORT)
• --host : Hôte pour la protection contre le rebinding DNS lors de l'utilisation de --http (défaut : 127.0.0.1, ou MCP_HOST). Définissez-le sur 0.0.0.0 pour désactiver la validation Host derrière un proxy/équilibreur de charge.
• --allowed-hosts : Liste blanche Host séparée par des virgules lors de l'utilisation de --http (ou MCP_ALLOWED_HOSTS)

Variables d'environnement :

• RESEND_API_KEY : Votre clé API Resend (requise pour stdio, facultative pour HTTP car les clients la transmettent via le jeton Bearer)
• SENDER_EMAIL_ADDRESS : Adresse e-mail d'expéditeur par défaut provenant d'un domaine vérifié (facultative)
• REPLY_TO_EMAIL_ADDRESSES : Adresses e-mail de réponse séparées par des virgules (facultatives)
• MCP_PORT : Port HTTP lors de l'utilisation de --http (facultatif)
• MCP_HOST : Hôte pour la protection contre le rebinding DNS lors de l'utilisation de --http (facultatif)
• MCP_ALLOWED_HOSTS : Liste blanche Host séparée par des virgules lors de l'utilisation de --http (facultative)

[!NOTE] Si vous ne fournissez pas d'adresse e-mail d'expéditeur, le serveur MCP vous demandera d'en fournir une à chaque appel de l'outil.

Outils du serveur MCP

Le serveur MCP de Resend donne à votre agent IA un accès natif à toute la plateforme Resend via une intégration unique. Vous pouvez gérer tous les aspects de votre infrastructure e-mail en langage naturel.

• E-mails : Envoyer, lister, récupérer, annuler, mettre à jour et envoyer des e-mails en lot. Prend en charge le HTML, le texte brut, les pièces jointes (fichier local, URL ou base64), CC/Cci, réponse, planification, tags, en-têtes personnalisés, envoi basé sur des sujets et clés d'idempotence.
• E-mails reçus : Lister et lire les e-mails entrants. Lister et télécharger les pièces jointes des e-mails reçus.
• Modèles : Créer, lister, récupérer, mettre à jour, publier, dupliquer et supprimer des modèles d'e-mail. Prend en charge la composition du contenu du modèle et les emplacements réservés {{{VARIABLE}}}.
• Contacts : Créer, lister, récupérer, mettre à jour et supprimer des contacts. Gérer les adhésions aux segments, les abonnements aux sujets et les importations de contacts CSV. Prend en charge les propriétés de contact personnalisées.
• Diffusions : Créer, envoyer, annuler, lister, récupérer, mettre à jour et supprimer des campagnes de diffusion. Prend en charge la planification, les emplacements réservés de personnalisation et le texte d'aperçu.
• Automatisations : Créer, lister, récupérer, mettre à jour et supprimer des automatisations. Examiner les exécutions d'une automatisation.
• Événements : Envoyer des événements pour déclencher des automatisations pour un contact. Créer, mettre à jour et supprimer des définitions d'événements.
• Domaines : Créer, lister, récupérer, mettre à jour, supprimer et vérifier des domaines d'expéditeur. Configurer le suivi, TLS et les capacités d'envoi/réception. Créer et vérifier des revendications de domaine.
• Segments : Créer, lister, récupérer et supprimer des segments d'audience.
• Suppressions : Lister, récupérer, ajouter et supprimer des entrées de liste de suppression, individuellement ou en lot. Les rejets définitifs et les plaintes pour spam sont supprimés automatiquement ; ajoutez des adresses manuellement pour respecter les demandes de non-contact.
• Sujets : Créer, lister, récupérer, mettre à jour et supprimer des sujets d'abonnement.
• Propriétés de contact : Créer, lister, récupérer, mettre à jour et supprimer des attributs de contact personnalisés.
• Clés API : Créer, lister et supprimer des clés API.
• Webhooks : Créer, lister, récupérer, mettre à jour et supprimer des webhooks pour les notifications d'événements.
• Journaux : Lister et inspecter les journaux de requêtes API, y compris les corps de requêtes et de réponses complets.
• Éditeur : Se connecter (et se déconnecter) à l'éditeur visuel du tableau de bord Resend, et lire le contenu d'un brouillon lors d'une collaboration sur des diffusions et des modèles.

Développement local

1. Clonez ce projet et compilez :

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

2. Pour utiliser la compilation locale, remplacez la commande npx par le chemin de votre compilation locale :

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

Tests en direct avec un client MCP

Lors du développement, vous pouvez tester vos modifications dans une session réelle d'un client MCP tout en modifiant le code dans une autre.

L'idée : exécutez tsc --watch pour recompiler en continu dist/, et pointez un client MCP séparé vers le dist/index.js compilé depuis un autre répertoire. Pour prendre en compte les modifications de code, redémarrez la session du client MCP (les serveurs MCP sont des processus stdio de longue durée qui ne prennent pas en charge le rechargement à chaud).

Exemple avec Claude Code :

1. Exécutez le watcher TypeScript pour recompiler automatiquement à chaque enregistrement :

   pnpm tsc --watch
   

2. Dans un répertoire séparé, créez un .mcp.json pointant vers la sortie de compilation :

   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. Démarrez Claude Code depuis ce répertoire et utilisez les outils MCP. Après avoir modifié le code, démarrez une nouvelle session Claude Code pour prendre en compte la nouvelle compilation.

Le même principe s'applique à n'importe quel client MCP — séparez votre environnement de test de votre environnement de développement, utilisez un chemin absolu vers dist/index.js, et reconnectez le serveur MCP après la recompilation.

Tests avec MCP Inspector

Note : Assurez-vous d'avoir compilé le projet d'abord (voir la section Développement local ci-dessus).

Utilisation du transport Stdio

1. Définissez votre clé API :

   export RESEND_API_KEY=re_your_key_here
   

2. Démarrez l'inspecteur :

   pnpm inspector
   

3. Dans le navigateur (interface Inspector) :

   • Choisissez stdio (lancer un processus).
   • Commande : node
   • Arguments : dist/index.js (ou le chemin complet vers dist/index.js)
   • Environnement : RESEND_API_KEY=re_your_key_here (ou laissez vide si vous l'avez déjà exporté dans le même terminal).
   • Cliquez sur Connect, puis utilisez « List tools » pour vérifier que le serveur fonctionne.

Utilisation du transport HTTP

1. Démarrez le serveur HTTP dans un terminal :

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

2. Démarrez l'inspecteur dans un autre terminal :

   pnpm inspector
   

3. Dans le navigateur (interface Inspector) :

   • Choisissez Streamable HTTP (connecter à une URL).
   • URL : http://127.0.0.1:3000/mcp
   • Ajoutez un en-tête personnalisé : Authorization: Bearer re_your_key_here et activez la bascule.
   • Cliquez sur Connect, puis utilisez « List tools » pour vérifier que le serveur fonctionne.