Resend Email

npx add-mcp 'https://mcp.resend.com/mcp'

Servidor MCP de Resend

Conecta tu agente de IA a la plataforma Resend. Envía y recibe correos electrónicos, gestiona contactos, transmisiones, dominios y más, directamente desde cualquier cliente MCP como Claude, Cursor o Claude Code.

Ofrecemos tanto un servidor MCP remoto alojado por Resend como un servidor MCP local (este paquete).

Servidor MCP remoto

Resend aloja el servidor MCP en:

https://mcp.resend.com/mcp

Conecta cualquier cliente MCP que admita servidores remotos (HTTP Streamable). No hay nada que instalar ni ningún proceso local que ejecutar, lo que lo convierte en la mejor opción para clientes basados en web como Claude y plataformas de agentes alojadas.

Cuando te conectas, tu cliente abre una ventana del navegador para iniciar sesión en Resend y aprobar el acceso mediante OAuth.

Claude Code

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

Luego ejecuta /mcp en Claude Code y selecciona resend para completar el inicio de sesión OAuth.

Claude

En Claude (web o escritorio), abre Configuración > Conectores > Añadir conector personalizado e introduce:

https://mcp.resend.com/mcp

Cursor

Abre la paleta de comandos y elige "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

Para usar GitHub Copilot en VS Code, añade lo siguiente a tu settings.json:

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

Windsurf

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

Warp

En la configuración de Warp, navega a Agents > MCP servers y haz clic en +Add para añadir un nuevo servidor.

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

Autenticación con una clave de API

Si tu cliente se ejecuta en un lugar donde no es posible iniciar sesión en el navegador (un servidor, CI o un agente sin interfaz), pasa una clave de API de Resend como token Bearer en lugar de usar OAuth.

Claude Code:

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

Configuración JSON (Cursor, Windsurf y otros), añade un encabezado Authorization:

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

Servidor MCP local

El servidor alojado ejecuta el mismo código de código abierto disponible en NPM como resend-mcp. Si prefieres ejecutar el servidor tú mismo, puedes integrarlo en cualquier cliente MCP compatible usando npx. Necesitarás:

• Crear una clave de API
• Verificar tu dominio

El servidor local admite dos modos de transporte: stdio (predeterminado) y HTTP.

Elige tu modo y cliente preferidos a continuación para comenzar. Recuerda reemplazar re_xxxxxxxxx con tu clave de API real.

Transporte Stdio (predeterminado)

Configuración rápida

Instala para todos los agentes y editores detectados/seleccionados:

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

Abre la paleta de comandos y elige "Cursor Settings" > "MCP" > "Add new global MCP server".

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

Claude Desktop

Abre la configuración de Claude Desktop > pestaña "Developer" > "Edit Config".

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

Copilot

Para usar GitHub Copilot en VS Code, añade lo siguiente a tu 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

Añade a tu configuración de opencode.json:

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

En Devin, abre Settings > Connections > MCP Servers y haz clic en Add a custom MCP. Consulta la guía de Devin para ver los pasos completos.

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

Transporte HTTP

Ejecuta el servidor a través de HTTP para integraciones remotas o basadas en web, por ejemplo detrás de tu propio túnel o proxy inverso, en lugar de usar el servidor MCP remoto alojado de Resend. En modo HTTP, cada cliente se autentica pasando su clave de API de Resend como token Bearer en el encabezado Authorization.

Inicia el servidor:

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

El servidor escuchará en http://127.0.0.1:3000 y expondrá el endpoint MCP en /mcp usando HTTP Streamable.

Claude Code

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

Cursor

Abre la paleta de comandos y elige "Cursor Settings" > "MCP" > "Add new global MCP server".

{
  "mcpServers": {
    "resend": {
      "url": "http://127.0.0.1:3000/mcp",
      "headers": {
        "Authorization": "Bearer re_xxxxxxxxx"
      }
    }
  }
}

También puedes configurar el puerto mediante la variable de entorno MCP_PORT:

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

Uso como biblioteca

El transporte HTTP también se exporta para que pueda integrarse en otro servicio en lugar de ejecutarse mediante la CLI. Cada cliente que se conecta se autentica con su propia clave de API de Resend pasada como token Bearer.

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

