Skip to main content
Verificar leads antes de uma campanha reduz as taxas de rejeição e protege a reputação do remetente. Este playbook cria um fluxo de trabalho n8n que lê uma lista de e-mails, verifica cada endereço com o Email Verifier, categoriza os resultados (válidos, inválidos, arriscados) e exporta uma lista limpa pronta para envio. Se você é novo no n8n com a Enrow, comece pelo guia de introdução ao n8n.

​
O que você vai construir?

Você vai construir um fluxo de trabalho que:
  1. Lê a lista de e-mails do Google Sheets ou CSV
  2. Verifica cada e-mail usando a Enrow
  3. Categoriza os resultados (válidos, inválidos, arriscados)
  4. Exporta a lista limpa pronta para campanhas
Tempo de construção: 10 minutos Dificuldade: Iniciante

​
Quando usar este fluxo de trabalho?

Use este fluxo de trabalho sempre que a entregabilidade de e-mail for importante para um processo subsequente. Casos de uso comuns:
  • Limpar listas de e-mails antes de campanhas de marketing
  • Verificar envios de formulários em tempo real
  • Manter a higiene do banco de dados
  • Reduzir as taxas de rejeição

​
O que você precisa antes de começar?

Antes de construir o fluxo de trabalho, certifique-se de ter o seguinte: A chave de API da Enrow autentica cada requisição através do cabeçalho x-api-key. Consulte Authentication para saber como recuperar e enviar a chave de API, e Credits & billing para entender como os créditos de verificação são consumidos.

​
Como configurar o Google Sheet?

Crie uma planilha com endereços de e-mail e colunas vazias para os resultados:
EmailStatusDeliverableRisk Factors
john@example.com
invalid@fake.com
temp@tempmail.com

​
Como construir o fluxo de trabalho em 5 minutos?

O caminho mais rápido é importar um fluxo de trabalho pronto, configurar suas credenciais e executá-lo.

​
Step 1: Importar Fluxo de Trabalho

Copie e importe este fluxo de trabalho no n8n: 
{
  "name": "Enrow - Email Verification",
  "nodes": [
    {
      "parameters": {},
      "name": "Manual Trigger",
      "type": "n8n-nodes-base.manualTrigger",
      "typeVersion": 1,
      "position": [240, 300]
    },
    {
      "parameters": {
        "operation": "read",
        "sheetId": "YOUR_SHEET_ID",
        "range": "Sheet1!A:D"
      },
      "name": "Read Email List",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 3,
      "position": [460, 300]
    },
    {
      "parameters": {
        "batchSize": 100,
        "options": {}
      },
      "name": "Batch Emails",
      "type": "n8n-nodes-base.splitInBatches",
      "typeVersion": 1,
      "position": [680, 300]
    },
    {
      "parameters": {
        "method": "POST",
        "url": "https://api.enrow.io/email/verify/bulk",
        "authentication": "headerAuth",
        "sendBody": true,
        "bodyContentType": "json",
        "jsonBody": "={\n  \"emails\": {{$json[\"emails\"].map(e => e.Email)}}\n}"
      },
      "name": "Verify Bulk",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 3,
      "position": [900, 300],
      "credentials": {
        "headerAuth": {"name": "Enrow API"}
      }
    },
    {
      "parameters": {
        "amount": 10,
        "unit": "seconds"
      },
      "name": "Wait",
      "type": "n8n-nodes-base.wait",
      "typeVersion": 1,
      "position": [1120, 300]
    },
    {
      "parameters": {
        "method": "GET",
        "url": "=https://api.enrow.io/email/verify/bulk?id={{$json[\"batch_id\"]}}",
        "authentication": "headerAuth"
      },
      "name": "Get Results",
      "type": "n8n-nodes-base.httpRequest",
      "typeVersion": 3,
      "position": [1340, 300],
      "credentials": {
        "headerAuth": {"name": "Enrow API"}
      }
    },
    {
      "parameters": {
        "operation": "update",
        "sheetId": "YOUR_SHEET_ID",
        "range": "Sheet1!A:D"
      },
      "name": "Update Sheet",
      "type": "n8n-nodes-base.googleSheets",
      "typeVersion": 3,
      "position": [1560, 300]
    }
  ],
  "connections": {
    "Manual Trigger": {
      "main": [[{"node": "Read Email List", "type": "main", "index": 0}]]
    },
    "Read Email List": {
      "main": [[{"node": "Batch Emails", "type": "main", "index": 0}]]
    },
    "Batch Emails": {
      "main": [[{"node": "Verify Bulk", "type": "main", "index": 0}]]
    },
    "Verify Bulk": {
      "main": [[{"node": "Wait", "type": "main", "index": 0}]]
    },
    "Wait": {
      "main": [[{"node": "Get Results", "type": "main", "index": 0}]]
    },
    "Get Results": {
      "main": [[{"node": "Update Sheet", "type": "main", "index": 0}]]
    }
  }
}

