Resend Email

officiel

Envoyez des e-mails directement depuis

Que pouvez-vous faire avec Resend Email MCP ?

  • Envoyer et programmer des e-mails — Demandez à votre assistant d’envoyer des e-mails HTML ou en texte brut avec des destinataires en CC/Cci, une adresse de réponse, des pièces jointes, des étiquettes et une programmation.
  • Gérer les contacts et les segments — Créez, mettez à jour et supprimez des contacts, gérez les appartenances aux segments et les abonnements aux sujets, et lancez des importations CSV.
  • Lancer des campagnes de diffusion — Créez, programmez, envoyez ou annulez des campagnes de diffusion, puis examinez les destinataires par type d’événement et les liens cliqués.
  • Gérer les e-mails entrants et les boîtes de réception — Répertoriez et lisez les e-mails reçus, téléchargez les pièces jointes et gérez les fils de discussion, les étiquettes et les brouillons des boîtes de réception.
  • Administrer les domaines et les exclusions — Créez, vérifiez et configurez des domaines d’expéditeur, et ajoutez ou supprimez des entrées de la liste d’exclusion.
  • Consulter les journaux et l’utilisation — Consultez les journaux des requêtes API avec le contenu intégral des requêtes et des réponses, et vérifiez l’utilisation et le quota du compte.

Serveur MCP hébergé

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

S’installe dans Claude Code, Codex, Cursor et plus

Documentation

Serveur MCP Resend

npm version

Connectez votre agent IA à la plateforme Resend. Envoyez et recevez des e-mails, gérez les contacts, les campagnes, les domaines et bien 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 suivante :

https://mcp.resend.com/mcp

Connectez n’importe quel client MCP prenant en charge les serveurs distants (Streamable HTTP). Rien à installer et aucun processus local à exécuter : c’est donc 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 permettre de vous connecter à Resend et d’autoriser l’accès avec 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 ordinateur), ouvrez Settings > Connectors > Add custom connector 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 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 est impossible (un serveur, une CI ou un agent sans interface graphique), 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 que celui disponible sur NPM sous la forme de 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 à l’aide de npx. Vous devrez :

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

Choisissez ci-dessous le mode et le client de votre choix pour commencer. Pensez à remplacer re_xxxxxxxxx par votre véritable clé API.

Transport Stdio (par défaut)

Configuration rapide

Installez-le pour tous les agents et éditeurs détectés ou 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 > l’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 ceci à 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 Settings > Connections > MCP Servers, puis cliquez sur Add a custom MCP. Consultez le guide Devin pour suivre 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é 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 à l’adresse /mcp avec 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 à l’aide de 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é à un autre service plutôt que 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 d’un déploiement derrière un proxy inverse ou un répartiteur de charge, où le serveur est protégé par la clé API Bearer propre à chaque requête, définissez host sur 0.0.0.0 afin que les en-têtes Host transmis par le proxy et les vérifications d’état du répartiteur 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 cette valeur sur 0.0.0.0 pour désactiver la validation Host derrière un proxy ou un répartiteur de charge.
  • --allowed-hosts : liste d’autorisation Host séparée par des virgules lors de l’utilisation de --http (ou MCP_ALLOWED_HOSTS)
  • --allowed-file-dirs : répertoires séparés par des virgules depuis lesquels les pièces jointes locales et les imports CSV peuvent être lus (ou MCP_ALLOWED_FILE_DIRS). Accès sans restriction en mode stdio si cette option n’est pas définie ; toujours désactivé via --http sauf si cette option est définie.