De forma predeterminada, el servidor aplica la validación de Host solo para localhost (protección contra el rebinding de DNS). Al implementar detrás de un proxy inverso o balanceador de carga, donde el servidor está protegido por la clave de API Bearer por solicitud, establece host a 0.0.0.0 para que el Host reenviado por el proxy y las comprobaciones de salud del balanceador de carga no se rechacen con 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'] });

A través de la CLI, esto se asigna a --host / --allowed-hosts (o MCP_HOST / MCP_ALLOWED_HOSTS).

Opciones

Puedes pasar argumentos adicionales para configurar el servidor local:

• --key: Tu clave de API de Resend (solo modo stdio, ya que el modo HTTP usa el token Bearer del cliente)
• --sender: Dirección de correo del remitente predeterminada de un dominio verificado
• --reply-to: Dirección de correo de respuesta predeterminada (se puede especificar varias veces)
• --http: Usar transporte HTTP en lugar de stdio (predeterminado: stdio)
• --port: Puerto HTTP al usar --http (predeterminado: 3000, o variable de entorno MCP_PORT)
• --host: Host para la protección contra el rebinding de DNS al usar --http (predeterminado: 127.0.0.1, o MCP_HOST). Establécelo en 0.0.0.0 para deshabilitar la validación de Host detrás de un proxy/balanceador de carga.
• --allowed-hosts: Lista de permitidos de Host separada por comas al usar --http (o MCP_ALLOWED_HOSTS)

Variables de entorno:

• RESEND_API_KEY: Tu clave de API de Resend (requerida para stdio, opcional para HTTP ya que los clientes la pasan mediante token Bearer)
• SENDER_EMAIL_ADDRESS: Dirección de correo del remitente predeterminada de un dominio verificado (opcional)
• REPLY_TO_EMAIL_ADDRESSES: Direcciones de correo de respuesta separadas por comas (opcional)
• MCP_PORT: Puerto HTTP al usar --http (opcional)
• MCP_HOST: Host para la protección contra el rebinding de DNS al usar --http (opcional)
• MCP_ALLOWED_HOSTS: Lista de permitidos de Host separada por comas al usar --http (opcional)

[!NOTE] Si no proporcionas una dirección de correo del remitente, el servidor MCP te pedirá que proporciones una cada vez que llames a la herramienta.

Herramientas del servidor MCP

El servidor MCP de Resend brinda a tu agente de IA acceso nativo a toda la plataforma Resend a través de una única integración. Puedes gestionar todos los aspectos de tu infraestructura de correo electrónico usando lenguaje natural.

