Resend Mcp

Resend MCP Server

[](https://smithery.ai/server/@resend/resend-mcp) [](https://www.npmjs.com/package/resend-mcp)

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:

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

Cursor

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

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

Claude Desktop

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

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

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

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

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

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

Use as a library

The HTTP transport is also exported so it can be embedded in another service instead of being run via the CLI. Each connecting client authenticates with its own Resend API key passed as a Bearer token.

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

By default the server applies localhost-only Host validation (DNS-rebinding protection). When deploying behind a reverse proxy or load balancer — where the server is protected by the per-request Bearer API key — set host to 0.0.0.0 so the proxy's forwarded Host and load-balancer health checks aren't rejected with 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 the CLI this maps to --host / --allowed-hosts (or MCP_HOST / MCP_ALLOWED_HOSTS).

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)
• --host: Host for DNS-rebinding protection when using --http (default: 127.0.0.1, or MCP_HOST). Set to 0.0.0.0 to disable Host validation behind a proxy/load balancer.
• --allowed-hosts: Comma-separated Host allow-list when using --http (or MCP_ALLOWED_HOSTS)

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)
• MCP_HOST: Host for DNS-rebinding protection when using --http (optional)
• MCP_ALLOWED_HOSTS: Comma-separated Host allow-list 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:

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

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

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

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:

``bash pnpm tsc --watch ``

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

``bash mkdir -p /tmp/mcp-test ``

``json // /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" } } } } ``

1. 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](#local-development) section above).

Using Stdio Transport

1. Set your API key:

``bash export RESEND_API_KEY=re_your_key_here ``

1. Start the inspector:

``bash pnpm inspector ``

1. 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:

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

1. Start the inspector in another terminal:

``bash pnpm inspector ``

1. 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.

Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

• Author: resend
• Source: resend/resend-mcp
• License: MIT

Install and usage instructions live in the source repository linked above.