resend-mcp lets an agent send and manage Resend email

Two servers, one codebase

Resend hosts an MCP server at a fixed URL, and the same code is published on npm as resend-mcp for you to run yourself.

https://mcp.resend.com/mcp

The README states plainly that the hosted server runs the same open-source code that is available on npm, so the choice between the two is a deployment decision rather than a feature decision. The hosted server is described as the best option for web-based clients like Claude and hosted agent platforms, because there is nothing to install and no local process to run, and the client opens a browser window to log in to Resend and approve access using OAuth. The local package exists for the opposite case, where you want the process on your own machine or your own infrastructure, and it supports two transport modes, stdio as the default and HTTP. The package manifest backs this up: the bin entry is resend-mcp pointing at dist/index.js, the main entry is dist/server.js with types, and the exports map offers the root and a separate ./http path pointing at dist/transports/http.js. The last push to the repository was on 2026-10-16, matching the v2.27.1 release, and the licence is MIT.

Connecting the hosted server from the common clients

The hosted server is reached over Streamable HTTP, and the documentation gives a per-client recipe. In Claude Code it is a single command with the transport and the URL.

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

Then you run /mcp in Claude Code and select resend to complete the OAuth login. In Claude, whether web or desktop, the path is Settings, then Connectors, then Add custom connector, and you enter the same URL. Cursor uses the command palette, choosing Cursor Settings, then MCP, then Add new global MCP server, and the configuration is a URL under a server name.

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

Codex takes it as a command with a URL flag.

codex mcp add resend --url https://mcp.resend.com/mcp

GitHub Copilot in VS Code expects a different shape, with the server type declared as http under an mcp servers key.

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

Windsurf uses a serverUrl key, and Warp adds the server under Agents, then MCP servers, with a +Add button.

API key authentication for headless agents and CI

The OAuth flow needs a browser, which is exactly what a server, a CI job or a headless agent does not have. For those cases the documentation says to pass a Resend API key as a Bearer token instead of using OAuth. In Claude Code that is the same add command with an extra header.

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

For JSON config in Cursor, Windsurf and others, the header goes into a headers object alongside the URL.

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

This is the single most important configuration decision in the whole setup, because the key is a full account credential rather than a narrow scope. An agent that can reach the server with that key can send mail as your verified domain and read your contacts. The hosted path at least gets a human approval step in the browser. The header approach gets you a working server in a container with no human present, and the security work shifts entirely to how the key is scoped, stored and rotated.

Running the local server over stdio

The local server speaks stdio by default, and the quick setup installs it for every detected agent and editor at once.

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

The per-client recipes all take the same shape, a client command plus the npx invocation with the API key in the environment. Claude Code registers it as an MCP server with the key passed with an env flag.

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

Codex takes the same two pieces across a continuation line.

codex mcp add resend \
  --env RESEND_API_KEY=re_xxxxxxxxx \
  -- npx -y resend-mcp

Cursor, Claude Desktop, Copilot, Gemini CLI, OpenCode and Windsurf all take a JSON entry with the same three fields, a command of npx, args of -y and resend-mcp, and the key in env. The OpenCode configuration is the odd one out, using a type of local, a command array, an enabled flag and an environment object. Two of the examples add a second variable, and the Devin one is the clearest case, since it also sets SENDER_EMAIL_ADDRESS to a Resend onboarding address, which is a hint that a sender identity has to be configured somewhere for the tools to work.

HTTP transport for your own tunnel, and the port variable

The HTTP mode exists for remote or web-based integrations, for example behind your own tunnel or reverse proxy, instead of using Resend's hosted remote MCP server. You start it with the http flag and a port.

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

The server listens on 127.0.0.1 and exposes the MCP endpoint at /mcp using Streamable HTTP, and in this mode each client authenticates by passing its own Resend API key as a Bearer token in the Authorization header. A client then points at the local endpoint with that header.

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

The port can also be set through the MCP_PORT environment variable, which is the same value the .env.example file carries alongside the API key, the sender address and the reply-to addresses.

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

Note the bind address, which is loopback only. If you want this reachable from elsewhere you have to put your own proxy in front of it, and at that point you own the TLS, the authentication and the rate limiting. The HTTP transport is also exported as a module so it can be embedded in another service rather than run from the command line, and each connecting client authenticates with its own API key passed as a Bearer token, which means the embedding service becomes the thing that holds the keys.

What the tool surface actually lets an agent do

The scope is described in one sentence and it is broad. The server lets you connect your AI agent to the Resend platform to send and receive emails and manage contacts, broadcasts, domains and more, directly from any MCP client like Claude, Cursor or Claude Code. Receiving email is the capability that is easy to underrate, because a tool that reads a mailbox gives an agent the contents of whatever people write to you, which includes anything a customer attaches to a support ticket. Contacts and domains are administrative operations rather than communication, and broadcasts are the mass-send path, which is the one to think hardest about before an agent gets the keys. The repository has an email.md file at the top level, which is presumably the prompt or guidance file for the email related tools, alongside the src/ directory, tests/ and scripts/. The package depends on the official resend client at 6.34.1 along with zod for validation, the MCP SDK packages for the node, server and express transports, express 5, dotenv, and minimist for the command line parsing.

The engineering setup behind the package

The manifest describes a modern TypeScript package with a conventional toolchain. The build script compiles with tsc and then marks the output executable, and the prepare hook runs that build, so a checkout is usable directly. Linting and formatting are handled by Biome rather than the ESLint and Prettier pairing, with a lint script that runs a check across the project and a lint:fix variant. Tests run under Vitest. There is an inspector script that launches the Model Context Protocol inspector against the latest published version, which is the fastest way to see the tool list and try calls by hand. The project also uses Renovate for dependency updates, has a pnpm workspace file and a pnpm lockfile, and declares pnpm 11.2.2 as its package manager, along with a pnpm-lock.yaml. Node 22 or newer is required. The dependency on the MCP express and node packages at 2.0.0 is the notable version, since those are recent releases of the protocol SDK and the server pins them exactly rather than with a caret, which tells you the server is sensitive to the SDK's behaviour.

Editorial conclusion

Adopt resend-mcp if you already use Resend and want an agent to draft, send and manage transactional email through the same tools, since the server exposes the Resend API as MCP tools across a long list of clients. Do not adopt it if you are not on Resend, since it is a binding to one vendor's API, and do not adopt it without thinking about the blast radius, because an agent that can send email can email your customers. Verify two things before you wire it in: which transport you will use, because the hosted server authenticates through a browser OAuth flow that a headless agent or CI job cannot complete, and which credentials that agent holds, since the API key authenticates every call. The practical first step is to add the local stdio server to one client with a scoped API key, run the server with the inspector command to see the tool list, and confirm the sender address before letting an agent use it.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. Releases
5. resend/resend-mcp on GitHub