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 bien plus, 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 suivante :

https://mcp.resend.com/mcp

Connectez n'importe quel client MCP prenant en charge les serveurs distants (HTTP Streamable). Il n'y a rien à installer ni de 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.

Lorsque vous vous connectez, 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 « Paramètres Cursor » > « MCP » > « Ajouter un nouveau serveur MCP global ».

{
  "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 > Serveurs MCP, puis cliquez sur +Ajouter 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 par navigateur est impossible (un serveur, CI ou un agent sans interface graphique), transmettez une clé API Resend en tant que 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

Installez 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 « Paramètres Cursor » > « MCP » > « Ajouter un nouveau serveur MCP global ».

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

Claude Desktop

Ouvrez les paramètres de Claude Desktop > onglet « Développeur » > « Modifier la configuration ».

{
  "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 étapes détaillées.

{
  "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é par Resend. En mode HTTP, chaque client s'authentifie en transmettant sa clé API Resend en tant que 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 « Paramètres Cursor » > « MCP » > « Ajouter un nouveau serveur MCP global ».

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

Utiliser 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 en tant que 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 l'en-tête Host transmis 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 (mode stdio uniquement, car le mode HTTP utilise le jeton Bearer du client)
• --sender : Adresse e-mail d'expéditeur par défaut 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'env 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 variable d'env 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 (obligatoire 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 d'un domaine vérifié (facultatif)
• REPLY_TO_EMAIL_ADDRESSES : Adresses e-mail de réponse séparées par des virgules (facultatif)
• 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 (facultatif)

[!REMARQUE] Si vous ne fournissez pas d'adresse e-mail d'expéditeur, le serveur MCP vous demandera d'en fournir une à chaque fois que vous appellerez 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 d'e-mails en utilisant le langage naturel.

• E-mails : Envoyer, lister, obtenir, annuler, mettre à jour et envoyer des e-mails par lots. Prend en charge HTML, texte brut, pièces jointes (fichier local, URL ou base64), CC/BCC, réponse, planification, balises, en-têtes personnalisés, envoi par sujet 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, obtenir, mettre à jour, publier, dupliquer et supprimer des modèles d'e-mails. Prend en charge la composition du contenu du modèle et les espaces réservés {{{VARIABLE}}}.
• Contacts : Créer, lister, obtenir, mettre à jour et supprimer des contacts. Gérer les appartenances 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, lister, obtenir, mettre à jour et supprimer des campagnes de diffusion. Prend en charge la planification, les espaces réservés de personnalisation et le texte d'aperçu.
• Automatisations : Créer, lister, obtenir, 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, obtenir, mettre à jour, supprimer et vérifier les domaines d'expéditeur. Configurer le suivi, TLS et les capacités d'envoi/réception. Créer et vérifier les revendications de domaine.
• Segments : Créer, lister, obtenir et supprimer des segments d'audience.
• Suppressions : Lister, obtenir, ajouter et supprimer des entrées de la liste de suppression, individuellement ou par lots. Les rebonds 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, obtenir, mettre à jour et supprimer des sujets d'abonnement.
• Propriétés de contact : Créer, lister, obtenir, 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, obtenir, 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 complets des requêtes et des réponses.
• Éditeur : Se connecter (et se déconnecter) à l'éditeur visuel dans le tableau de bord Resend, et lire le contenu d'un brouillon tout en collaborant sur les diffusions et les modèles.

Développement local

1. Clonez ce projet et construisez-le :

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

2. Pour utiliser la construction locale, remplacez la commande npx par le chemin vers votre construction 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 éditant le code dans une autre.

L'idée : exécutez tsc --watch pour reconstruire en continu dist/, et pointez un client MCP séparé vers le dist/index.js construit à partir d'un répertoire différent. Lorsque vous souhaitez 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 se rechargent pas à chaud).

Exemple avec Claude Code :

1. Exécutez l'observateur TypeScript pour reconstruire automatiquement à la sauvegarde :

   pnpm tsc --watch
   

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

   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 à partir de ce répertoire et utilisez les outils MCP. Après avoir apporté des modifications au code, démarrez une nouvelle session Claude Code pour prendre en compte la nouvelle construction.

Le même principe s'applique à tout 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 reconstruction.

Tests avec MCP Inspector

Remarque : Assurez-vous d'avoir d'abord construit le projet (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 utilisateur de l'inspecteur) :

   • Choisissez stdio (lancer un processus).
   • Commande : node
   • Args : 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ée dans le même terminal).
   • Cliquez sur Connecter, puis utilisez « Lister les outils » 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 utilisateur de l'inspecteur) :

   • Choisissez HTTP Streamable (se connecter à l'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 Connecter, puis utilisez « Lister les outils » pour vérifier que le serveur fonctionne.