> ## Documentation Index
> Fetch the complete documentation index at: https://docs.enrow.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Verificação de Leads (n8n)

> Limpe e verifique listas de e-mails antes de campanhas com um fluxo de trabalho n8n que verifica leads em massa usando a API da Enrow e exporta uma lista entregável

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](/pt/api-reference/email-verifier/verify-bulk), 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](/pt/playbooks/n8n/getting-started).

## 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:

* n8n ([obter n8n](https://n8n.io))
* Chave de API da Enrow ([obter chave](https://app.enrow.io/settings/api-keys))
* Lista de e-mails (Google Sheet ou CSV)

A chave de API da Enrow autentica cada requisição através do cabeçalho `x-api-key`. Consulte [Authentication](/pt/authentication) para saber como recuperar e enviar a chave de API, e [Credits & billing](/pt/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:

| Email                                         | Status | Deliverable | Risk Factors |
| --------------------------------------------- | ------ | ----------- | ------------ |
| [john@example.com](mailto:john@example.com)   |        |             |              |
| [invalid@fake.com](mailto:invalid@fake.com)   |        |             |              |
| [temp@tempmail.com](mailto: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:

```json theme={null}
{
  "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:

```javascript theme={null}
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](/pt/api-reference/email-verifier/verify-bulk) 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](/pt/how-webhooks-work).

### Step 5: Buscar os Resultados

1. Adicione o nó **"HTTP Request"**
2. Configure:

```javascript theme={null}
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](/pt/api-reference/email-verifier/get-bulk-verifications) retorna os resultados de verificação do lote.

### Step 6: Processar os Resultados

Adicione o nó **"Function"** para categorizar os e-mails:

```javascript theme={null}
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:

```mermaid theme={null}
graph LR
    A[Webhook] --> B[Receive Form Data]
    B --> C[Verify Email]
    C --> D{Valid?}
    D -->|Yes| E[Save to CRM]
    D -->|No| F[Reject Submission]
```

### 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

```javascript theme={null}
// 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](/pt/api-reference/email-verifier/verify-single). Para enviar leads aceitos ao seu CRM, consulte as integrações [HubSpot](/pt/integrations/crm/hubspot) e [Salesforce](/pt/integrations/crm/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:

```javascript theme={null}
// 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

```javascript theme={null}
// 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:

```javascript theme={null}
// 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:

```javascript theme={null}
// IF node
{{$json["Status"]}} === "" || {{$json["Status"]}} === null
```

Consulte [Credits & billing](/pt/credits-billing) para o custo de créditos por endpoint.

## Boas Práticas

<AccordionGroup>
  <Accordion title="Verifique Antes das Campanhas">
    Sempre verifique sua lista 24-48 horas antes do envio. A validade dos e-mails pode mudar.
  </Accordion>

  <Accordion title="Lide com E-mails Arriscados">
    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
  </Accordion>

  <Accordion title="Monitore a Entregabilidade">
    Acompanhe as taxas de rejeição após o envio. Se estiverem altas, verifique sua lista novamente.
  </Accordion>

  <Accordion title="Limpeza Regular">
    Verifique toda a sua lista a cada 3-6 meses para remover e-mails inválidos.
  </Accordion>
</AccordionGroup>

## 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](/pt/rate-limits). Para códigos de status e formatos de erro, consulte [Error handling](/pt/error-handling).

## FAQ

<AccordionGroup>
  <Accordion title="Quantos e-mails posso verificar em um lote?">
    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](/pt/rate-limits) para os limites de requisições.
  </Accordion>

  <Accordion title="O que significam os status válido, inválido e arriscado?">
    `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.
  </Accordion>

  <Accordion title="Devo verificar um único e-mail ou usar a verificação em massa?">
    Use [Verificar E-mails em Massa](/pt/api-reference/email-verifier/verify-bulk) para listas e limpezas agendadas, e [Verificar E-mail](/pt/api-reference/email-verifier/verify-single) para verificações em tempo real, como envios de formulários.
  </Accordion>

  <Accordion title="Como evito desperdiçar créditos?">
    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](/pt/credits-billing) para os custos por endpoint.
  </Accordion>
</AccordionGroup>

## Próximos passos

<CardGroup cols={2}>
  <Card title="Enriquecimento de E-mail" icon="envelope-circle-check" href="/pt/playbooks/n8n/email-enrichment-workflow">
    Encontre e-mails para seus contatos com um fluxo de trabalho n8n.
  </Card>

  <Card title="Verificar E-mails em Massa" icon="code" href="/pt/api-reference/email-verifier/verify-bulk">
    Explore a referência do endpoint de verificação em massa.
  </Card>

  <Card title="Authentication" icon="key" href="/pt/authentication">
    Como enviar sua chave de API no cabeçalho x-api-key.
  </Card>

  <Card title="Webhooks" icon="bell" href="/pt/how-webhooks-work">
    Seja notificado automaticamente quando um lote for concluído.
  </Card>
</CardGroup>