Skip to main content
Leads verifiëren voor een campagne verlaagt bouncepercentages en beschermt je afzenderreputatie. Deze playbook bouwt een n8n-workflow die een e-maillijst inleest, elk adres verifieert met de Email Verifier, de resultaten categoriseert (valid, invalid, risky) en een schone, verzendklare lijst exporteert. Ben je nieuw met n8n in combinatie met Enrow, begin dan met de introductiegids voor n8n.

​
Wat ga je bouwen?

Je bouwt een workflow die:
  1. De e-maillijst inleest vanuit Google Sheets of CSV
  2. Elke e-mail verifieert met Enrow
  3. Resultaten categoriseert (valid, invalid, risky)
  4. Een schone lijst exporteert die klaar is voor campagnes
Bouwtijd: 10 minuten Moeilijkheidsgraad: Beginner

​
Wanneer gebruik je deze workflow?

Gebruik deze workflow telkens wanneer e-mailbezorgbaarheid van belang is voor een vervolgproces. Veelvoorkomende use cases:
  • E-maillijsten opschonen voor marketingcampagnes
  • Formulierinzendingen in realtime verifiëren
  • De hygiëne van je database op orde houden
  • Bouncepercentages verlagen

​
Wat heb je nodig voordat je begint?

Zorg voordat je de workflow bouwt dat je het volgende hebt: De Enrow API-sleutel authenticeert elk verzoek via de x-api-key-header. Zie Authentication voor hoe je de API-sleutel ophaalt en meegeeft, en Credits & billing om te begrijpen hoe verificatiecredits worden verbruikt.

​
Hoe stel je de Google Sheet in?

Maak een sheet met e-mailadressen en lege kolommen voor de resultaten:
EmailStatusDeliverableRisk Factors
john@example.com
invalid@fake.com
temp@tempmail.com

​
Hoe bouw je de workflow in 5 minuten?

De snelste weg is een kant-en-klare workflow importeren, je gegevens configureren en hem uitvoeren.

​
Stap 1: Workflow importeren

Kopieer en importeer deze workflow in 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}]]
    }
  }
}

​
Stap 2: Configureren

  1. Vervang YOUR_SHEET_ID door je Google Sheet-ID
  2. Voeg je Enrow API-sleutel toe aan de Header Auth-credential
  3. Test eerst met een paar e-mails

​
Stap 3: Uitvoeren

  1. Klik op “Execute Workflow”
  2. Wacht tot de verificatie is voltooid
  3. Controleer je Google Sheet op de resultaten

​
Hoe bouw je de workflow stap voor stap?

Wil je liever de workflow node voor node bouwen, volg dan de gedetailleerde gids hieronder.

​
Stap 1: E-maillijst inlezen

Google Sheets:
  1. Voeg een “Google Sheets”-node toe
  2. Operation: Read
  3. Selecteer je spreadsheet
  4. Range: Sheet1!A:A (alleen de e-mailkolom)
CSV-bestand:
  1. Voeg een “Read Binary Files”-node toe
  2. Voeg een “CSV to JSON”-node toe
  3. Map het e-mailveld

​
Stap 2: Batches maken

Voor betere prestaties verwerk je e-mails in batches:
  1. Voeg een “Split In Batches”-node toe
  2. Batch Size: 100 (of minder voor snellere resultaten)
Hiermee stuur je 100 e-mails tegelijk naar Enrow.

​
Stap 3: Verifiëren met de Enrow Bulk API

  1. Voeg een “HTTP Request”-node toe
  2. Configureer:
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) }}
}
Dit geeft direct een batch_id terug. Zie E-mails in bulk verifiëren voor de volledige referentie van verzoek en respons.

​
Stap 4: Wachten op resultaten

Voeg een “Wait”-node toe met een vertraging van 10-15 seconden. Wacht bij grote batches langer. Voor event-gedreven ophalen in plaats van pollen geef je een webhook-URL mee in het verzoek — zie Hoe webhooks werken.

​
Stap 5: Resultaten ophalen

  1. Voeg een “HTTP Request”-node toe
  2. Configureer:
Method: GET
URL: https://api.enrow.io/email/verify/bulk?id={{$json["batch_id"]}}
Authentication: Header Auth (reuse credential)
Het Get Bulk Verifications-endpoint geeft de verificatieresultaten voor de batch terug.

​
Stap 6: Resultaten verwerken

Voeg een “Function”-node toe om e-mails te categoriseren: 
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)
    }
  }
];

​
Stap 7: Google Sheet bijwerken

  1. Voeg een “Google Sheets”-node toe
  2. Operation: Update
  3. Map de resultaten terug naar de oorspronkelijke rijen
Of maak aparte sheets voor elke categorie:
  • Valid Emails → Sheet “Valid”
  • Invalid Emails → Sheet “Invalid”
  • Risky Emails → Sheet “Risky”

​
Hoe verifieer je e-mails uit een formulier in realtime?

Om e-mails te verifiëren zodra gebruikers formulieren indienen, trigger je de workflow met een webhook en verifieer je elk adres afzonderlijk:

​
Workflow:

  1. Webhook Trigger: Ontvangt formulierinzendingen
  2. Extract Email: Haal de e-mail op uit de formuliergegevens
  3. Verify: Roep Enrow /email/verify/single aan
  4. Decision:
    • Valid → Opslaan in CRM (Salesforce, HubSpot, enz.)
    • Invalid → Stuur een foutmelding of markeer voor beoordeling
// 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'
      }
    }
  ];
}
Verificatie van één adres gebruikt het Eén e-mail verifiëren-endpoint. Om geaccepteerde leads naar je CRM te sturen, zie de integraties met HubSpot en Salesforce.

​
Hoe exporteer je de schone lijst?

Zodra de resultaten zijn gecategoriseerd, kun je de schone lijst exporteren in het formaat dat jouw stack nodig heeft.

​
Optie 1: Google Sheets

Al klaar! De resultaten staan in je sheet.

​
Optie 2: CSV-export

  1. Voeg een “Move Binary Data”-node toe
  2. Voeg een “Write Binary File”-node toe
  3. Sla op schijf op of verstuur via e-mail

​
Optie 3: Sturen naar e-mailplatform

  1. Voeg een “HTTP Request”-node toe voor de API van je e-mailplatform
  2. Voorbeelden:
    • Mailchimp: Toevoegen aan audience
    • SendGrid: Contacten bijwerken
    • Customer.io: Attributen synchroniseren

​
Hoe houd je verificatiemetrics bij?

Voeg een samenvattingsnode toe om bezorgbaarheidsmetrics per run te berekenen: 
// 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 }];
Stuur deze samenvatting naar:
  • Slack: Plaats de samenvatting in een kanaal
  • Email: Dagelijkse/wekelijkse rapporten
  • Database: Houd het in de tijd bij

​
Hoe verlaag je het creditverbruik?

Verificatie verbruikt credits per e-mail, dus beperk het werk voor elke run. Drie tactieken houden de kosten laag.

​
Dedupliceren voordat je verifieert

// 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 } }));
Door duplicaten te verwijderen bespaar je credits doordat elk adres maar één keer wordt geverifieerd.

​
Resultaten cachen

Bewaar verificatieresultaten 30-90 dagen: 
// 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;

​
Al geverifieerde overslaan

Verifieer alleen e-mails met een lege status: 
// IF node
{{$json["Status"]}} === "" || {{$json["Status"]}} === null
Zie Credits & billing voor de creditkosten per endpoint.

​
Best practices

Verifieer je lijst altijd 24-48 uur voor verzending. De geldigheid van een e-mail kan veranderen.
Beslis op basis van de use case:
  • B2B: Role-e-mails (info@, support@) zijn misschien oké
  • B2C: Weiger wegwerp-e-mails
  • Cold outreach: Gebruik alleen e-mails met hoge betrouwbaarheid
Houd bouncepercentages bij na verzending. Bij hoge percentages: verifieer je lijst opnieuw.
Verifieer je volledige lijst elke 3-6 maanden om ongeldige e-mails te verwijderen.

​
Problemen oplossen

Duurt de verificatie te lang?
  • Verklein de batchgrootte tot 50-100 e-mails
  • Verhoog de wachttijd tussen batches
Worden sommige e-mails als “risky” weergegeven?
  • Controleer metadata.is_disposable - mogelijk tijdelijke e-mails
  • Bekijk metadata.is_catch_all - accept-all-servers
Word je rate limited?
  • Voeg vertragingen toe tussen batches
  • Verklein de batchgrootte
  • Upgrade je Enrow-abonnement
Voor verzoeklimieten en de afhandeling van 429, zie Rate limits. Voor statuscodes en foutformaten, zie Error handling.

​
FAQ

Gebruik de Batch Emails-node om e-mails in groepen te verwerken (het voorbeeld gebruikt een batchgrootte van 100). Voor heel grote lijsten splits je het werk in kleinere batches en voeg je een langere wachttijd tussen verzoeken toe om rate limiting te voorkomen. Zie Rate limits voor de verzoeklimieten.
valid betekent dat het adres bezorgbaar is, invalid betekent dat het zou bouncen, en risky dekt catch-all-, wegwerp- of role-based adressen waarbij de bezorgbaarheid onzeker is. Gebruik de metadata-velden (is_disposable, is_role, is_catch_all, is_free) om te bepalen hoe je risky resultaten voor jouw use case behandelt.
Gebruik E-mails in bulk verifiëren voor lijsten en geplande opschoning, en Eén e-mail verifiëren voor realtime controles zoals formulierinzendingen.
Dedupliceer adressen voordat je verifieert, cache resultaten 30-90 dagen en sla rijen over die al een status hebben. Zie Credits & billing voor de kosten per endpoint.

​
Volgende stappen

E-mailverrijking

Vind e-mails voor je contacten met een n8n-workflow.

E-mails in bulk verifiëren

Verken de referentie van het bulkverificatie-endpoint.

Authentication

Hoe je je API-sleutel meegeeft in de x-api-key-header.

Webhooks

Word automatisch op de hoogte gesteld wanneer een batch is voltooid.