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

# Verificación de leads (n8n)

> Limpia y verifica listas de correos antes de tus campañas con un workflow de n8n que verifica leads de forma masiva usando la API de Enrow y exporta una lista entregable

Verificar los leads antes de una campaña reduce las tasas de rebote y protege la reputación de tu remitente. Este playbook construye un workflow de n8n que lee una lista de correos, verifica cada dirección con el [Email Verifier](/es/api-reference/email-verifier/verify-bulk), categoriza los resultados (válidos, inválidos, riesgosos) y exporta una lista limpia lista para enviar. Si eres nuevo en n8n con Enrow, empieza con la [guía de introducción a n8n](/es/playbooks/n8n/getting-started).

## ¿Qué vas a construir?

Vas a construir un workflow que:

1. **Lee una lista de correos** desde Google Sheets o CSV
2. **Verifica cada correo** usando Enrow
3. **Categoriza los resultados** (válidos, inválidos, riesgosos)
4. **Exporta una lista limpia** lista para campañas

**Tiempo de construcción**: 10 minutos
**Dificultad**: Principiante

## ¿Cuándo deberías usar este workflow?

Usa este workflow siempre que la entregabilidad del correo sea importante para un proceso posterior. Casos de uso comunes:

* Limpiar listas de correos antes de campañas de marketing
* Verificar envíos de formularios en tiempo real
* Mantener la higiene de la base de datos
* Reducir las tasas de rebote

## ¿Qué necesitas antes de empezar?

Antes de construir el workflow, asegúrate de tener lo siguiente:

* n8n ([obtener n8n](https://n8n.io))
* Clave de API de Enrow ([obtener clave](https://app.enrow.io/settings/api-keys))
* Lista de correos (Google Sheet o CSV)

La clave de API de Enrow autentica cada solicitud a través del header `x-api-key`. Consulta [Autenticación](/es/authentication) para saber cómo obtener y pasar la clave de API, y [Créditos y facturación](/es/credits-billing) para entender cómo se consumen los créditos de verificación.

## ¿Cómo configuras el Google Sheet?

Crea una hoja con direcciones de correo y columnas vacías para los 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) |        |             |              |

## ¿Cómo construyes el workflow en 5 minutos?

La vía más rápida es importar un workflow ya listo, configurar tus credenciales y ejecutarlo.

### Paso 1: Importar el workflow

Copia e importa este workflow en 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}]]
    }
  }
}
```

### Paso 2: Configurar

1. Reemplaza `YOUR_SHEET_ID` con el ID de tu Google Sheet
2. Añade tu clave de API de Enrow a la credencial Header Auth
3. Prueba primero con unos pocos correos

### Paso 3: Ejecutar

1. Haz clic en **"Execute Workflow"**
2. Espera a que termine la verificación
3. Revisa los resultados en tu Google Sheet

## ¿Cómo construyes el workflow paso a paso?

Si prefieres construir el workflow nodo por nodo, sigue la guía detallada a continuación.

### Paso 1: Leer la lista de correos

**Google Sheets:**

1. Añade el nodo **"Google Sheets"**
2. Operación: **Read**
3. Selecciona tu hoja de cálculo
4. Rango: `Sheet1!A:A` (solo la columna de correos)

**Archivo CSV:**

1. Añade el nodo **"Read Binary Files"**
2. Añade el nodo **"CSV to JSON"**
3. Mapea el campo de correo

### Paso 2: Crear lotes

Para un mejor rendimiento, procesa los correos en lotes:

1. Añade el nodo **"Split In Batches"**
2. Tamaño del lote: **100** (o menos para resultados más rápidos)

Esto envía 100 correos a la vez a Enrow.

### Paso 3: Verificar con la API masiva de Enrow

1. Añade el nodo **"HTTP Request"**
2. Configura:

```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) }}
}
```

Esto devuelve un `batch_id` de inmediato. Consulta [Verificar correos](/es/api-reference/email-verifier/verify-bulk) para ver la referencia completa de solicitud y respuesta.

### Paso 4: Esperar los resultados

Añade el nodo **"Wait"** con un retraso de 10-15 segundos. Para lotes grandes, espera más tiempo. Para una recuperación basada en eventos en lugar de sondeo, pasa una URL de webhook en la solicitud; consulta [Cómo funcionan los webhooks](/es/how-webhooks-work).

### Paso 5: Obtener los resultados

1. Añade el nodo **"HTTP Request"**
2. Configura:

```javascript theme={null}
Method: GET
URL: https://api.enrow.io/email/verify/bulk?id={{$json["batch_id"]}}
Authentication: Header Auth (reuse credential)
```

El endpoint [Obtener verificaciones](/es/api-reference/email-verifier/get-bulk-verifications) devuelve los resultados de verificación del lote.

### Paso 6: Procesar los resultados

Añade el nodo **"Function"** para categorizar los correos:

```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)
    }
  }
];
```

### Paso 7: Actualizar el Google Sheet

1. Añade el nodo **"Google Sheets"**
2. Operación: **Update**
3. Mapea los resultados de vuelta a las filas originales

O crea hojas separadas para cada categoría:

* **Correos válidos** → Hoja "Valid"
* **Correos inválidos** → Hoja "Invalid"
* **Correos riesgosos** → Hoja "Risky"

## ¿Cómo verificas los correos de un formulario en tiempo real?

Para verificar los correos a medida que los usuarios envían formularios, activa el workflow con un webhook y verifica cada dirección de forma individual:

```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]
```

### Workflow:

1. **Webhook Trigger**: Recibe los envíos de formularios
2. **Extract Email**: Obtiene el correo de los datos del formulario
3. **Verify**: Llama a `/email/verify/single` de Enrow
4. **Decisión**:
   * Válido → Guardar en el CRM (Salesforce, HubSpot, etc.)
   * Inválido → Enviar una respuesta de error o marcar para revisión

```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'
      }
    }
  ];
}
```

La verificación de una sola dirección usa el endpoint [Verificar correo](/es/api-reference/email-verifier/verify-single). Para enviar los leads aceptados a tu CRM, consulta las integraciones de [HubSpot](/es/integrations/crm/hubspot) y [Salesforce](/es/integrations/crm/salesforce).

## ¿Cómo exportas la lista limpia?

Una vez categorizados los resultados, puedes exportar la lista limpia en el formato que necesite tu stack.

### Opción 1: Google Sheets

¡Ya está hecho! Los resultados están en tu hoja.

### Opción 2: Exportación a CSV

1. Añade el nodo **"Move Binary Data"**
2. Añade el nodo **"Write Binary File"**
3. Guarda en disco o envía por correo

### Opción 3: Enviar a una plataforma de correo

1. Añade el nodo **"HTTP Request"** para la API de tu plataforma de correo
2. Ejemplos:
   * **Mailchimp**: Añadir a la audiencia
   * **SendGrid**: Actualizar contactos
   * **Customer.io**: Sincronizar atributos

## ¿Cómo realizas el seguimiento de las métricas de verificación?

Añade un nodo de resumen para calcular las métricas de entregabilidad de cada ejecución:

```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 }];
```

Envía este resumen a:

* **Slack**: Publica el resumen en un canal
* **Email**: Informes diarios/semanales
* **Base de datos**: Seguimiento a lo largo del tiempo

## ¿Cómo reduces el uso de créditos?

La verificación consume créditos por correo, así que reduce el trabajo antes de cada ejecución. Tres tácticas mantienen bajos los costos.

### Eliminar duplicados 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 } }));
```

Eliminar duplicados ahorra créditos al verificar cada dirección una sola vez.

### Almacenar los resultados en caché

Guarda los resultados de verificación durante 30-90 días:

```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;
```

### Omitir los ya verificados

Verifica solo los correos con estado vacío:

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

Consulta [Créditos y facturación](/es/credits-billing) para el costo en créditos por endpoint.

## Buenas prácticas