​
Step 2: Configurar

  1. Substitua YOUR_SHEET_ID pelo ID do seu Google Sheet
  2. Adicione sua chave de API da Enrow à credencial Header Auth
  3. Teste primeiro com alguns e-mails

​
Step 3: Executar

  1. Clique em “Execute Workflow”
  2. Aguarde a conclusão da verificação
  3. Verifique os resultados no seu Google Sheet

​
Como construir o fluxo de trabalho passo a passo?

Se você preferir construir o fluxo de trabalho nó por nó, siga o guia detalhado abaixo.

​
Step 1: Ler a Lista de E-mails

Google Sheets:
  1. Adicione o nó “Google Sheets”
  2. Operação: Read
  3. Selecione sua planilha
  4. Intervalo: Sheet1!A:A (apenas a coluna de e-mail)
Arquivo CSV:
  1. Adicione o nó “Read Binary Files”
  2. Adicione o nó “CSV to JSON”
  3. Mapeie o campo de e-mail

​
Step 2: Criar Lotes

Para melhor desempenho, processe os e-mails em lotes:
  1. Adicione o nó “Split In Batches”
  2. Tamanho do lote: 100 (ou menos para resultados mais rápidos)
Isso envia 100 e-mails por vez para a Enrow.

​
Step 3: Verificar com a API Bulk da Enrow

  1. Adicione o nó “HTTP Request”
  2. Configure:
Method: POST
URL: https://api.enrow.io/email/verify/bulk
Authentication: Header Auth
  Name: x-api-key
  Value: YOUR_API_KEY

JSON Body:
{
  "emails": {{ $json["items"].map(item => item.Email) }}
}
Isso retorna um batch_id imediatamente. Consulte Verificar E-mails em Massa para a referência completa de requisição e resposta.

​
Step 4: Aguardar os Resultados

Adicione o nó “Wait” com um atraso de 10-15 segundos. Para lotes grandes, aguarde mais tempo. Para recuperação orientada a eventos em vez de polling, envie uma URL de webhook na requisição — consulte Como funcionam os webhooks.

​
Step 5: Buscar os Resultados

  1. Adicione o nó “HTTP Request”
  2. Configure:
Method: GET
URL: https://api.enrow.io/email/verify/bulk?id={{$json["batch_id"]}}
Authentication: Header Auth (reuse credential)
O endpoint Obter Verificações em Massa retorna os resultados de verificação do lote.

​
Step 6: Processar os Resultados

Adicione o nó “Function” para categorizar os e-mails: 
const results = $input.all()[0].json.results;

const valid = results.filter(r =>
  r.status === 'valid' &&
  r.is_deliverable &&
  !r.metadata.is_disposable
);

const invalid = results.filter(r => r.status === 'invalid');

const risky = results.filter(r =>
  r.status === 'risky' ||
  r.metadata.is_disposable ||
  r.metadata.is_role
);

return [
  {
    json: {
      total: results.length,
      valid: valid.length,
      invalid: invalid.length,
      risky: risky.length,
      validEmails: valid.map(r => r.email),
      invalidEmails: invalid.map(r => r.email),
      riskyEmails: risky.map(r => r.email)
    }
  }
];

​
Step 7: Atualizar o Google Sheet

  1. Adicione o nó “Google Sheets”
  2. Operação: Update
  3. Mapeie os resultados de volta para as linhas originais
Ou crie planilhas separadas para cada categoria:
  • E-mails Válidos → Planilha “Valid”
  • E-mails Inválidos → Planilha “Invalid”
  • E-mails Arriscados → Planilha “Risky”

​
Como verificar e-mails de um formulário em tempo real?

Para verificar e-mails à medida que os usuários enviam formulários, acione o fluxo de trabalho com um webhook e verifique cada endereço individualmente:

​
Fluxo de trabalho:

  1. Webhook Trigger: Recebe envios de formulários
  2. Extract Email: Obtém o e-mail dos dados do formulário
  3. Verify: Chama o /email/verify/single da Enrow
  4. Decision:
    • Válido → Salva no CRM (Salesforce, HubSpot, etc.)
    • Inválido → Envia resposta de erro ou sinaliza para revisão
// In Function node after verification
if ($json.status === 'valid' && $json.is_deliverable) {
  return [
    {
      json: {
        action: 'accept',
        email: $json.email
      }
    }
  ];
} else {
  return [
    {
      json: {
        action: 'reject',
        email: $json.email,
        reason: 'Invalid or undeliverable email'
      }
    }
  ];
}
A verificação de endereço único usa o endpoint Verificar E-mail. Para enviar leads aceitos ao seu CRM, consulte as integrações HubSpot e Salesforce.

​
Como exportar a lista limpa?

Depois que os resultados forem categorizados, você pode exportar a lista limpa no formato que sua stack precisar.

​
Opção 1: Google Sheets

Já está pronto! Os resultados estão na sua planilha.

​
Opção 2: Exportação para CSV

  1. Adicione o nó “Move Binary Data”
  2. Adicione o nó “Write Binary File”
  3. Salve no disco ou envie por e-mail