Variables d’environnement :

  • RESEND_API_KEY : votre clé API Resend (obligatoire en mode stdio, facultative en mode HTTP puisque les clients la transmettent via un 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 (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)
  • MCP_ALLOWED_FILE_DIRS : répertoires séparés par des virgules depuis lesquels les fichiers locaux peuvent être lus (facultatif)

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

[!WARNING] send-email (attachments[].filePath) et create-contact-import (filePath) lisent des fichiers locaux. Via --http, cette fonctionnalité est désactivée par défaut afin que les clients distants ne puissent pas lire le disque du serveur ; utilisez --allowed-file-dirs pour autoriser certains répertoires. En mode stdio, définissez --allowed-file-dirs pour empêcher un agent manipulé par injection de prompt de joindre des fichiers situés en dehors des dossiers que vous avez choisis.

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 de messagerie en langage naturel.

  • E-mails : envoyer, répertorier, consulter, annuler, mettre à jour, partager et envoyer des e-mails par lots. Récupérer les métriques de livraison et d’engagement. Prise en charge du HTML, du texte brut, des pièces jointes (fichier local, URL ou base64), des champs CC/BCC, de l’adresse de réponse, de la planification, des balises, des en-têtes personnalisés, de l’envoi par sujet et des clés d’idempotence.
  • E-mails reçus : répertorier et lire les e-mails entrants. Répertorier et télécharger les pièces jointes des e-mails reçus.
  • Boîtes de réception : créer, répertorier, consulter, mettre à jour et supprimer des boîtes de réception. Lire et mettre à jour les paramètres de l’agent de boîte de réception. Répertorier, rechercher, consulter, mettre à jour et supprimer des fils de discussion, et ajouter, définir ou supprimer leurs libellés. Répertorier et consulter les e-mails d’un fil, et y répondre ou les transférer avec des pièces jointes et des en-têtes personnalisés. Créer, répertorier, mettre à jour et supprimer des libellés. Créer, répertorier, consulter, mettre à jour, supprimer et envoyer des brouillons, avec des pièces jointes fournies en base64 ou via une URL. Envoyer un nouvel e-mail depuis une boîte de réception pour démarrer un fil de discussion. Prise en charge des clés d’idempotence pour les réponses, les transferts, la création et l’envoi de brouillons, ainsi que l’envoi de nouveaux e-mails.
  • Modèles : créer, répertorier, consulter, mettre à jour, publier, dupliquer et supprimer des modèles d’e-mail. Prise en charge de la rédaction du contenu des modèles et des espaces réservés {{{VARIABLE}}}.
  • Contacts : créer, répertorier, consulter, mettre à jour et supprimer des contacts. Gérer les appartenances aux segments, les abonnements aux sujets et les imports de contacts CSV. Prise en charge des propriétés de contact personnalisées.
  • Campagnes : créer, envoyer, annuler, dupliquer, répertorier, consulter, mettre à jour et supprimer des campagnes. Répertorier les liens cliqués d’une campagne et ses destinataires par type d’événement (envoyé, livré, ouvert, cliqué, rejeté, signalé comme indésirable, désabonné, supprimé de la liste). Prise en charge de la planification, des espaces réservés de personnalisation et du texte d’aperçu.
  • Automatisations : créer, répertorier, consulter, 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, répertorier, consulter, mettre à jour, supprimer et vérifier des domaines d’expéditeur. Configurer le suivi, TLS et les capacités d’envoi et de réception. Créer et vérifier des revendications de domaine.
  • Segments : créer, répertorier, consulter, mettre à jour et supprimer des segments d’audience.
  • Suppressions : répertorier, consulter, ajouter et supprimer des entrées de la liste de suppression, individuellement ou par lot. Les rebonds définitifs et les signalements comme indésirables sont automatiquement ajoutés à la liste de suppression ; ajoutez manuellement des adresses pour respecter les demandes de non-contact.
  • Sujets : créer, répertorier, consulter, mettre à jour et supprimer des sujets d’abonnement.
  • Propriétés des contacts : créer, répertorier, consulter, mettre à jour et supprimer des attributs de contact personnalisés.
  • Clés API : créer, répertorier, mettre à jour et supprimer des clés API.
  • Webhooks : créer, répertorier, consulter, mettre à jour et supprimer des webhooks de notification d’événements, et examiner leur historique de livraison — les événements envoyés à un webhook, la charge utile d’un événement et les tentatives de livraison. Relancer un événement pour mettre une nouvelle livraison en file d’attente et renouveler le secret de signature d’un webhook.
  • Journaux : répertorier et examiner les journaux des requêtes API, y compris le contenu intégral des requêtes et des réponses.
  • Utilisation : récupérer les informations d’utilisation et de quotas au niveau du compte : e-mails, contacts, segments, campagnes, crédits IA, exécutions d’automatisations, domaines et limite de débit de l’API.
  • Éditeur : se connecter à l’éditeur visuel du tableau de bord Resend (ou s’en déconnecter) et lire le contenu d’un brouillon tout en collaborant sur des campagnes et des modèles.

Développement local

  1. Clonez ce projet et compilez-le :
git clone https://github.com/resend/resend-mcp.git
pnpm install
pnpm run build
  1. Pour utiliser la compilation locale, remplacez la commande npx par le chemin d’accès à 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

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

Le principe : exécutez tsc --watch pour reconstruire continuellement dist/, puis configurez un client MCP distinct pour utiliser le fichier compilé dist/index.js depuis un autre répertoire. Pour prendre en compte les modifications du code, redémarrez la session du client MCP (les serveurs MCP sont des processus stdio de longue durée qui ne rechargent pas le code à chaud).

Exemple avec Claude Code :

  1. Exécutez le compilateur TypeScript en mode surveillance pour reconstruire automatiquement le projet à chaque enregistrement :

    pnpm tsc --watch
    
  2. Dans un autre répertoire, créez un fichier .mcp.json pointant vers le résultat de la 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 charger la nouvelle compilation.

Le même principe s’applique à tous les clients 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 compilation.

Tests avec MCP Inspector

Remarque : veillez à avoir d’abord compilé 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 de l’inspecteur) :

    • 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 ce champ vide si vous l’avez déjà exportée 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 de l’inspecteur) :

    • 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 le bouton bascule.
    • Cliquez sur Connect, puis utilisez « List tools » pour vérifier que le serveur fonctionne.