Skip to main content
Verificare i lead prima di una campagna riduce i tassi di bounce e protegge la reputazione del mittente. Questo playbook crea un workflow n8n che legge una lista di email, verifica ogni indirizzo con l’Email Verifier, categorizza i risultati (validi, non validi, rischiosi) ed esporta una lista pulita pronta per l’invio. Se sei alle prime armi con n8n e Enrow, parti dalla guida introduttiva a n8n.

​
Cosa creerai?

Creerai un workflow che:
  1. Legge la lista di email da Google Sheets o CSV
  2. Verifica ogni email usando Enrow
  3. Categorizza i risultati (validi, non validi, rischiosi)
  4. Esporta una lista pulita pronta per le campagne
Tempo di creazione: 10 minuti Difficoltà: Principiante

​
Quando dovresti usare questo workflow?

Usa questo workflow ogni volta che la recapitabilità delle email è importante per un processo a valle. Casi d’uso comuni:
  • Pulire le liste di email prima delle campagne di marketing
  • Verificare gli invii dei form in tempo reale
  • Mantenere l’igiene del database
  • Ridurre i tassi di bounce

​
Cosa ti serve prima di iniziare?

Prima di creare il workflow, assicurati di avere quanto segue: La chiave API Enrow autentica ogni richiesta tramite l’header x-api-key. Consulta Authentication per scoprire come recuperare e passare la chiave API, e Credits & billing per capire come vengono consumati i crediti di verifica.

​
Come si configura il Google Sheet?

Crea un foglio con gli indirizzi email e colonne vuote per i risultati:
EmailStatusDeliverableRisk Factors
john@example.com
invalid@fake.com
temp@tempmail.com

​
Come si crea il workflow in 5 minuti?

Il percorso più veloce è importare un workflow già pronto, configurare le credenziali ed eseguirlo.

​
Step 1: Importa il workflow

Copia e importa questo 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}]]
    }
  }
}

​
Step 2: Configura

  1. Sostituisci YOUR_SHEET_ID con l’ID del tuo Google Sheet
  2. Aggiungi la tua chiave API Enrow alla credenziale Header Auth
  3. Prova prima con poche email

​
Step 3: Esegui

  1. Clicca su “Execute Workflow”
  2. Attendi il completamento della verifica
  3. Controlla il tuo Google Sheet per i risultati

​
Come si crea il workflow passo dopo passo?

Se preferisci creare il workflow nodo per nodo, segui la guida dettagliata qui sotto.

​
Step 1: Leggi la lista di email

Google Sheets:
  1. Aggiungi il nodo “Google Sheets”
  2. Operazione: Read
  3. Seleziona il tuo foglio di calcolo
  4. Intervallo: Sheet1!A:A (solo la colonna email)
File CSV:
  1. Aggiungi il nodo “Read Binary Files”
  2. Aggiungi il nodo “CSV to JSON”
  3. Mappa il campo email

​
Step 2: Crea i batch

Per prestazioni migliori, elabora le email in batch:
  1. Aggiungi il nodo “Split In Batches”
  2. Dimensione batch: 100 (o meno per risultati più rapidi)
In questo modo vengono inviate 100 email alla volta a Enrow.

​
Step 3: Verifica con l’API Bulk di Enrow

  1. Aggiungi il 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) }}
}
Questo restituisce subito un batch_id. Consulta Verify Bulk Emails per il riferimento completo di richiesta e risposta.

​
Step 4: Attendi i risultati

Aggiungi il nodo “Wait” con un ritardo di 10-15 secondi. Per batch grandi, attendi di più. Per un recupero basato sugli eventi anziché tramite polling, passa un URL webhook nella richiesta — consulta How webhooks work.

​
Step 5: Recupera i risultati

  1. Aggiungi il nodo “HTTP Request”
  2. Configura:
Method: GET
URL: https://api.enrow.io/email/verify/bulk?id={{$json["batch_id"]}}
Authentication: Header Auth (reuse credential)
L’endpoint Get Bulk Verifications restituisce i risultati di verifica per il batch.

​
Step 6: Elabora i risultati

Aggiungi il nodo “Function” per categorizzare le email: 
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)
    }
  }
];

​
Step 7: Aggiorna il Google Sheet

  1. Aggiungi il nodo “Google Sheets”
  2. Operazione: Update
  3. Rimappa i risultati nelle righe originali
Oppure crea fogli separati per ogni categoria:
  • Email valide → Foglio “Valid”
  • Email non valide → Foglio “Invalid”
  • Email rischiose → Foglio “Risky”

​
Come si verificano le email di un form in tempo reale?

Per verificare le email mentre gli utenti inviano i form, attiva il workflow con un webhook e verifica ogni indirizzo individualmente:

​
Workflow:

  1. Webhook Trigger: Riceve gli invii dei form
  2. Extract Email: Ottiene l’email dai dati del form
  3. Verify: Chiama /email/verify/single di Enrow
  4. Decision:
    • Valida → Salva nel CRM (Salesforce, HubSpot, ecc.)
    • Non valida → Invia una risposta di errore o segnala per la revisione
// 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 verifica di un singolo indirizzo usa l’endpoint Verify Single Email. Per inviare i lead accettati nel tuo CRM, consulta le integrazioni HubSpot e Salesforce.

​
Come si esporta la lista pulita?

Una volta categorizzati i risultati, puoi esportare la lista pulita nel formato richiesto dal tuo stack.

​
Opzione 1: Google Sheets

Già fatto! I risultati sono nel tuo foglio.

​
Opzione 2: Esportazione CSV

  1. Aggiungi il nodo “Move Binary Data”
  2. Aggiungi il nodo “Write Binary File”
  3. Salva su disco o invia via email

​
Opzione 3: Invia a una piattaforma email

  1. Aggiungi il nodo “HTTP Request” per l’API della tua piattaforma email
  2. Esempi:
    • Mailchimp: Aggiungi al pubblico
    • SendGrid: Aggiorna i contatti
    • Customer.io: Sincronizza gli attributi

​
Come si monitorano le metriche di verifica?

Aggiungi un nodo di riepilogo per calcolare le metriche di recapitabilità a ogni esecuzione: 
// 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 }];
Invia questo riepilogo a:
  • Slack: Pubblica il riepilogo in un canale
  • Email: Report giornalieri/settimanali
  • Database: Traccia nel tempo

​
Come si riduce il consumo di crediti?

La verifica consuma crediti per email, quindi riduci il lavoro prima di ogni esecuzione. Tre tattiche mantengono bassi i costi.

​
Deduplica prima di verificare

// 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 } }));
Rimuovere i duplicati fa risparmiare crediti verificando ogni indirizzo una sola volta.

​
Memorizza i risultati nella cache

Conserva i risultati di verifica per 30-90 giorni: 
// 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;

​
Salta quelle già verificate

Verifica solo le email con status vuoto: 
// IF node
{{$json["Status"]}} === "" || {{$json["Status"]}} === null
Consulta Credits & billing per il costo in crediti di ogni endpoint.

​
Best Practice

Verifica sempre la tua lista 24-48 ore prima dell’invio. La validità delle email può cambiare.
Decidi in base al caso d’uso:
  • B2B: Le email di ruolo (info@, support@) potrebbero andare bene
  • B2C: Rifiuta le email usa e getta
  • Cold outreach: Usa solo email ad alta affidabilità
Traccia i tassi di bounce dopo l’invio. Se sono alti, riverifica la tua lista.
Verifica l’intera lista ogni 3-6 mesi per rimuovere le email non valide.

​
Risoluzione dei problemi

La verifica richiede troppo tempo?
  • Riduci la dimensione del batch a 50-100 email
  • Aumenta il tempo di attesa tra i batch
Alcune email risultano “risky”?
  • Controlla metadata.is_disposable - potrebbero essere email temporanee
  • Esamina metadata.is_catch_all - server accept-all
Stai ricevendo un rate limit?
  • Aggiungi ritardi tra i batch
  • Riduci la dimensione del batch
  • Effettua l’upgrade del tuo piano Enrow
Per i limiti massimi delle richieste e la gestione del codice 429, consulta Rate limits. Per i codici di stato e i formati di errore, consulta Error handling.

​
FAQ

Usa il nodo Batch Emails per elaborare le email in gruppi (l’esempio usa una dimensione batch di 100). Per liste molto grandi, suddividi il lavoro in batch più piccoli e aggiungi un’attesa più lunga tra le richieste per evitare il rate limit. Consulta Rate limits per i limiti massimi delle richieste.
valid significa che l’indirizzo è recapitabile, invalid significa che genererebbe un bounce, e risky riguarda indirizzi catch-all, usa e getta o di ruolo per cui la recapitabilità è incerta. Usa i campi metadata (is_disposable, is_role, is_catch_all, is_free) per decidere come trattare i risultati rischiosi nel tuo caso d’uso.
Usa Verify Bulk Emails per le liste e la pulizia programmata, e Verify Single Email per i controlli in tempo reale come gli invii dei form.
Deduplica gli indirizzi prima di verificarli, memorizza i risultati nella cache per 30-90 giorni e salta le righe che hanno già uno status. Consulta Credits & billing per i costi di ogni endpoint.

​
Prossimi passi

Arricchimento Email

Trova le email per i tuoi contatti con un workflow n8n.

Verify Bulk Emails

Esplora il riferimento dell’endpoint di verifica in blocco.

Authentication

Come passare la tua chiave API nell’header x-api-key.

Webhooks

Ricevi una notifica automatica al completamento di un batch.