Skip to main content
Weryfikacja leadów przed kampanią obniża współczynnik odrzuceń i chroni reputację nadawcy. Ten playbook tworzy przepływ n8n, który odczytuje listę e-mail, weryfikuje każdy adres za pomocą Email Verifier, kategoryzuje wyniki (poprawne, niepoprawne, ryzykowne) i eksportuje czystą listę gotową do wysłania. Jeśli dopiero zaczynasz pracę z n8n i Enrow, zacznij od przewodnika wprowadzającego do n8n.

​
Co zbudujesz?

Zbudujesz przepływ, który:
  1. Odczytuje listę e-mail z Google Sheets lub pliku CSV
  2. Weryfikuje każdy adres e-mail za pomocą Enrow
  3. Kategoryzuje wyniki (poprawne, niepoprawne, ryzykowne)
  4. Eksportuje czystą listę gotową do kampanii
Czas budowy: 10 minut Poziom trudności: Początkujący

​
Kiedy warto użyć tego przepływu?

Użyj tego przepływu zawsze, gdy dostarczalność e-maili ma znaczenie dla dalszego procesu. Typowe przypadki użycia:
  • Oczyszczanie list e-mail przed kampaniami marketingowymi
  • Weryfikacja zgłoszeń z formularzy w czasie rzeczywistym
  • Utrzymanie higieny bazy danych
  • Obniżenie współczynnika odrzuceń

​
Czego potrzebujesz przed rozpoczęciem?

Przed zbudowaniem przepływu upewnij się, że masz następujące rzeczy: Klucz API Enrow uwierzytelnia każde żądanie za pomocą nagłówka x-api-key. Zobacz Uwierzytelnianie, aby dowiedzieć się, jak pobrać i przekazać klucz API, oraz Kredyty i rozliczenia, aby zrozumieć, jak zużywane są kredyty weryfikacyjne.

​
Jak skonfigurować arkusz Google Sheet?

Utwórz arkusz z adresami e-mail i pustymi kolumnami na wyniki:
EmailStatusDeliverableRisk Factors
john@example.com
invalid@fake.com
temp@tempmail.com

​
Jak zbudować przepływ w 5 minut?

Najszybsza droga to zaimportowanie gotowego przepływu, skonfigurowanie poświadczeń i jego uruchomienie.

​
Krok 1: Import przepływu

Skopiuj i zaimportuj ten przepływ do 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}]]
    }
  }
}

​
Krok 2: Konfiguracja

  1. Zastąp YOUR_SHEET_ID identyfikatorem swojego arkusza Google Sheet
  2. Dodaj swój klucz API Enrow do poświadczenia Header Auth
  3. Najpierw przetestuj na kilku adresach e-mail

​
Krok 3: Uruchomienie

  1. Kliknij “Execute Workflow”
  2. Poczekaj na zakończenie weryfikacji
  3. Sprawdź wyniki w swoim arkuszu Google Sheet

​
Jak zbudować przepływ krok po kroku?

Jeśli wolisz budować przepływ węzeł po węźle, postępuj zgodnie ze szczegółowym przewodnikiem poniżej.

​
Krok 1: Odczyt listy e-mail

Google Sheets:
  1. Dodaj węzeł “Google Sheets”
  2. Operacja: Read
  3. Wybierz swój arkusz kalkulacyjny
  4. Zakres: Sheet1!A:A (tylko kolumna z adresami e-mail)
Plik CSV:
  1. Dodaj węzeł “Read Binary Files”
  2. Dodaj węzeł “CSV to JSON”
  3. Zmapuj pole z adresem e-mail

​
Krok 2: Tworzenie partii

Dla lepszej wydajności przetwarzaj adresy e-mail w partiach:
  1. Dodaj węzeł “Split In Batches”
  2. Rozmiar partii: 100 (lub mniej dla szybszych wyników)
To wysyła 100 adresów e-mail naraz do Enrow.