​
Opção 3: Enviar para Plataforma de E-mail

  1. Adicione o nó “HTTP Request” para a API da sua plataforma de e-mail
  2. Exemplos:
    • Mailchimp: Adicionar ao público
    • SendGrid: Atualizar contatos
    • Customer.io: Sincronizar atributos

​
Como acompanhar as métricas de verificação?

Adicione um nó de resumo para calcular as métricas de entregabilidade de cada execução: 
// Function node
const results = $input.all()[0].json.results;
const summary = {
  timestamp: new Date().toISOString(),
  total_verified: results.length,
  valid: results.filter(r => r.status === 'valid').length,
  invalid: results.filter(r => r.status === 'invalid').length,
  risky: results.filter(r => r.status === 'risky').length,
  disposable: results.filter(r => r.metadata?.is_disposable).length,
  role_based: results.filter(r => r.metadata?.is_role).length,
  free_provider: results.filter(r => r.metadata?.is_free).length
};

summary.valid_rate = (summary.valid / summary.total_verified * 100).toFixed(2) + '%';
summary.invalid_rate = (summary.invalid / summary.total_verified * 100).toFixed(2) + '%';

return [{ json: summary }];
Envie este resumo para:
  • Slack: Publicar resumo no canal
  • E-mail: Relatórios diários/semanais
  • Banco de dados: Acompanhar ao longo do tempo

​
Como reduzir o uso de créditos?

A verificação consome créditos por e-mail, então reduza o trabalho antes de cada execução. Três táticas ajudam a manter os custos baixos.

​
Remover Duplicatas Antes de Verificar

// Function node before verification
const emails = $input.all().map(item => item.json.Email);
const unique = [...new Set(emails)];

return unique.map(email => ({ json: { Email: email } }));
Remover duplicatas economiza créditos ao verificar cada endereço apenas uma vez.

​
Armazenar Resultados em Cache

Guarde os resultados de verificação por 30-90 dias: 
// Check cache before API call
const cached = await redis.get(`verified:${email}`);
if (cached) {
  return JSON.parse(cached);
}

// Call API
const result = await verifyEmail(email);

// Cache result
await redis.setex(`verified:${email}`, 7776000, JSON.stringify(result)); // 90 days

return result;

​
Ignorar os Já Verificados

Verifique apenas e-mails com status vazio: 
// IF node
{{$json["Status"]}} === "" || {{$json["Status"]}} === null
Consulte Credits & billing para o custo de créditos por endpoint.

​
Boas Práticas

Sempre verifique sua lista 24-48 horas antes do envio. A validade dos e-mails pode mudar.
Decida com base no caso de uso:
  • B2B: E-mails de função (info@, support@) podem estar OK
  • B2C: Rejeite e-mails descartáveis
  • Cold outreach: Use apenas e-mails de alta confiança
Acompanhe as taxas de rejeição após o envio. Se estiverem altas, verifique sua lista novamente.
Verifique toda a sua lista a cada 3-6 meses para remover e-mails inválidos.

​
Solução de Problemas

A verificação está demorando muito?
  • Reduza o tamanho do lote para 50-100 e-mails
  • Aumente o tempo de espera entre os lotes
Alguns e-mails aparecem como “risky”?
  • Verifique metadata.is_disposable - podem ser e-mails temporários
  • Revise metadata.is_catch_all - servidores que aceitam tudo
Atingindo o limite de taxa?
  • Adicione atrasos entre os lotes
  • Reduza o tamanho do lote
  • Faça upgrade do seu plano da Enrow
Para limites de requisições e tratamento de 429, consulte Rate limits. Para códigos de status e formatos de erro, consulte Error handling.

​
FAQ

Use o nó Batch Emails para processar e-mails em grupos (o exemplo usa um tamanho de lote de 100). Para listas muito grandes, divida o trabalho em lotes menores e adicione uma espera mais longa entre as requisições para evitar atingir o limite de taxa. Consulte Rate limits para os limites de requisições.
valid significa que o endereço é entregável, invalid significa que ele rejeitaria, e risky cobre endereços catch-all, descartáveis ou baseados em função, onde a entregabilidade é incerta. Use os campos metadata (is_disposable, is_role, is_catch_all, is_free) para decidir como tratar os resultados arriscados no seu caso de uso.
Use Verificar E-mails em Massa para listas e limpezas agendadas, e Verificar E-mail para verificações em tempo real, como envios de formulários.
Remova endereços duplicados antes de verificar, armazene os resultados em cache por 30-90 dias e ignore as linhas que já têm um status. Consulte Credits & billing para os custos por endpoint.

​
Próximos passos

Enriquecimento de E-mail

Encontre e-mails para seus contatos com um fluxo de trabalho n8n.

Verificar E-mails em Massa

Explore a referência do endpoint de verificação em massa.

Authentication

Como enviar sua chave de API no cabeçalho x-api-key.

Webhooks

Seja notificado automaticamente quando um lote for concluído.