Resend Email

Servidor MCP Resend

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 (HTTP Transmissível). 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 "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 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é Agents > MCP servers e clique em +Add para adicionar um novo servidor.

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

Autenticando com uma chave de API

Se o seu cliente for executado em um local onde o login no navegador não é possível (um servidor, CI ou um agente headless), passe uma chave de API 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 "Cursor Settings" > "MCP" > "Add new global MCP server".

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

Claude Desktop

Abra as configurações do Claude Desktop > aba "Developer" > "Edit Config".

{
  "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 à sua 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 Settings > Connections > MCP Servers e clique em Add a custom MCP. 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 via 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 se autentica passando sua chave de API Resend como um 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 HTTP Transmissível.

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 "Cursor Settings" > "MCP" > "Add new global MCP server".

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

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

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

Usar como uma 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 conectado se autentica com sua própria chave de API 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 Host somente 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 pelo 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 Resend (apenas 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: Usar 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 desabilitar a validação 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 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 cada vez que chamar a ferramenta.

Ferramentas do Servidor MCP

O servidor MCP da Resend dá ao seu agente de IA acesso nativo à plataforma Resend completa através 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 e-mails em lote. Suporta HTML, texto simples, anexos (arquivo local, URL ou base64), CC/BCC, resposta, agendamento, tags, cabeçalhos personalizados, envio baseado em tópicos e chaves de idempotência.
• E-mails Recebidos: Listar e ler e-mails recebidos. Listar e baixar anexos de e-mails recebidos.
• Templates: Criar, listar, obter, atualizar, publicar, duplicar e remover templates de e-mail. Suporta composição de conteúdo de template e placeholders {{{VARIABLE}}}.
• Contatos: Criar, listar, obter, atualizar e remover contatos. Gerenciar associações de segmento, assinaturas de tópicos e importações de contatos CSV. Suporta propriedades de contato personalizadas.
• Transmissões: Criar, enviar, 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 audiência.
• Supressões: Listar, obter, adicionar e remover entradas da lista de supressão, individualmente ou em lote. Hard bounces e reclamações de spam são suprimidos 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 de contato personalizados.
• 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 requisições de API, incluindo corpos completos de requisição e resposta.
• Editor: Conectar-se (e desconectar-se) do editor visual no painel da Resend e ler o conteúdo de um rascunho enquanto colabora em transmissões e templates.

Desenvolvimento Local

1. Clone este projeto e compile:

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

2. Para usar a compilação local, substitua o comando npx pelo caminho para sua compilação 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 as alterações em uma sessão real do 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 dist/index.js compilado de um diretório diferente. Quando quiser incorporar as alterações de código, reinicie a sessão do cliente MCP (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 da compilação:

   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 incorporar a nova compilação.

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 compilado o projeto primeiro (consulte a seção Desenvolvimento Local acima).

Usando Transporte Stdio

1. Defina sua chave de API:

   export RESEND_API_KEY=re_your_key_here
   

2. Inicie o inspetor:

   pnpm inspector
   

3. No navegador (IU do Inspetor):

   • 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 já o exportou no mesmo terminal).
   • Clique em Connect e use "List tools" para verificar se o servidor está funcionando.

Usando Transporte HTTP

1. Inicie o servidor HTTP em um terminal:

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

2. Inicie o inspetor em outro terminal:

   pnpm inspector
   

3. No navegador (IU do Inspetor):

   • 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 Connect e use "List tools" para verificar se o servidor está funcionando.