​
Krok 3: Weryfikacja za pomocą Enrow Bulk API

  1. Dodaj węzeł “HTTP Request”
  2. Skonfiguruj:
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) }}
}
To natychmiast zwraca batch_id. Zobacz Masowa weryfikacja e-maili, aby zapoznać się z pełną dokumentacją żądania i odpowiedzi.

​
Krok 4: Oczekiwanie na wyniki

Dodaj węzeł “Wait” z opóźnieniem 10-15 sekund. W przypadku dużych partii odczekaj dłużej. Aby pobierać wyniki w oparciu o zdarzenia zamiast odpytywania, przekaż w żądaniu adres URL webhooka — zobacz Jak działają webhooki.

​
Krok 5: Pobranie wyników

  1. Dodaj węzeł “HTTP Request”
  2. Skonfiguruj:
Method: GET
URL: https://api.enrow.io/email/verify/bulk?id={{$json["batch_id"]}}
Authentication: Header Auth (reuse credential)
Punkt końcowy Pobierz masowe weryfikacje zwraca wyniki weryfikacji dla danej partii.

​
Krok 6: Przetwarzanie wyników

Dodaj węzeł “Function”, aby kategoryzować adresy e-mail: 
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)
    }
  }
];

​
Krok 7: Aktualizacja arkusza Google Sheet

  1. Dodaj węzeł “Google Sheets”
  2. Operacja: Update
  3. Zmapuj wyniki z powrotem do oryginalnych wierszy
Możesz też utworzyć osobne arkusze dla każdej kategorii:
  • Poprawne adresy e-mail → arkusz “Valid”
  • Niepoprawne adresy e-mail → arkusz “Invalid”
  • Ryzykowne adresy e-mail → arkusz “Risky”

​
Jak weryfikować adresy e-mail z formularza w czasie rzeczywistym?

Aby weryfikować adresy e-mail w momencie przesyłania formularzy przez użytkowników, uruchamiaj przepływ za pomocą webhooka i weryfikuj każdy adres osobno:

​
Przepływ:

  1. Webhook Trigger: Odbiera zgłoszenia z formularzy
  2. Extract Email: Pobiera adres e-mail z danych formularza
  3. Verify: Wywołuje Enrow /email/verify/single
  4. Decyzja:
    • Poprawny → Zapisz w CRM (Salesforce, HubSpot itp.)
    • Niepoprawny → Wyślij odpowiedź z błędem lub oznacz do przeglądu
// 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'
      }
    }
  ];
}
Weryfikacja pojedynczego adresu korzysta z punktu końcowego Weryfikacja pojedynczego e-maila. Aby przesyłać zaakceptowane leady do swojego CRM, zobacz integracje HubSpot i Salesforce.

​
Jak wyeksportować czystą listę?

Po skategoryzowaniu wyników możesz wyeksportować czystą listę w dowolnym formacie wymaganym przez Twój stos technologiczny.

​
Opcja 1: Google Sheets

Już gotowe! Wyniki znajdują się w Twoim arkuszu.

​
Opcja 2: Eksport do CSV

  1. Dodaj węzeł “Move Binary Data”
  2. Dodaj węzeł “Write Binary File”
  3. Zapisz na dysku lub wyślij e-mailem

​
Opcja 3: Wysyłka do platformy e-mail

  1. Dodaj węzeł “HTTP Request” dla API swojej platformy e-mail
  2. Przykłady:
    • Mailchimp: Dodaj do odbiorców
    • SendGrid: Zaktualizuj kontakty
    • Customer.io: Zsynchronizuj atrybuty

​
Jak śledzić metryki weryfikacji?

Dodaj węzeł podsumowujący, aby obliczyć metryki dostarczalności dla każdego uruchomienia: 
// 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 }];
Wyślij to podsumowanie do:
  • Slack: Opublikuj podsumowanie na kanale
  • Email: Raporty dzienne/tygodniowe
  • Baza danych: Śledzenie w czasie

​
Jak zmniejszyć zużycie kredytów?

