Resend MCP Server

Connect your AI agent to the Resend platform. Send and receive emails, manage contacts, broadcasts, domains, and more, directly from any MCP client like Claude, Cursor, or Claude Code.

We offer both a remote MCP server hosted by Resend and a local MCP server (this package).

Remote MCP Server

Resend hosts the MCP server at:

https://mcp.resend.com/mcp

Connect any MCP client that supports remote servers (Streamable HTTP). There's nothing to install and no local process to run, which makes it the best option for web-based clients like Claude and hosted agent platforms.

When you connect, your client opens a browser window to log in to Resend and approve access using OAuth.

Claude Code

claude mcp add --transport http resend https://mcp.resend.com/mcp

Then run `/mcp` in Claude Code and select resend to complete the OAuth login.

Claude

In Claude (web or desktop), open Settings > Connectors > Add custom connector and enter:

https://mcp.resend.com/mcp

Cursor

Open the command palette and choose "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

To use GitHub Copilot in VS Code, add the following to your `settings.json`:

{
  "mcp": {
    "servers": {
      "resend": {
        "type": "http",
        "url": "https://mcp.resend.com/mcp"
      }
    }
  }
}

Windsurf

{
  "mcpServers": {
    "resend": {
      "serverUrl": "https://mcp.resend.com/mcp"
    }
  }
}

Warp

In Warp's Settings, navigate to Agents > MCP servers, and click +Add to add a new server.

{
  "resend": {
    "serverUrl": "https://mcp.resend.com/mcp"
  }
}

Authenticating with an API key

If your client runs somewhere a browser login isn't possible (a server, CI, or a headless agent), pass a Resend API key as a Bearer token instead of using OAuth.

Claude Code:

claude mcp add --transport http resend https://mcp.resend.com/mcp --header "Authorization: Bearer re_xxxxxxxxx"

JSON config (Cursor, Windsurf, and others), add an `Authorization` header:

{
  "mcpServers": {
    "resend": {
      "url": "https://mcp.resend.com/mcp",
      "headers": {
        "Authorization": "Bearer re_xxxxxxxxx"
      }
    }
  }
}

Local MCP Server

The hosted server runs the same open-source code that's available on NPM as `resend-mcp`. If you prefer to run the server yourself, you can integrate it into any supported MCP client using `npx`. You'll need to:

• Create an API key
• Verify your domain

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

Choose your preferred mode and client below to get started. Remember to replace `re_xxxxxxxxx` with your actual API key.

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

Codex

codex mcp add resend \
  --env 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"
      }
    }
  }
}

Copilot

To use GitHub Copilot in VS Code, add the following to your `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

Add to your `opencode.json` config:

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

In Devin, open Settings > Connections > MCP Servers and click Add a custom MCP. See the Devin guide for the full step-by-step.

{
  "mcpServers": {
    "resend": {
      "command": "npx",
      "args": ["-y", "resend-mcp"],
      "env": {
        "RESEND_API_KEY": "re_xxxxxxxxx",
        "SENDER_EMAIL_ADDRESS": "onboarding@resend.dev"
      }
    }
  }
}

HTTP Transport

Run the server over HTTP for remote or web-based integrations, for example behind your own tunnel or reverse proxy, instead of using Resend's hosted remote MCP server. 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 local server:

• `--key`: Your Resend API key (stdio mode only, since 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.

MCP Server Tools

Resend's MCP server gives your AI agent native access to the full Resend platform through a single integration. You can manage all aspects of your email infrastructure using natural language.

• Emails: Send, list, get, cancel, update, share, and batch send emails. Retrieve delivery and engagement metrics. Supports HTML, plain text, attachments (local file, URL, or base64), CC/BCC, reply-to, scheduling, tags, custom headers, topic-based sending, and idempotency keys.
• Received Emails: List and read inbound emails. List and download received email attachments.
• Templates: Create, list, get, update, publish, duplicate, and remove email templates. Supports composing template content and `{{{VARIABLE}}}` placeholders.
• Contacts: Create, list, get, update, and remove contacts. Manage segment memberships, topic subscriptions, and CSV contact imports. Supports custom contact properties.
• Broadcasts: Create, send, cancel, list, get, update, and remove broadcast campaigns. List a broadcast's clicked links, and its recipients by event type (sent, delivered, opened, clicked, bounced, complained, unsubscribed, suppressed). Supports scheduling, personalization placeholders, and preview text.
• Automations: Create, list, get, update, duplicate, and remove automations. Review the runs of an automation.
• Events: Send events to trigger automations for a contact. Create, update, and remove event definitions.
• Domains: Create, list, get, update, remove, and verify sender domains. Configure tracking, TLS, and sending/receiving capabilities. Create and verify domain claims.
• Segments: Create, list, get, update, and remove audience segments.
• Suppressions: List, get, add, and remove suppression list entries, individually or in batch. Hard bounces and spam complaints are suppressed automatically; add addresses manually to honor do-not-contact requests.
• Topics: Create, list, get, update, and remove subscription topics.
• Contact Properties: Create, list, get, update, and remove custom contact attributes.
• API Keys: Create, list, update, and remove API keys.
• Webhooks: Create, list, get, update, and remove webhooks for event notifications, and inspect their delivery history — the events sent to a webhook, one event's payload, and the attempts made to deliver it.
• Logs: List and inspect API request logs, including full request and response bodies.
• Editor: Connect to (and disconnect from) the visual editor in the Resend dashboard, and read a draft's content while collaborating on broadcasts and templates.

Local Development

1. Clone this project and build:

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

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:

pnpm tsc --watch

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

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

export RESEND_API_KEY=re_your_key_here

2. Start the inspector:

pnpm inspector

3. In the browser (Inspector UI):

Using HTTP Transport

1. Start the HTTP server in one terminal:

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

2. Start the inspector in another terminal:

pnpm inspector

3. In the browser (Inspector UI):