Skip to main content
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, 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.

​
¿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: La clave de API de Enrow autentica cada solicitud a través del header x-api-key. Consulta Autenticación para saber cómo obtener y pasar la clave de API, y Créditos y facturación 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:
EmailStatusDeliverableRisk Factors
john@example.com
invalid@fake.com
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: 
{
  "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:
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 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.

​
Paso 5: Obtener los resultados

  1. Añade el nodo “HTTP Request”
  2. Configura:
Method: GET
URL: https://api.enrow.io/email/verify/bulk?id={{$json["batch_id"]}}
Authentication: Header Auth (reuse credential)
El endpoint Obtener verificaciones devuelve los resultados de verificación del lote.

​
Paso 6: Procesar los resultados

Añade el nodo “Function” para categorizar los correos: 
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:

​
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
// 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. Para enviar los leads aceptados a tu CRM, consulta las integraciones de HubSpot y 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: 
// 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

// 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: 
// 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: 
// IF node
{{$json["Status"]}} === "" || {{$json["Status"]}} === null
Consulta Créditos y facturación para el costo en créditos por endpoint.

​
Buenas prácticas

Verifica siempre tu lista 24-48 horas antes de enviar. La validez de un correo puede cambiar.
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
Haz seguimiento de las tasas de rebote después de enviar. Si son altas, vuelve a verificar tu lista.
Verifica toda tu lista cada 3-6 meses para eliminar los correos inválidos.

​
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. Para los códigos de estado y los formatos de error, consulta Manejo de errores.

​
FAQ

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 para los topes de solicitudes.
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.
Usa Verificar correos para listas y limpiezas programadas, y Verificar correo para comprobaciones en tiempo real, como los envíos de formularios.
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 para los costos por endpoint.

​
Próximos pasos

Enriquecimiento de correos

Encuentra correos para tus contactos con un workflow de n8n.

Verificar correos

Explora la referencia del endpoint de verificación masiva.

Autenticación

Cómo pasar tu clave de API en el header x-api-key.

Webhooks

Recibe notificaciones automáticas cuando un lote se completa.