Weryfikacja zużywa kredyty na każdy adres e-mail, więc ogranicz pracę przed każdym uruchomieniem. Trzy taktyki pozwalają utrzymać niskie koszty.

​
Usuwanie duplikatów przed weryfikacją

// 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 } }));
Usuwanie duplikatów oszczędza kredyty, weryfikując każdy adres tylko raz.

​
Buforowanie wyników

Przechowuj wyniki weryfikacji przez 30-90 dni: 
// 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;

​
Pomijanie już zweryfikowanych

Weryfikuj tylko adresy e-mail z pustym statusem: 
// IF node
{{$json["Status"]}} === "" || {{$json["Status"]}} === null
Zobacz Kredyty i rozliczenia, aby poznać koszt kredytów dla poszczególnych punktów końcowych.

​
Najlepsze praktyki

Zawsze weryfikuj swoją listę 24-48 godzin przed wysyłką. Ważność adresów e-mail może się zmienić.
Zdecyduj na podstawie przypadku użycia:
  • B2B: Adresy funkcyjne (info@, support@) mogą być w porządku
  • B2C: Odrzucaj jednorazowe adresy e-mail
  • Cold outreach: Używaj tylko adresów e-mail o wysokiej pewności
Śledź współczynnik odrzuceń po wysyłce. Jeśli jest wysoki, ponownie zweryfikuj swoją listę.
Weryfikuj całą listę co 3-6 miesięcy, aby usunąć niepoprawne adresy e-mail.

​
Rozwiązywanie problemów

Weryfikacja trwa zbyt długo?
  • Zmniejsz rozmiar partii do 50-100 adresów e-mail
  • Wydłuż czas oczekiwania między partiami
Niektóre adresy e-mail wyświetlają się jako “risky”?
  • Sprawdź metadata.is_disposable - mogą to być tymczasowe adresy e-mail
  • Przejrzyj metadata.is_catch_all - serwery typu accept-all
Otrzymujesz ograniczenia liczby żądań?
  • Dodaj opóźnienia między partiami
  • Zmniejsz rozmiar partii
  • Zaktualizuj swój plan Enrow
Informacje o limitach żądań i obsłudze kodu 429 znajdziesz w Limity zapytań. Kody statusu i formaty błędów opisano w Obsługa błędów.

​
FAQ

Użyj węzła Batch Emails, aby przetwarzać adresy e-mail w grupach (przykład używa rozmiaru partii 100). W przypadku bardzo dużych list podziel pracę na mniejsze partie i dodaj dłuższe oczekiwanie między żądaniami, aby uniknąć ograniczeń liczby żądań. Zobacz Limity zapytań, aby poznać górne limity żądań.
valid oznacza, że adres jest dostarczalny, invalid oznacza, że wysyłka zostałaby odrzucona, a risky obejmuje adresy typu catch-all, jednorazowe lub funkcyjne, gdzie dostarczalność jest niepewna. Użyj pól metadata (is_disposable, is_role, is_catch_all, is_free), aby zdecydować, jak traktować ryzykowne wyniki w swoim przypadku użycia.
Używaj Masowa weryfikacja e-maili dla list i zaplanowanego czyszczenia oraz Weryfikacja pojedynczego e-maila dla sprawdzeń w czasie rzeczywistym, takich jak zgłoszenia z formularzy.
Usuwaj duplikaty adresów przed weryfikacją, buforuj wyniki przez 30-90 dni i pomijaj wiersze, które już mają status. Zobacz Kredyty i rozliczenia, aby poznać koszty dla poszczególnych punktów końcowych.

​
Następne kroki

Wzbogacanie e-maili

Znajdź adresy e-mail dla swoich kontaktów za pomocą przepływu n8n.

Masowa weryfikacja e-maili

Poznaj dokumentację punktu końcowego masowej weryfikacji.

Uwierzytelnianie

Jak przekazać klucz API w nagłówku x-api-key.

Webhooki

Otrzymuj automatyczne powiadomienia o zakończeniu partii.