Skip to main content
Das Verifizieren von Leads vor einer Kampagne senkt Bounce-Raten und schützt Ihre Absenderreputation. Dieses Playbook erstellt einen n8n-Workflow, der eine E-Mail-Liste einliest, jede Adresse mit dem Email Verifier verifiziert, die Ergebnisse kategorisiert (gültig, ungültig, riskant) und eine bereinigte, versandfertige Liste exportiert. Wenn Sie neu bei n8n mit Enrow sind, beginnen Sie mit dem n8n-Einstiegsleitfaden.

​
Was werden Sie erstellen?

Sie erstellen einen Workflow, der:
  1. E-Mail-Liste einliest aus Google Sheets oder CSV
  2. Jede E-Mail verifiziert mit Enrow
  3. Ergebnisse kategorisiert (gültig, ungültig, riskant)
  4. Bereinigte Liste exportiert bereit für Kampagnen
Erstellungsdauer: 10 Minuten Schwierigkeitsgrad: Einsteiger

​
Wann sollten Sie diesen Workflow verwenden?

Verwenden Sie diesen Workflow immer dann, wenn die E-Mail-Zustellbarkeit für einen nachgelagerten Prozess wichtig ist. Häufige Anwendungsfälle:
  • E-Mail-Listen vor Marketingkampagnen bereinigen
  • Formulareinsendungen in Echtzeit verifizieren
  • Datenbankhygiene aufrechterhalten
  • Bounce-Raten reduzieren

​
Was benötigen Sie, bevor Sie beginnen?

Bevor Sie den Workflow erstellen, stellen Sie sicher, dass Sie Folgendes haben: Der Enrow-API-Schlüssel authentifiziert jede Anfrage über den x-api-key-Header. Unter Authentifizierung erfahren Sie, wie Sie den API-Schlüssel abrufen und übergeben, und unter Credits & Abrechnung, wie Verifizierungs-Credits verbraucht werden.

​
Wie richten Sie das Google Sheet ein?

Erstellen Sie ein Sheet mit E-Mail-Adressen und leeren Spalten für die Ergebnisse:
EmailStatusDeliverableRisk Factors
john@example.com
invalid@fake.com
temp@tempmail.com

​
Wie erstellen Sie den Workflow in 5 Minuten?

Der schnellste Weg ist, einen fertigen Workflow zu importieren, Ihre Anmeldedaten zu konfigurieren und ihn auszuführen.

​
Schritt 1: Workflow importieren

Kopieren und importieren Sie diesen 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}]]
    }
  }
}

​
Schritt 2: Konfigurieren

  1. Ersetzen Sie YOUR_SHEET_ID durch Ihre Google-Sheet-ID
  2. Fügen Sie Ihren Enrow-API-Schlüssel zur Header-Auth-Anmeldeinformation hinzu
  3. Testen Sie zunächst mit einigen wenigen E-Mails

​
Schritt 3: Ausführen

  1. Klicken Sie auf “Execute Workflow”
  2. Warten Sie, bis die Verifizierung abgeschlossen ist
  3. Prüfen Sie die Ergebnisse in Ihrem Google Sheet

​
Wie erstellen Sie den Workflow Schritt für Schritt?

Wenn Sie den Workflow lieber Knoten für Knoten erstellen möchten, folgen Sie der detaillierten Anleitung unten.

​
Schritt 1: E-Mail-Liste einlesen

Google Sheets:
  1. Fügen Sie einen “Google Sheets”-Knoten hinzu
  2. Operation: Read
  3. Wählen Sie Ihre Tabelle aus
  4. Bereich: Sheet1!A:A (nur E-Mail-Spalte)
CSV-Datei:
  1. Fügen Sie einen “Read Binary Files”-Knoten hinzu
  2. Fügen Sie einen “CSV to JSON”-Knoten hinzu
  3. Mappen Sie das E-Mail-Feld

​
Schritt 2: Batches erstellen

Für eine bessere Performance verarbeiten Sie E-Mails in Batches:
  1. Fügen Sie einen “Split In Batches”-Knoten hinzu
  2. Batch-Größe: 100 (oder weniger für schnellere Ergebnisse)
Dies sendet jeweils 100 E-Mails an Enrow.

