MCP Emails

Servidor de e-mail hospedado para Gmail, Fastmail, iCloud, Yahoo, Zoho, Yandex e qualquer caixa de correio IMAP/SMTP: leia, pesquise, envie, organize, rascunhe e agende e-mails de qualquer cliente MCP, buscados ao vivo e nunca armazenados. Documentação em https://mcpemails.com/docs

GitHub

Experimente este MCPPatrocinado

Documentação

MCPEmails

Dê ao seu agente de IA uma caixa de entrada. Um servidor hospedado de Model Context Protocol que permite que Claude, Cursor ou qualquer cliente compatível com MCP leia, pesquise, envie, organize e agende e-mails através das suas caixas de entrada existentes — sem nunca armazenar seus e-mails.

Conecte uma caixa de entrada uma vez, cole uma URL no seu agente, e ele poderá trabalhar na sua caixa de entrada ao vivo. O e-mail é buscado sob demanda e nunca retido; as credenciais são criptografadas em repouso e descriptografadas apenas no momento da chamada dentro de uma função de borda isolada.

🔗 mcpemails.com · 📚 Documentação · 💳 Preços

Conteúdo

Como funciona
Início rápido (conectando um agente)
Recursos
Ferramentas
Escopos OAuth
Provedores suportados
Preços
Arquitetura
Estrutura do repositório
Desenvolvimento local
Variáveis de ambiente
Banco de dados e migrações
Implantação
Auto-hospedagem
Internacionalização
Modelo de segurança

Como funciona

Conecte uma caixa de entrada. Entre em mcpemails.com e conecte o Gmail (OAuth com um clique) ou qualquer conta IMAP/SMTP (senha de aplicativo). As credenciais são criptografadas com AES‑256‑GCM antes de tocarem o banco de dados.
Obtenha acesso. Clientes com capacidade OAuth (claude.ai, Claude Desktop, Cursor) conectam-se em um clique via OAuth 2.0 + PKCE. Todo o resto usa uma chave de API com escopo (mcpe_…).
Aponte seu cliente para o servidor. O endpoint MCP é uma única URL:
```
https://mcpemails.com/api/mcp
```
Seu agente trabalha na caixa de entrada. Ele chama ferramentas como inbox_list, email_read (action: "search"), email_compose (action: "send") e schedule (action: "create"). Cada solicitação busca dados ao vivo do seu provedor — nada é espelhado ou armazenado em cache no servidor.

As permissões são definidas por chave, então você pode dar a um agente apenas read:email, ou conceder envio e gerenciamento de pastas sem nunca expor a exclusão.

Início rápido (conectando um agente)

Claude Desktop / Cursor (OAuth): adicione um servidor MCP remoto apontando para https://mcpemails.com/api/mcp e aprove a tela de consentimento. Escolha os escopos que o agente deve ter.

Chave de API (qualquer cliente MCP): crie uma chave no painel, escolha seus escopos e (opcionalmente) restrinja-a a caixas de entrada específicas, depois envie-a como um token de portador:

// Example MCP client config
{
  "mcpServers": {
    "mcpemails": {
      "url": "https://mcpemails.com/api/mcp",
      "headers": { "Authorization": "Bearer mcpe_your_key_here" }
    }
  }
}

O protocolo é JSON‑RPC 2.0 sobre HTTP (MCP 2025-06-18, transporte Streamable). Inicie cada sessão com inbox_list — ele retorna as caixas de entrada que a chave pode acessar, seus recursos por provedor e um perfil de compatibilidade versionado. O perfil marca operações normalizadas como exact, different ou unavailable, para que os agentes possam preservar as diferenças entre provedores em vez de enfraquecer silenciosamente uma solicitação.

Recursos