• Correos electrónicos: Envía, lista, obtén, cancela, actualiza, comparte y envía correos en lote. Recupera métricas de entrega y participación. Admite HTML, texto plano, archivos adjuntos (archivo local, URL o base64), CC/CCO, respuesta, programación, etiquetas, encabezados personalizados, envío basado en temas y claves de idempotencia.
• Correos recibidos: Lista y lee correos entrantes. Lista y descarga archivos adjuntos de correos recibidos.
• Plantillas: Crea, lista, obtén, actualiza, publica, duplica y elimina plantillas de correo. Admite la composición de contenido de plantillas y marcadores de posición {{{VARIABLE}}}.
• Contactos: Crea, lista, obtén, actualiza y elimina contactos. Gestiona membresías de segmentos, suscripciones a temas e importaciones de contactos CSV. Admite propiedades de contacto personalizadas.
• Transmisiones: Crea, envía, cancela, duplica, lista, obtén, actualiza y elimina campañas de transmisión. Lista los enlaces en los que se hizo clic de una transmisión y sus destinatarios por tipo de evento (enviado, entregado, abierto, clic, rebotado, quejado, dado de baja, suprimido). Admite programación, marcadores de posición de personalización y texto de vista previa.
• Automatizaciones: Crea, lista, obtén, actualiza, duplica y elimina automatizaciones. Revisa las ejecuciones de una automatización.
• Eventos: Envía eventos para activar automatizaciones para un contacto. Crea, actualiza y elimina definiciones de eventos.
• Dominios: Crea, lista, obtén, actualiza, elimina y verifica dominios de remitente. Configura el seguimiento, TLS y las capacidades de envío/recepción. Crea y verifica reclamaciones de dominio.
• Segmentos: Crea, lista, obtén, actualiza y elimina segmentos de audiencia.
• Supresiones: Lista, obtén, añade y elimina entradas de la lista de supresión, individualmente o en lote. Los rebotes duros y las quejas de spam se suprimen automáticamente; añade direcciones manualmente para honrar las solicitudes de no contacto.
• Temas: Crea, lista, obtén, actualiza y elimina temas de suscripción.
• Propiedades de contacto: Crea, lista, obtén, actualiza y elimina atributos de contacto personalizados.
• Claves de API: Crea, lista, actualiza y elimina claves de API.
• Webhooks: Crea, lista, obtén, actualiza y elimina webhooks para notificaciones de eventos, e inspecciona su historial de entrega: los eventos enviados a un webhook, la carga útil de un evento y los intentos realizados para entregarlo. Reproduce un evento para poner en cola otra entrega y rota el secreto de firma de un webhook.
• Registros: Lista e inspecciona registros de solicitudes de API, incluidos los cuerpos completos de solicitudes y respuestas.
• Uso: Recupera información de uso y cuota a nivel de cuenta: correos, contactos, segmentos, transmisiones, créditos de IA, ejecuciones de automatización, dominios y el límite de velocidad de la API.
• Editor: Conéctate (y desconéctate) al editor visual en el panel de Resend y lee el contenido de un borrador mientras colaboras en transmisiones y plantillas.

Desarrollo local

1. Clona este proyecto y compila:

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

2. Para usar la compilación local, reemplaza el comando npx con la ruta a tu compilación local:

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

Pruebas en vivo con un cliente MCP

Al desarrollar, puedes probar cambios en una sesión real de cliente MCP mientras editas código en otro.

La idea: ejecuta tsc --watch para recompilar continuamente dist/ y apunta un cliente MCP separado al dist/index.js compilado desde un directorio diferente. Cuando quieras recoger los cambios de código, reinicia la sesión del cliente MCP (los servidores MCP son procesos stdio de larga duración que no se recargan en caliente).

Ejemplo con Claude Code:

1. Ejecuta el observador de TypeScript para recompilar automáticamente al guardar:

   pnpm tsc --watch
   

2. En un directorio separado, crea un .mcp.json que apunte a la salida de compilación:

   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. Inicia Claude Code desde ese directorio y usa las herramientas MCP. Después de hacer cambios de código, inicia una nueva sesión de Claude Code para recoger la nueva compilación.

El mismo principio se aplica a cualquier cliente MCP: separa tu entorno de prueba de tu entorno de desarrollo, usa una ruta absoluta a dist/index.js y vuelve a conectar el servidor MCP después de recompilar.

Pruebas con MCP Inspector

Nota: Asegúrate de haber compilado el proyecto primero (consulta la sección Desarrollo local anterior).

Uso del transporte Stdio

1. Configura tu clave de API:

   export RESEND_API_KEY=re_your_key_here
   

2. Inicia el inspector:

   pnpm inspector
   

3. En el navegador (interfaz del Inspector):

   • Elige stdio (iniciar un proceso).
   • Comando: node
   • Argumentos: dist/index.js (o la ruta completa a dist/index.js)
   • Entorno: RESEND_API_KEY=re_your_key_here (o déjalo en blanco si ya lo exportaste en la misma terminal).
   • Haz clic en Connect y luego usa "List tools" para verificar que el servidor funciona.

Uso del transporte HTTP

1. Inicia el servidor HTTP en una terminal:

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

2. Inicia el inspector en otra terminal:

   pnpm inspector
   

3. En el navegador (interfaz del Inspector):

   • Elige Streamable HTTP (conectar a URL).
   • URL: http://127.0.0.1:3000/mcp
   • Añade un encabezado personalizado: Authorization: Bearer re_your_key_here y activa el interruptor.
   • Haz clic en Connect y luego usa "List tools" para verificar que el servidor funciona.