​
Schritt 3: Mit der Enrow-Bulk-API verifizieren

  1. Fügen Sie einen “HTTP Request”-Knoten hinzu
  2. Konfigurieren:
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) }}
}
Dies gibt sofort eine batch_id zurück. Unter E-Mails per Bulk verifizieren finden Sie die vollständige Anfrage- und Antwortreferenz.

​
Schritt 4: Auf Ergebnisse warten

Fügen Sie einen “Wait”-Knoten mit 10-15 Sekunden Verzögerung hinzu. Bei großen Batches warten Sie länger. Für ein ereignisgesteuertes Abrufen anstelle von Polling übergeben Sie eine Webhook-URL in der Anfrage – siehe So funktionieren Webhooks.

​
Schritt 5: Ergebnisse abrufen

  1. Fügen Sie einen “HTTP Request”-Knoten hinzu
  2. Konfigurieren:
Method: GET
URL: https://api.enrow.io/email/verify/bulk?id={{$json["batch_id"]}}
Authentication: Header Auth (reuse credential)
Der Endpunkt Bulk-Verifizierungen abrufen gibt die Verifizierungsergebnisse für den Batch zurück.

​
Schritt 6: Ergebnisse verarbeiten

Fügen Sie einen “Function”-Knoten hinzu, um E-Mails zu kategorisieren: 
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)
    }
  }
];

​
Schritt 7: Google Sheet aktualisieren

  1. Fügen Sie einen “Google Sheets”-Knoten hinzu
  2. Operation: Update
  3. Mappen Sie die Ergebnisse zurück auf die ursprünglichen Zeilen
Oder erstellen Sie separate Sheets für jede Kategorie:
  • Gültige E-Mails → Sheet “Valid”
  • Ungültige E-Mails → Sheet “Invalid”
  • Riskante E-Mails → Sheet “Risky”

​
Wie verifizieren Sie E-Mails aus einem Formular in Echtzeit?

Um E-Mails zu verifizieren, während Nutzer Formulare absenden, lösen Sie den Workflow per Webhook aus und verifizieren Sie jede Adresse einzeln:

​
Workflow:

  1. Webhook-Trigger: Empfängt Formulareinsendungen
  2. E-Mail extrahieren: E-Mail aus den Formulardaten holen
  3. Verifizieren: Enrow /email/verify/single aufrufen
  4. Entscheidung:
    • Gültig → In CRM speichern (Salesforce, HubSpot usw.)
    • Ungültig → Fehlerantwort senden oder zur Prüfung markieren
// 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'
      }
    }
  ];
}
Die Verifizierung einzelner Adressen verwendet den Endpunkt Einzelne E-Mail verifizieren. Um akzeptierte Leads in Ihr CRM zu übertragen, siehe die Integrationen für HubSpot und Salesforce.

​
Wie exportieren Sie die bereinigte Liste?

Sobald die Ergebnisse kategorisiert sind, können Sie die bereinigte Liste in dem Format exportieren, das Ihr Stack benötigt.

​
Option 1: Google Sheets

Bereits erledigt! Die Ergebnisse stehen in Ihrem Sheet.

​
Option 2: CSV-Export

  1. Fügen Sie einen “Move Binary Data”-Knoten hinzu
  2. Fügen Sie einen “Write Binary File”-Knoten hinzu
  3. Auf Festplatte speichern oder per E-Mail versenden

​
Option 3: An E-Mail-Plattform senden

  1. Fügen Sie einen “HTTP Request”-Knoten für die API Ihrer E-Mail-Plattform hinzu
  2. Beispiele:
    • Mailchimp: Zur Audience hinzufügen
    • SendGrid: Kontakte aktualisieren
    • Customer.io: Attribute synchronisieren

​
Wie verfolgen Sie Verifizierungsmetriken?

Fügen Sie einen Zusammenfassungsknoten hinzu, um für jeden Lauf Zustellbarkeitsmetriken zu berechnen: 
// 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 }];
Senden Sie diese Zusammenfassung an:
  • Slack: Zusammenfassung im Channel posten
  • E-Mail: Tägliche/wöchentliche Berichte
  • Datenbank: Über die Zeit hinweg verfolgen

