Resend MCP Server

An MCP server for the Resend platform. Send and receive emails, manage contacts, broadcasts, domains, and more — directly from any MCP client like Claude Desktop, Cursor, or Claude Code.

Features

• Emails — Send, list, get, cancel, update, and batch send emails. Supports HTML, plain text, attachments (local file, URL, or base64), CC/BCC, reply-to, scheduling, tags, and topic-based sending.
• Received Emails — List and read inbound emails. List and download received email attachments.
• Contacts — Create, list, get, update, and remove contacts. Manage segment memberships and topic subscriptions. Supports custom contact properties.
• Broadcasts — Create, send, list, get, update, and remove broadcast campaigns. Supports scheduling, personalization placeholders, and preview text.
• Templates — Create, list, get, update, publish, duplicate, and remove reusable email templates.
• Visual Editor — Compose broadcast and template content that renders live in the Resend dashboard. Agents appear as a named avatar in the editor while working.
• Domains — Create, list, get, update, remove, and verify sender domains. Configure tracking, TLS, and sending/receiving capabilities.
• Segments — Create, list, get, and remove audience segments.
• Topics — Create, list, get, update, and remove subscription topics.
• Contact Properties — Create, list, get, update, and remove custom contact attributes.
• API Keys — Create, list, and remove API keys.
• Webhooks — Create, list, get, update, and remove webhooks for event notifications.

Setup

Create a free Resend account and create an API key. To send to addresses outside of your own, you'll need to verify your domain.

Usage

The server supports two transport modes: stdio (default) and HTTP.

Stdio Transport (Default)

Quick Setup

Install for all detected/selected agents and editors:

bashCopy code
npx add-mcp resend-mcp --name resend --env "RESEND_API_KEY=re_xxxxxxxxx"

Claude Code

bashCopy code
claude mcp add resend -e RESEND_API_KEY=re_xxxxxxxxx -- npx -y resend-mcp

Cursor

Open the command palette and choose "Cursor Settings" > "MCP" > "Add new global MCP server".

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

Claude Desktop

Open Claude Desktop settings > "Developer" tab > "Edit Config".

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

HTTP Transport

Run the server over HTTP for remote or web-based integrations. In HTTP mode, each client authenticates by passing their Resend API key as a Bearer token in the Authorization header.

Start the server:

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

The server will listen on http://127.0.0.1:3000 and expose the MCP endpoint at /mcp using Streamable HTTP.

Claude Code

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

Cursor

Open the command palette and choose "Cursor Settings" > "MCP" > "Add new global MCP server".

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

You can also set the port via the MCP_PORT environment variable:

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

Options

You can pass additional arguments to configure the server:

• --key: Your Resend API key (stdio mode only; HTTP mode uses the Bearer token from the client)
• --sender: Default sender email address from a verified domain
• --reply-to: Default reply-to email address (can be specified multiple times)
• --http: Use HTTP transport instead of stdio (default: stdio)
• --port: HTTP port when using --http (default: 3000, or MCP_PORT env var)

Environment variables:

• RESEND_API_KEY: Your Resend API key (required for stdio, optional for HTTP since clients pass it via Bearer token)
• SENDER_EMAIL_ADDRESS: Default sender email address from a verified domain (optional)
• REPLY_TO_EMAIL_ADDRESSES: Comma-separated reply-to email addresses (optional)
• MCP_PORT: HTTP port when using --http (optional)

[!NOTE] If you don't provide a sender email address, the MCP server will ask you to provide one each time you call the tool.

Local Development

1. Clone this project and build:

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

2. To use the local build, replace the npx command with the path to your local build:

Claude Code (stdio):

bashCopy code
claude mcp add resend -e RESEND_API_KEY=re_xxxxxxxxx -- node ABSOLUTE_PATH_TO_PROJECT/dist/index.js

Claude Code (HTTP):

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

Cursor / Claude Desktop (stdio):

jsonCopy code
{
  "mcpServers": {
    "resend": {
      "command": "node",
      "args": ["ABSOLUTE_PATH_TO_PROJECT/dist/index.js"],
      "env": {
        "RESEND_API_KEY": "re_xxxxxxxxx"
      }
    }
  }
}

Cursor (HTTP):

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

Live Testing with an MCP Client

When developing, you can test changes in a real MCP client session while editing code in another.

The idea: run tsc --watch to continuously rebuild dist/, and point a separate MCP client at the built dist/index.js from a different directory. When you want to pick up code changes, restart the MCP client session (MCP servers are long-lived stdio processes that don't hot-reload).

Example with Claude Code:

1. Run the TypeScript watcher to auto-rebuild on save:

   bashCopy code
   pnpm tsc --watch
   

2. In a separate directory, create a .mcp.json pointing at the build output:

   bashCopy code
   mkdir -p /tmp/mcp-test
   

   jsonCopy code
   // /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. Start Claude Code from that directory and use the MCP tools. After making code changes, start a new Claude Code session to pick up the new build.

The same principle applies to any MCP client — separate your test environment from your dev environment, use an absolute path to dist/index.js, and reconnect the MCP server after rebuilding.

Testing with MCP Inspector

Note: Make sure you've built the project first (see Local Development section above).

Using Stdio Transport

1. Set your API key:

   bashCopy code
   export RESEND_API_KEY=re_your_key_here
   

2. Start the inspector:

   bashCopy code
   pnpm inspector
   

3. In the browser (Inspector UI):

   • Choose stdio (launch a process).
   • Command: node
   • Args: dist/index.js (or the full path to dist/index.js)
   • Env: RESEND_API_KEY=re_your_key_here (or leave blank if you already exported it in the same terminal).
   • Click Connect, then use "List tools" to verify the server is working.

Using HTTP Transport

1. Start the HTTP server in one terminal:

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

2. Start the inspector in another terminal:

   bashCopy code
   pnpm inspector
   

3. In the browser (Inspector UI):

   • Choose Streamable HTTP (connect to URL).
   • URL: http://127.0.0.1:3000/mcp
   • Add a custom header: Authorization: Bearer re_your_key_here and activate the toggle.
   • Click Connect, then use "List tools" to verify the server is working.