How do I install Resend?

Copy the stdio config for Cursor, Claude Desktop, Claude Code, or VS Code on this page. It uses the publisher's install, not a PlugMCP proxy.

Does Resend need an API key?

No required environment variable is listed on this record.

What transport does Resend use?

Resend runs locally over stdio.

When was Resend last checked?

Last checked 2026-11-05. The official MCP server to send emails and interact with Resend

Resend MCP sunucusu

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:

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": "[email protected]"
      }
    }
  }
}

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)
--allowed-file-dirs: Comma-separated directories that local file attachments and CSV imports may be read from (or MCP_ALLOWED_FILE_DIRS). Unrestricted on stdio when unset; always disabled over --http unless set.

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)
MCP_ALLOWED_FILE_DIRS: Comma-separated directories local files may be read from (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.

[!WARNING] send-email (attachments[].filePath) and create-contact-import (filePath) read local files. Over --http this is disabled by default so remote clients can't read the server's disk; use --allowed-file-dirs to opt in for specific directories. On stdio, set --allowed-file-dirs to stop a prompt-injected agent from attaching files outside the folders you choose.

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.
Inboxes: Create, list, get, update, and remove inboxes. Read and update the inbox agent settings. List, search, get, update, and remove threads, and add, set, or remove their labels. List and get thread emails, and reply to or forward them with attachments and custom headers. Create, list, update, and remove labels. Create, list, get, update, remove, and send drafts, with attachments. Send a new email from an inbox to start a thread. Supports idempotency keys when replying, forwarding, creating drafts, sending drafts, and sending new emails.
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, duplicate, 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. Replay an event to queue another delivery, and rotate a webhook's signing secret.

Local Development

Clone this project and build:

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

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:

Run the TypeScript watcher to auto-rebuild on save:
```
pnpm tsc --watch
```

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

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

Set your API key:
```
export RESEND_API_KEY=re_your_key_here
```
Start the inspector:
```
pnpm inspector
```
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

Start the HTTP server in one terminal:
```
node dist/index.js --http --port 3000
```
Start the inspector in another terminal:
```
pnpm inspector
```
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.

Bu sunucuyu ekle

Host a copy with our keys and logs.

Server facts

Tools

Questions

How do I install Resend?

Does Resend need an API key?

What transport does Resend use?

When was Resend last checked?

Documentation

Resend MCP Server

Remote MCP Server

Claude Code

Claude

Cursor

Codex

Copilot

Windsurf

Warp

Authenticating with an API key

Local MCP Server

Stdio Transport (Default)

Quick Setup

Claude Code

Codex

Cursor

Claude Desktop

Copilot

Gemini CLI

OpenCode

Windsurf

Devin

HTTP Transport

Claude Code

Cursor

Use as a library

Options

MCP Server Tools

Local Development

Live Testing with an MCP Client

Testing with MCP Inspector

Using Stdio Transport

Using HTTP Transport