​
Wie reduzieren Sie den Credit-Verbrauch?

Die Verifizierung verbraucht Credits pro E-Mail, reduzieren Sie also den Aufwand vor jedem Lauf. Drei Taktiken halten die Kosten niedrig.

​
Vor der Verifizierung deduplizieren

// 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 } }));
Das Entfernen von Duplikaten spart Credits, da jede Adresse nur einmal verifiziert wird.

​
Ergebnisse zwischenspeichern

Speichern Sie Verifizierungsergebnisse für 30-90 Tage: 
// 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;

​
Bereits verifizierte überspringen

Verifizieren Sie nur E-Mails mit leerem Status: 
// IF node
{{$json["Status"]}} === "" || {{$json["Status"]}} === null
Unter Credits & Abrechnung finden Sie die Credit-Kosten pro Endpunkt.

​
Best Practices

Verifizieren Sie Ihre Liste immer 24-48 Stunden vor dem Versand. Die Gültigkeit von E-Mails kann sich ändern.
Entscheiden Sie je nach Anwendungsfall:
  • B2B: Rollen-E-Mails (info@, support@) sind möglicherweise in Ordnung
  • B2C: Wegwerf-E-Mails ablehnen
  • Cold Outreach: Nur E-Mails mit hoher Konfidenz verwenden
Verfolgen Sie die Bounce-Raten nach dem Versand. Wenn sie hoch sind, verifizieren Sie Ihre Liste erneut.
Verifizieren Sie Ihre gesamte Liste alle 3-6 Monate, um ungültige E-Mails zu entfernen.

​
Fehlerbehebung

Verifizierung dauert zu lange?
  • Batch-Größe auf 50-100 E-Mails reduzieren
  • Wartezeit zwischen Batches erhöhen
Einige E-Mails werden als “risky” angezeigt?
  • metadata.is_disposable prüfen – könnten temporäre E-Mails sein
  • metadata.is_catch_all überprüfen – Accept-all-Server
Werden Sie ratenbegrenzt?
  • Verzögerungen zwischen Batches hinzufügen
  • Batch-Größe reduzieren
  • Ihren Enrow-Plan upgraden
Für Anfragenobergrenzen und den Umgang mit 429 siehe Rate Limits. Für Statuscodes und Fehlerformate siehe Fehlerbehandlung.

​
FAQ

Verwenden Sie den Batch-Emails-Knoten, um E-Mails in Gruppen zu verarbeiten (das Beispiel verwendet eine Batch-Größe von 100). Bei sehr großen Listen teilen Sie die Arbeit in kleinere Batches auf und fügen Sie eine längere Wartezeit zwischen den Anfragen ein, um eine Ratenbegrenzung zu vermeiden. Unter Rate Limits finden Sie die Anfragenobergrenzen.
valid bedeutet, dass die Adresse zustellbar ist, invalid bedeutet, dass sie zurückprallen würde, und risky umfasst Catch-all-, Wegwerf- oder rollenbasierte Adressen, bei denen die Zustellbarkeit unsicher ist. Nutzen Sie die metadata-Felder (is_disposable, is_role, is_catch_all, is_free), um zu entscheiden, wie Sie riskante Ergebnisse für Ihren Anwendungsfall behandeln.
Verwenden Sie E-Mails per Bulk verifizieren für Listen und geplante Bereinigungen und Einzelne E-Mail verifizieren für Echtzeitprüfungen wie Formulareinsendungen.
Deduplizieren Sie Adressen vor der Verifizierung, speichern Sie Ergebnisse für 30-90 Tage zwischen und überspringen Sie Zeilen, die bereits einen Status haben. Unter Credits & Abrechnung finden Sie die Kosten pro Endpunkt.

​
Nächste Schritte

E-Mail-Anreicherung

Finden Sie E-Mails für Ihre Kontakte mit einem n8n-Workflow.

E-Mails per Bulk verifizieren

Erkunden Sie die Referenz des Bulk-Verifizierungsendpunkts.

Authentifizierung

So übergeben Sie Ihren API-Schlüssel im x-api-key-Header.

Webhooks

Werden Sie automatisch benachrichtigt, wenn ein Batch abgeschlossen ist.