Content
# Resend MCP Server
[](https://smithery.ai/server/@resend/resend-mcp)
[](https://www.npmjs.com/package/resend-mcp)
An MCP server for the [Resend](https://resend.com/) 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.
- **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](https://resend.com/api-keys). To send to addresses outside of your own, you'll need to [verify your domain](https://resend.com/domains).
## Usage
The server supports two transport modes: **stdio** (default) and **HTTP**.
### Stdio Transport (Default)
#### Claude Code
```bash
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".
```json
{
"mcpServers": {
"resend": {
"command": "npx",
"args": ["-y", "resend-mcp"],
"env": {
"RESEND_API_KEY": "re_xxxxxxxxx"
}
}
}
}
```
#### Claude Desktop
Open Claude Desktop settings > "Developer" tab > "Edit Config".
```json
{
"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:
```bash
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
```bash
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".
```json
{
"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:
```bash
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:
```
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):**
```bash
claude mcp add resend -e RESEND_API_KEY=re_xxxxxxxxx -- node ABSOLUTE_PATH_TO_PROJECT/dist/index.js
```
**Claude Code (HTTP):**
```bash
claude mcp add resend --transport http http://127.0.0.1:3000/mcp --header "Authorization: Bearer re_xxxxxxxxx"
```
**Cursor / Claude Desktop (stdio):**
```json
{
"mcpServers": {
"resend": {
"command": "node",
"args": ["ABSOLUTE_PATH_TO_PROJECT/dist/index.js"],
"env": {
"RESEND_API_KEY": "re_xxxxxxxxx"
}
}
}
}
```
**Cursor (HTTP):**
```json
{
"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
```
2. 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"
}
}
}
}
```
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](#local-development) section above).
#### Using Stdio Transport
1. Set your API key:
```bash
export RESEND_API_KEY=re_your_key_here
```
2. Start the inspector:
```bash
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:
```bash
node dist/index.js --http --port 3000
```
2. Start the inspector in another terminal:
```bash
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.