Ao vivo, nunca armazenado — o e-mail é lido diretamente do seu provedor a cada chamada; nenhum corpo de mensagem é persistido.
Multi‑provedor — Gmail via OAuth, além de qualquer caixa de entrada IMAP/SMTP (Fastmail, iCloud, Yahoo, Zoho, Yandex, auto‑hospedada…) via senha de aplicativo.
Sem retransmissão — o e-mail de saída é enviado pelo SMTP/API do seu provedor, do seu endereço real.
Escopos granulares — oito escopos de permissão, concedíveis independentemente por chave de API e por caixa de entrada.
Lote e busca‑e‑ação — leia, mova, exclua ou sinalize até centenas de mensagens em uma única chamada, incluindo combinadores de "buscar e mover/excluir".
Rascunhos e agendamento — componha rascunhos e coloque mensagens na fila para envio futuro (despacho no servidor).
Busca independente de provedor — sintaxe do Gmail, IMAP SEARCH e JMAP são normalizados atrás de uma única interface email_read (action: "search").
Pronto para equipes: workspaces, membros, funções, SSO e um log de auditoria no plano Team.

Ferramentas

11 ferramentas. A maioria é orientada a recursos e recebe um argumento action que seleciona a operação específica (e, para ações que precisam de privilégios diferentes, o escopo necessário):

Ferramenta	Ações	Escopo(s)
`inbox_list`	(ação única)	`read:email`
`email_read`	`list`, `read`, `read_batch`, `search`, `attachment`, `extract`, `original`	`read:email` (`search` também aceita `search:email`)
`email_organize`	`move`, `move_batch`, `copy`, `copy_batch`, `flag`, `archive`, `search_and_move`	`manage:folders` (mover/copiar/buscar_e_mover), `send:email` (sinalizar/arquivar)
`email_delete`	`delete`, `delete_batch`, `search_and_delete`	`delete:email`
`email_compose`	`send`, `reply`, `forward`	`send:email`
`folder`	`list`, `create`, `rename`, `delete`	`read:email` (listar), `manage:folders` (criar/renomear/excluir)
`draft`	`list`, `create`, `reply`, `update`, `send`, `delete`	`manage:drafts` (listar/criar/responder/atualizar/excluir), `read:email` (responder também), `send:email` (enviar)
`schedule`	`create`, `list`, `cancel`	`schedule:email`
`signature`	`get`, `set`	`read:email` (obter), `send:email` (definir)
`automation`	`create`, `list`, `get`, `update`, `enable`, `disable`, `delete`, `runs`, `preview`	`manage:automations`
`contact_search`	(ação única)	`manage:contacts`

Observações:

As ferramentas aceitam um inbox_id explícito (UUID) ou um endereço de e-mail inbox; chaves de caixa de entrada única resolvem o destino automaticamente.
As ações em lote limitam-se a 50 (email_read's read_batch) a 500 (mover/excluir/sinalizar) mensagens por chamada.
Para uma mutação direcionada, primeiro use email_read com action: "search", depois passe o message_id ou message_ids retornado para email_organize ou email_delete. Os campos de busca são aceitos apenas pelas ações de mutação search_and_move e search_and_delete.
contact_search examina e-mails recentes ao vivo — não há lista de contatos armazenada.
A ação original de email_read retorna uma mensagem MIME completa armazenada no provedor como um arquivo .eml portátil (até 25 MB). É somente leitura e nunca marca a mensagem como lida.
A ação send de draft requer send:email, não manage:drafts — para que uma chave que só pode gerenciar rascunhos não possa usá-los para contornar o consentimento de envio de e-mail.
A ação reply de draft cria uma resposta não enviada, nativa do provedor, na conversa de origem. Ela precisa tanto de manage:drafts quanto de read:email, e por padrão responde apenas ao remetente.
automation gerencia regras de triagem agendadas sem supervisão: uma busca armazenada mais uma ação fixa, avaliadas em uma cadência sem modelo no loop. Não há ação de exclusão, um forward sempre aguarda aprovação humana, e draft_reply apenas escreve um rascunho. Veja docs/automations-trust-boundary.md.
tools/list retorna apenas as ferramentas para as quais sua chave (ou token OAuth) está realmente autorizada.

Escopos OAuth

Escopo	Concede
`read:email`	Listar caixas de entrada e pastas; listar, ler e pesquisar mensagens
`search:email`	Alternativa mais restrita que concede apenas a ação `search` de `email_read`
`send:email`	Enviar, responder, encaminhar, sinalizar, arquivar; também necessário para enviar um rascunho
`manage:folders`	Criar/renomear/excluir pastas; mover/copiar mensagens
`delete:email`	Mover para a lixeira ou excluir permanentemente mensagens
`manage:drafts`	Criar, editar e excluir rascunhos (enviar um também requer `send:email`)
`manage:contacts`	Consulta ao vivo de contatos a partir de e-mails recentes
`schedule:email`	Colocar mensagens na fila para entrega futura
`manage:automations`	Criar e gerenciar regras de triagem agendadas sem supervisão (sem ação de exclusão; encaminhamentos permanecem sujeitos a aprovação)

Provedores suportados

Provedor	Conectar via	Ler/Pesquisar	Enviar	Pastas	Exclusão permanente	Rascunhos
Gmail / Google Workspace	OAuth 2.0	✅	✅	Rótulos	Somente lixeira	✅
Fastmail	Senha de aplicativo (IMAP/SMTP)	✅	✅	✅	✅	✅
iCloud, Yahoo, Zoho, Yandex	Senha de aplicativo (IMAP/SMTP)	✅	✅	✅	✅	✅
Qualquer caixa de entrada IMAP/SMTP	Senha de aplicativo	✅	✅	✅	✅	✅
Outlook / Microsoft 365	OAuth 2.0	🚧 construído, bloqueado aguardando verificação

O OAuth do Outlook está implementado de ponta a ponta, mas atualmente está bloqueado pela verificação de editor da Microsoft; ele fica oculto na interface de conexão até ser lançado.

Preços

A métrica de valor é caixas de entrada conectadas. O plano Free conecta uma caixa de entrada, o Personal conecta até três, o Pro conecta todas as caixas de entrada que você possui, e o Team adiciona pessoas, funções e um workspace separado por cliente. A cobrança anual economiza cerca de 20%.

	Free	Personal	Pro	Team
Preço	$0	$5/mês · $48/ano ($4/mês)	$29/mês · $276/ano ($23/mês)	$79/mês · $756/ano ($63/mês)
Caixas de entrada conectadas	1	3	Ilimitadas	Ilimitadas
Chaves de API	Ilimitadas	Ilimitadas	Ilimitadas	Ilimitadas
Membros	1 (somente proprietário)	1 (somente proprietário)	1 (somente proprietário)	Ilimitados, com funções
Limite de uso justo	60 req/min	120 req/min	300 req/min	1.000 req/min
Funções e workspaces de equipe	Não	Não	Não	✅
SSO (SAML/OIDC) + log de auditoria	Não	Não	Não	✅
Suporte	Comunidade	E-mail	E-mail	Prioritário

Limites por chave de API também se aplicam (100 req/min · 1.000/h · 10.000/dia). Os limites de taxa são repetíveis: eles retornam como erro JSON-RPC -32003 com data.retry_after em segundos.

Cada workspace também tem um teto de uso justo em ações cobráveis por período de cobrança. É uma proteção contra abuso, não um recurso do plano: fica muito acima de qualquer uso real observado, nunca é mostrado aos clientes e não pode ser ampliado por compra. Atingi-lo não é repetível e não é um erro JSON-RPC: retorna como um resultado normal de ferramenta com isError: true e um bloco _meta["com.mcpemails/usage_limit"], e é limpo em reset_at.

Os IDs internos de plano são anteriores aos nomes: solo é vendido como Pro e pro é vendido como Team. O ID mais novo personal é o único que corresponde ao nome exibido, Personal. Todo usuário que existia antes do reajuste de 2026-08-19 mantém caixas de entrada ilimitadas gratuitamente, permanentemente. Veja apps/web/src/lib/stripe/plans.ts.

Arquitetura

flowchart LR
    Agent["MCP client<br/>(Claude, Cursor, …)"] -->|"JSON-RPC / OAuth or API key"| Web

    subgraph Vercel["Vercel — Next.js 16"]
      Web["/api/mcp route<br/>+ marketing site + dashboard"]
    end

    subgraph Supabase
      Edge["mcp-server<br/>edge function (Deno)"]
      DB[("Postgres<br/>RLS + encrypted creds")]
      Cron["token-refresh<br/>edge functions"]
    end

    Web -->|proxies| Edge
    Edge -->|decrypt creds, fetch live| Providers["Email providers<br/>Gmail API · IMAP/SMTP"]
    Edge --> DB
    Cron --> DB
    Web --> Stripe[("Stripe<br/>billing")]

/api/mcp é um manipulador de rotas fino do Next.js que faz proxy para a função de borda do Supabase mcp-server — a implementação real do MCP, onde as credenciais são descriptografadas e as chamadas ao provedor são feitas.
O banco de dados Postgres armazena workspaces, membros, caixas de entrada (tokens/senhas criptografados), chaves de API com hash, clientes OAuth, envios agendados e um log de atividades — tudo protegido por Segurança em Nível de Linha.
Funções de borda Cron atualizam os tokens OAuth do Gmail/Outlook antes da expiração.

Stack: Next.js 16 (App Router) · React 19 · next‑intl 4 · Supabase (Auth, Postgres, Edge Functions) · Stripe · Resend · TypeScript. Análise/sanitização de e-mail via mailparser, jsdom e isomorphic-dompurify.

Estrutura do repositório

.
├── apps/
│   └── web/                     # Next.js 16 app (marketing, dashboard, /api/mcp proxy)
│       ├── app/                 # App Router routes ([locale], dashboard, api, auth)
│       ├── components/          # marketing/ + dashboard/ React components
│       ├── messages/            # next-intl translations (en, nb, es, fr, zh)
│       ├── src/lib/             # stripe/, supabase/, blog/, crypto helpers
│       └── proxy.ts             # middleware: i18n + Supabase session + CDN cache
├── supabase/
│   ├── functions/
│   │   ├── mcp-server/          # the MCP server (tools, auth, scopes)
│   │   ├── gmail-token-refresh/
│   │   └── outlook-token-refresh/
│   └── migrations/              # SQL migrations (schema + RLS)
└── package.json                 # npm workspaces (apps/*)

Desenvolvimento local

Pré‑requisitos: Node.js 20+, npm e a CLI do Supabase (para migrações e funções de borda).

# 1. Install (npm workspaces — run from the repo root)
npm install

# 2. Configure environment
cp .env.example apps/web/.env.local
#   then fill in the values (see below) and generate the two secrets:
openssl rand -hex 32   # ENCRYPTION_KEY
openssl rand -hex 32   # CSRF_SECRET

# 3. Run the web app (http://localhost:3000)
npm run dev

# 4. Production build
npm run build

next.config.js valida as variáveis de ambiente obrigatórias no build/início e rejeita valores fracos de ENCRYPTION_KEY, para que um ambiente mal configurado falhe rapidamente em vez de em tempo de execução.

Variáveis de ambiente

Copie .env.example e preencha com valores reais. Obrigatórias em todos os ambientes:

Variável	Finalidade
`NEXT_PUBLIC_SUPABASE_URL` / `NEXT_PUBLIC_SUPABASE_ANON_KEY`	Cliente Supabase (público)
`SUPABASE_SERVICE_ROLE_KEY`	Chave de administração do lado do servidor (ignora RLS) — segredo
`NEXT_PUBLIC_APP_URL`	URL base canônica; orienta URIs de redirecionamento OAuth
`GOOGLE_SITE_VERIFICATION` (opcional)	Token de verificação de tag HTML do Google Search Console; defina apenas em produção
`ENCRYPTION_KEY`	Chave AES‑256‑GCM de 64 hex para credenciais em repouso — segredo
`CSRF_SECRET`	Chave HMAC de 64 hex para tokens CSRF (distinta da acima) — segredo

Dependente de funcionalidade:

Variável(is)	Necessária(s) para
`GMAIL_CLIENT_ID` / `GMAIL_CLIENT_SECRET`	OAuth do Gmail (`gmail.readonly`, `gmail.send`, `gmail.modify`)
`OUTLOOK_CLIENT_ID` / `OUTLOOK_CLIENT_SECRET` / `OUTLOOK_TENANT_ID`	OAuth do Outlook (`Mail.Read`, `Mail.Send`, `Mail.ReadWrite`, `offline_access`)
`NEXT_PUBLIC_OAUTH_VERIFICATION_PENDING`	Exibe o aviso de aplicativo não verificado até a verificação do Google/Microsoft ser concluída
`STRIPE_SECRET_KEY` / `STRIPE_WEBHOOK_SECRET` / `NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY`	Cobrança
`STRIPE_PRICE_PERSONAL_MONTHLY` / `_YEARLY`, `STRIPE_PRICE_SOLO_MONTHLY` / `_YEARLY`, `STRIPE_PRICE_PRO_MONTHLY` / `_YEARLY`	IDs de preço do plano (`personal` = Personal, `solo` = Pro, `pro` = Team)

Fastmail e outros provedores IMAP conectam via senha de aplicativo e não precisam de credenciais OAuth.

Banco de dados e migrações

O esquema e as políticas de Row‑Level Security estão em supabase/migrations/. Tabelas principais: workspaces, workspace_members, inboxes (credenciais criptografadas, com soft‑delete), api_keys (com hash, escopadas, restritas por caixa de entrada), oauth_clients, scheduled_sends, workspace_invites e uma activity_log particionada por mês.

# Apply migrations to the linked project
npx supabase db push

# Generate TypeScript types from the live schema
npx supabase gen types typescript --linked > apps/web/src/types/database.ts

A CLI do Supabase é a fonte da verdade para alterações no banco de dados neste projeto.

Implantação

Aplicativo web → Vercel (projeto mcp-emails-web):

vercel --prod --yes

Cabeçalhos de segurança e timeouts de função são definidos em vercel.json. As rotas de marketing são servidas com um Cache-Control armazenável em cache de CDN (definido em proxy.ts) para que rastreadores e visitantes recorrentes acessem o cache de borda; o dashboard, a autenticação e as rotas de API permanecem no-store.

Servidor MCP → função de borda do Supabase:

npx supabase functions deploy mcp-server --project-ref <your-project-ref> --no-verify-jwt

Autohospedagem

Não quer confiar no serviço hospedado com seu e‑mail? Execute o mesmo servidor MCP na sua própria máquina. self-host/ inclui uma stack conteinerizada (Postgres + PostgREST + o servidor Deno, sem Supabase/Stripe/dashboard), para que suas credenciais sejam criptografadas com uma chave que só você possui e descriptografadas apenas dentro do seu próprio contêiner.

cd self-host
make setup      # generate secrets (.env)
make up         # build + start the stack
export IMAP_PASSWORD='your-app-password'
make provision EMAIL=you@example.com IMAP_HOST=imap.fastmail.com SMTP_HOST=smtp.fastmail.com SERVICE=fastmail
make key NAME="my agent"   # mint an mcpe_ key, then point your client at http://localhost:8787

É IMAP/SMTP‑first (Fastmail, iCloud, Yahoo, Zoho, Yandex, genérico) via senha de aplicativo; OAuth do Gmail/Outlook e o dashboard web permanecem apenas no serviço hospedado. O contêiner executa supabase/functions/mcp-server/ sem modificações; veja self-host/README.md para o guia completo.

Internacionalização

Construído com next‑intl (localePrefix: 'as-needed', localeDetection: false para URLs canônicas estáveis). O inglês é servido em /; outros idiomas têm um prefixo (/nb, /es, /fr, /zh). As traduções estão em apps/web/messages/.

Idiomas suportados: Inglês, Norueguês (Bokmål), Espanhol, Francês, Chinês (Simplificado).

Modelo de segurança

Credenciais criptografadas em repouso com AES‑256‑GCM; descriptografadas apenas dentro da função de borda no momento da chamada.
Sem armazenamento de mensagens — corpos de e‑mail e anexos são buscados ao vivo e nunca persistidos. A extração de texto de anexos é executada de forma transitória na requisição e não retorna bytes brutos de anexos.
Chaves de API com hash (apenas um prefixo é armazenado para exibição) e escopadas por permissão e por caixa de entrada, com expiração opcional.
OAuth 2.0 + PKCE para autorização de clientes; Dynamic Client Registration (RFC 7591) para clientes MCP.
Row‑Level Security isola os dados de cada workspace na camada do banco de dados.
CSP estrito, HSTS, X-Frame-Options: DENY e cabeçalhos relacionados em cada resposta.

Licença

MCP Emails é open source sob a GNU Affero General Public License v3.0 (AGPL‑3.0). O serviço hospedado em mcpemails.com executa o mesmo servidor que você pode autohospedar, para que você possa ler o código, verificá‑lo e executá‑lo você mesmo. Veja /security para o modelo de confiança.