Resend Email

Resend MCP Server

Conecte seu agente de IA à plataforma Resend. Envie e receba e-mails, gerencie contatos, transmissões, domínios e muito mais, diretamente de qualquer cliente MCP, como Claude, Cursor ou Claude Code.

Oferecemos tanto um servidor MCP remoto hospedado pela Resend quanto um servidor MCP local (este pacote).

Servidor MCP Remoto

A Resend hospeda o servidor MCP em:

https://mcp.resend.com/mcp

Conecte qualquer cliente MCP que suporte servidores remotos (Streamable HTTP). Não há nada para instalar e nenhum processo local para executar, o que o torna a melhor opção para clientes baseados na web, como Claude e plataformas de agentes hospedados.

Ao conectar, seu cliente abre uma janela do navegador para fazer login na Resend e aprovar o acesso usando OAuth.

Claude Code

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

Em seguida, execute /mcp no Claude Code e selecione resend para concluir o login OAuth.

Claude

No Claude (web ou desktop), abra Configurações > Conectores > Adicionar conector personalizado e insira:

https://mcp.resend.com/mcp

Cursor

Abra a paleta de comandos e escolha "Configurações do Cursor" > "MCP" > "Adicionar novo servidor MCP global".

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

Codex

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

Copilot

Para usar o GitHub Copilot no VS Code, adicione o seguinte ao seu settings.json:

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

Windsurf

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

Warp

Nas configurações do Warp, navegue até Agentes > Servidores MCP e clique em +Adicionar para adicionar um novo servidor.

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

Autenticando com uma chave de API

Se seu cliente for executado em um ambiente onde o login pelo navegador não é possível (um servidor, CI ou agente headless), passe uma chave de API da Resend como token Bearer em vez de usar OAuth.

Claude Code:

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

Configuração JSON (Cursor, Windsurf e outros), adicione um cabeçalho Authorization:

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

Servidor MCP Local

O servidor hospedado executa o mesmo código de código aberto disponível no NPM como resend-mcp. Se preferir executar o servidor você mesmo, pode integrá-lo a qualquer cliente MCP compatível usando npx. Você precisará:

• Criar uma chave de API
• Verificar seu domínio

O servidor local suporta dois modos de transporte: stdio (padrão) e HTTP.

Escolha seu modo e cliente preferidos abaixo para começar. Lembre-se de substituir re_xxxxxxxxx pela sua chave de API real.

Transporte Stdio (Padrão)

Configuração rápida

Instale para todos os agentes e editores detectados/selecionados:

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

Abra a paleta de comandos e escolha "Configurações do Cursor" > "MCP" > "Adicionar novo servidor MCP global".

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

Claude Desktop

Abra as configurações do Claude Desktop > aba "Desenvolvedor" > "Editar Configuração".

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

Copilot

Para usar o GitHub Copilot no VS Code, adicione o seguinte ao seu 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

Adicione ao seu arquivo de configuração 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

No Devin, abra Configurações > Conexões > Servidores MCP e clique em Adicionar um MCP personalizado. Consulte o guia do Devin para o passo a passo completo.

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

Transporte HTTP

Execute o servidor por HTTP para integrações remotas ou baseadas na web, por exemplo, atrás do seu próprio túnel ou proxy reverso, em vez de usar o servidor MCP remoto hospedado da Resend. No modo HTTP, cada cliente autentica passando sua chave de API da Resend como token Bearer no cabeçalho Authorization.

Inicie o servidor:

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

O servidor escutará em http://127.0.0.1:3000 e exporá o endpoint MCP em /mcp usando Streamable HTTP.

Claude Code

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

Cursor

Abra a paleta de comandos e escolha "Configurações do Cursor" > "MCP" > "Adicionar novo servidor MCP global".

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

Você também pode definir a porta via a variável de ambiente MCP_PORT:

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

Uso como biblioteca

O transporte HTTP também é exportado para que possa ser incorporado em outro serviço em vez de ser executado via CLI. Cada cliente que se conecta autentica com sua própria chave de API da Resend passada 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);

Por padrão, o servidor aplica validação de Host somente para localhost (proteção contra rebinding de DNS). Ao implantar atrás de um proxy reverso ou balanceador de carga, onde o servidor é protegido pela chave de API Bearer por requisição, defina host como 0.0.0.0 para que o Host encaminhado do proxy e as verificações de saúde do balanceador de carga não sejam rejeitados com 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 CLI, isso mapeia para --host / --allowed-hosts (ou MCP_HOST / MCP_ALLOWED_HOSTS).

Opções

Você pode passar argumentos adicionais para configurar o servidor local:

• --key: Sua chave de API da Resend (somente no modo stdio, já que o modo HTTP usa o token Bearer do cliente)
• --sender: Endereço de e-mail do remetente padrão de um domínio verificado
• --reply-to: Endereço de e-mail de resposta padrão (pode ser especificado várias vezes)
• --http: Use transporte HTTP em vez de stdio (padrão: stdio)
• --port: Porta HTTP ao usar --http (padrão: 3000, ou variável de ambiente MCP_PORT)
• --host: Host para proteção contra rebinding de DNS ao usar --http (padrão: 127.0.0.1, ou MCP_HOST). Defina como 0.0.0.0 para desativar a validação de Host atrás de um proxy/balanceador de carga.
• --allowed-hosts: Lista de permissões Host separada por vírgulas ao usar --http (ou MCP_ALLOWED_HOSTS)

Variáveis de ambiente:

• RESEND_API_KEY: Sua chave de API da Resend (obrigatória para stdio, opcional para HTTP, pois os clientes a passam via token Bearer)
• SENDER_EMAIL_ADDRESS: Endereço de e-mail do remetente padrão de um domínio verificado (opcional)
• REPLY_TO_EMAIL_ADDRESSES: Endereços de e-mail de resposta separados por vírgulas (opcional)
• MCP_PORT: Porta HTTP ao usar --http (opcional)
• MCP_HOST: Host para proteção contra rebinding de DNS ao usar --http (opcional)
• MCP_ALLOWED_HOSTS: Lista de permissões Host separada por vírgulas ao usar --http (opcional)

[!NOTE] Se você não fornecer um endereço de e-mail do remetente, o servidor MCP solicitará que você forneça um toda vez que chamar a ferramenta.

Ferramentas do Servidor MCP

O servidor MCP da Resend dá ao seu agente de IA acesso nativo a toda a plataforma Resend por meio de uma única integração. Você pode gerenciar todos os aspectos da sua infraestrutura de e-mail usando linguagem natural.

• E-mails: Enviar, listar, obter, cancelar, atualizar e enviar em lote. Suporta HTML, texto simples, anexos (arquivo local, URL ou base64), CC/CCO, resposta, agendamento, tags, cabeçalhos personalizados, envio baseado em tópicos e chaves de idempotência.
• E-mails Recebidos: Listar e ler e-mails de entrada. Listar e baixar anexos de e-mails recebidos.
• Modelos: Criar, listar, obter, atualizar, publicar, duplicar e remover modelos de e-mail. Suporta composição de conteúdo de modelos e placeholders de {{{VARIABLE}}}.
• Contatos: Criar, listar, obter, atualizar e remover contatos. Gerenciar associações de segmentos, assinaturas de tópicos e importações de contatos CSV. Suporta propriedades de contato personalizadas.
• Transmissões: Criar, enviar, cancelar, listar, obter, atualizar e remover campanhas de transmissão. Suporta agendamento, placeholders de personalização e texto de pré-visualização.
• Automações: Criar, listar, obter, atualizar e remover automações. Revisar as execuções de uma automação.
• Eventos: Enviar eventos para acionar automações para um contato. Criar, atualizar e remover definições de eventos.
• Domínios: Criar, listar, obter, atualizar, remover e verificar domínios de remetente. Configurar rastreamento, TLS e capacidades de envio/recebimento. Criar e verificar reivindicações de domínio.
• Segmentos: Criar, listar, obter e remover segmentos de público.
• Supressões: Listar, obter, adicionar e remover entradas da lista de supressão, individualmente ou em lote. Rejeições definitivas e reclamações de spam são suprimidas automaticamente; adicione endereços manualmente para honrar solicitações de não contato.
• Tópicos: Criar, listar, obter, atualizar e remover tópicos de assinatura.
• Propriedades de Contato: Criar, listar, obter, atualizar e remover atributos personalizados de contato.
• Chaves de API: Criar, listar e remover chaves de API.
• Webhooks: Criar, listar, obter, atualizar e remover webhooks para notificações de eventos.
• Logs: Listar e inspecionar logs de solicitações de API, incluindo corpos completos de solicitação e resposta.
• Editor: Conectar-se (e desconectar-se) ao editor visual no painel da Resend e ler o conteúdo de um rascunho enquanto colabora em transmissões e modelos.

Desenvolvimento Local

1. Clone este projeto e faça o build:

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

2. Para usar o build local, substitua o comando npx pelo caminho para o seu build 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"
      }
    }
  }
}

Teste ao vivo com um cliente MCP

Ao desenvolver, você pode testar alterações em uma sessão real de cliente MCP enquanto edita o código em outra.

A ideia: execute tsc --watch para recompilar continuamente dist/, e aponte um cliente MCP separado para o build dist/index.js de um diretório diferente. Quando quiser aplicar alterações de código, reinicie a sessão do cliente MCP (os servidores MCP são processos stdio de longa duração que não recarregam automaticamente).

Exemplo com Claude Code:

1. Execute o observador TypeScript para recompilar automaticamente ao salvar:

   pnpm tsc --watch
   

2. Em um diretório separado, crie um .mcp.json apontando para a saída do build:

   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. Inicie o Claude Code a partir desse diretório e use as ferramentas MCP. Após fazer alterações no código, inicie uma nova sessão do Claude Code para carregar o novo build.

O mesmo princípio se aplica a qualquer cliente MCP — separe seu ambiente de teste do ambiente de desenvolvimento, use um caminho absoluto para dist/index.js e reconecte o servidor MCP após recompilar.

Testando com o MCP Inspector

Nota: Certifique-se de ter feito o build do projeto primeiro (consulte a seção Desenvolvimento Local acima).

Usando o Transporte Stdio

1. Defina sua chave de API:

   export RESEND_API_KEY=re_your_key_here
   

2. Inicie o inspector:

   pnpm inspector
   

3. No navegador (interface do Inspector):

   • Escolha stdio (iniciar um processo).
   • Comando: node
   • Args: dist/index.js (ou o caminho completo para dist/index.js)
   • Env: RESEND_API_KEY=re_your_key_here (ou deixe em branco se você já exportou no mesmo terminal).
   • Clique em Conectar e use "Listar ferramentas" para verificar se o servidor está funcionando.

Usando o Transporte HTTP

1. Inicie o servidor HTTP em um terminal:

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

2. Inicie o inspector em outro terminal:

   pnpm inspector
   

3. No navegador (interface do Inspector):

   • Escolha Streamable HTTP (conectar à URL).
   • URL: http://127.0.0.1:3000/mcp
   • Adicione um cabeçalho personalizado: Authorization: Bearer re_your_key_here e ative a alternância.
   • Clique em Conectar e use "Listar ferramentas" para verificar se o servidor está funcionando.