<AccordionGroup>
  <Accordion title="Verifica antes de las campañas">
    Verifica siempre tu lista 24-48 horas antes de enviar. La validez de un correo puede cambiar.
  </Accordion>

  <Accordion title="Gestiona los correos riesgosos">
    Decide según el caso de uso:

    * **B2B**: Los correos de rol (info@, support@) pueden estar bien
    * **B2C**: Rechaza los correos desechables
    * **Cold outreach**: Usa solo correos de alta confianza
  </Accordion>

  <Accordion title="Monitorea la entregabilidad">
    Haz seguimiento de las tasas de rebote después de enviar. Si son altas, vuelve a verificar tu lista.
  </Accordion>

  <Accordion title="Limpieza periódica">
    Verifica toda tu lista cada 3-6 meses para eliminar los correos inválidos.
  </Accordion>
</AccordionGroup>

## Solución de problemas

**¿La verificación tarda demasiado?**

* Reduce el tamaño del lote a 50-100 correos
* Aumenta el tiempo de espera entre lotes

**¿Algunos correos aparecen como "risky"?**

* Revisa `metadata.is_disposable` — podrían ser correos temporales
* Revisa `metadata.is_catch_all` — servidores que aceptan todo

**¿Estás recibiendo límites de tasa?**

* Añade retrasos entre lotes
* Reduce el tamaño del lote
* Mejora tu plan de Enrow

Para los topes de solicitudes y el manejo del `429`, consulta [Límites de tasa](/es/rate-limits). Para los códigos de estado y los formatos de error, consulta [Manejo de errores](/es/error-handling).

## FAQ

<AccordionGroup>
  <Accordion title="¿Cuántos correos puedo verificar en un lote?">
    Usa el nodo Batch Emails para procesar los correos en grupos (el ejemplo usa un tamaño de lote de 100). Para listas muy grandes, divide el trabajo en lotes más pequeños y añade una espera más larga entre solicitudes para evitar los límites de tasa. Consulta [Límites de tasa](/es/rate-limits) para los topes de solicitudes.
  </Accordion>

  <Accordion title="¿Qué significan los estados válido, inválido y riesgoso?">
    `valid` significa que la dirección es entregable, `invalid` significa que rebotaría, y `risky` cubre direcciones de catch-all, desechables o de rol donde la entregabilidad es incierta. Usa los campos de `metadata` (`is_disposable`, `is_role`, `is_catch_all`, `is_free`) para decidir cómo tratar los resultados riesgosos en tu caso de uso.
  </Accordion>

  <Accordion title="¿Debería verificar un solo correo o usar el modo masivo?">
    Usa [Verificar correos](/es/api-reference/email-verifier/verify-bulk) para listas y limpiezas programadas, y [Verificar correo](/es/api-reference/email-verifier/verify-single) para comprobaciones en tiempo real, como los envíos de formularios.
  </Accordion>

  <Accordion title="¿Cómo evito desperdiciar créditos?">
    Elimina los duplicados antes de verificar, almacena los resultados en caché durante 30-90 días y omite las filas que ya tienen un estado. Consulta [Créditos y facturación](/es/credits-billing) para los costos por endpoint.
  </Accordion>
</AccordionGroup>

## Próximos pasos

<CardGroup cols={2}>
  <Card title="Enriquecimiento de correos" icon="envelope-circle-check" href="/es/playbooks/n8n/email-enrichment-workflow">
    Encuentra correos para tus contactos con un workflow de n8n.
  </Card>

  <Card title="Verificar correos" icon="code" href="/es/api-reference/email-verifier/verify-bulk">
    Explora la referencia del endpoint de verificación masiva.
  </Card>

  <Card title="Autenticación" icon="key" href="/es/authentication">
    Cómo pasar tu clave de API en el header x-api-key.
  </Card>

  <Card title="Webhooks" icon="bell" href="/es/how-webhooks-work">
    Recibe notificaciones automáticas cuando un lote se completa.
  </Card>
</CardGroup>