Resend Email

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

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 paquet).

Serveur MCP distant

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

https://mcp.resend.com/mcp

Connectez n'importe quel client MCP prenant en charge les serveurs distants (HTTP Streamable). 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ées.

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

Exécutez ensuite /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ù une connexion par navigateur n'est pas possible (un serveur, un CI ou un agent sans interface), 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 devrez :

• 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

Installation pour tous les agents et é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 étape par étape.

{
  "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 HTTP Streamable.

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 comme 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 les Host transférés 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 transmettre des arguments supplémentaires pour configurer le serveur local :

• --key : Votre clé API Resend (mode stdio uniquement, 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 (par défaut : stdio)
• --port : Port HTTP lors de l'utilisation de --http (par 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 (par défaut : 127.0.0.1, ou MCP_HOST). Définissez sur 0.0.0.0 pour désactiver la validation Host derrière un proxy/équilibreur de charge.
• --allowed-hosts : Liste d'autorisation 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 d'autorisation 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 à l'ensemble de la plateforme Resend via une seule intégration. 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, partager et envoyer des e-mails en lot. Récupérer les métriques de livraison et d'engagement. Prend en charge HTML, texte brut, pièces jointes (fichier local, URL ou base64), CC/CCI, réponse à, planification, balises, 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 espaces 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, dupliquer, lister, récupérer, mettre à jour et supprimer des campagnes de diffusion. Lister les liens cliqués d'une diffusion et ses destinataires par type d'événement (envoyé, livré, ouvert, cliqué, rejeté, plaintes, désabonné, supprimé). Prend en charge la planification, les espaces réservés de personnalisation et le texte d'aperçu.
• Automatisations : Créer, lister, récupérer, mettre à jour, dupliquer 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, mettre à jour 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 honorer 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, mettre à jour 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, et inspecter leur historique de livraison — les événements envoyés à un webhook, la charge utile d'un événement et les tentatives de livraison. Rejouer un événement pour mettre en file une autre livraison et faire pivoter le secret de signature d'un webhook.
• Journaux : Lister et inspecter les journaux de requêtes API, y compris les corps de requête et de réponse complets.
• Utilisation : Récupérer les informations d'utilisation et de quota au niveau du compte : e-mails, contacts, segments, diffusions, crédits IA, exécutions d'automatisation, domaines et limite de débit API.
• Éditeur : Se connecter (et se déconnecter) à l'éditeur visuel du tableau de bord Resend et lire le contenu d'un brouillon lors de la 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 vers 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 les modifications dans une session client MCP réelle 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. Lorsque vous souhaitez récupérer les modifications de code, redémarrez la session client MCP (les serveurs MCP sont des processus stdio de longue durée qui ne se rechargent pas à chaud).

Exemple avec Claude Code :

1. Exécutez le watcher TypeScript pour recompiler automatiquement à l'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 apporté des modifications au code, démarrez une nouvelle session Claude Code pour récupérer 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

Remarque : 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)
   • Env : 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 (se 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.