> ## Documentation Index
> Fetch the complete documentation index at: https://docs.enrow.io/llms.txt
> Use this file to discover all available pages before exploring further.

# Verifica Lead (n8n)

> Pulisci e verifica le liste di email prima delle campagne con un workflow n8n che verifica i lead in blocco usando l'API Enrow ed esporta una lista pronta alla consegna

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](/it/api-reference/email-verifier/verify-bulk), 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](/it/playbooks/n8n/getting-started).

## 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:

* n8n ([ottieni n8n](https://n8n.io))
* Chiave API Enrow ([ottieni la chiave](https://app.enrow.io/settings/api-keys))
* Lista di email (Google Sheet o CSV)

La chiave API Enrow autentica ogni richiesta tramite l'header `x-api-key`. Consulta [Authentication](/it/authentication) per scoprire come recuperare e passare la chiave API, e [Credits & billing](/it/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:

| Email                                         | Status | Deliverable | Risk Factors |
| --------------------------------------------- | ------ | ----------- | ------------ |
| [john@example.com](mailto:john@example.com)   |        |             |              |
| [invalid@fake.com](mailto:invalid@fake.com)   |        |             |              |
| [temp@tempmail.com](mailto: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:

```json theme={null}
{
  "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:

```javascript theme={null}
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](/it/api-reference/email-verifier/verify-bulk) 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](/it/how-webhooks-work).

### Step 5: Recupera i risultati

1. Aggiungi il nodo **"HTTP Request"**
2. Configura:

```javascript theme={null}
Method: GET
URL: https://api.enrow.io/email/verify/bulk?id={{$json["batch_id"]}}
Authentication: Header Auth (reuse credential)
```

L'endpoint [Get Bulk Verifications](/it/api-reference/email-verifier/get-bulk-verifications) restituisce i risultati di verifica per il batch.

### Step 6: Elabora i risultati

Aggiungi il nodo **"Function"** per categorizzare le email:

```javascript theme={null}
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:

```mermaid theme={null}
graph LR
    A[Webhook] --> B[Receive Form Data]
    B --> C[Verify Email]
    C --> D{Valid?}
    D -->|Yes| E[Save to CRM]
    D -->|No| F[Reject Submission]
```

### 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

```javascript theme={null}
// 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](/it/api-reference/email-verifier/verify-single). Per inviare i lead accettati nel tuo CRM, consulta le integrazioni [HubSpot](/it/integrations/crm/hubspot) e [Salesforce](/it/integrations/crm/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:

```javascript theme={null}
// 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

```javascript theme={null}
// 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:

```javascript theme={null}
// 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:

```javascript theme={null}
// IF node
{{$json["Status"]}} === "" || {{$json["Status"]}} === null
```

Consulta [Credits & billing](/it/credits-billing) per il costo in crediti di ogni endpoint.

## Best Practice

<AccordionGroup>
  <Accordion title="Verifica prima delle campagne">
    Verifica sempre la tua lista 24-48 ore prima dell'invio. La validità delle email può cambiare.
  </Accordion>

  <Accordion title="Gestisci le email rischiose">
    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à
  </Accordion>

  <Accordion title="Monitora la recapitabilità">
    Traccia i tassi di bounce dopo l'invio. Se sono alti, riverifica la tua lista.
  </Accordion>

  <Accordion title="Pulizia regolare">
    Verifica l'intera lista ogni 3-6 mesi per rimuovere le email non valide.
  </Accordion>
</AccordionGroup>

## 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](/it/rate-limits). Per i codici di stato e i formati di errore, consulta [Error handling](/it/error-handling).

## FAQ

<AccordionGroup>
  <Accordion title="Quante email posso verificare in un singolo batch?">
    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](/it/rate-limits) per i limiti massimi delle richieste.
  </Accordion>

  <Accordion title="Cosa significano gli status valid, invalid e risky?">
    `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.
  </Accordion>

  <Accordion title="Dovrei verificare una singola email o usare il bulk?">
    Usa [Verify Bulk Emails](/it/api-reference/email-verifier/verify-bulk) per le liste e la pulizia programmata, e [Verify Single Email](/it/api-reference/email-verifier/verify-single) per i controlli in tempo reale come gli invii dei form.
  </Accordion>

  <Accordion title="Come evito di sprecare crediti?">
    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](/it/credits-billing) per i costi di ogni endpoint.
  </Accordion>
</AccordionGroup>

## Prossimi passi

<CardGroup cols={2}>
  <Card title="Arricchimento Email" icon="envelope-circle-check" href="/it/playbooks/n8n/email-enrichment-workflow">
    Trova le email per i tuoi contatti con un workflow n8n.
  </Card>

  <Card title="Verify Bulk Emails" icon="code" href="/it/api-reference/email-verifier/verify-bulk">
    Esplora il riferimento dell'endpoint di verifica in blocco.
  </Card>

  <Card title="Authentication" icon="key" href="/it/authentication">
    Come passare la tua chiave API nell'header x-api-key.
  </Card>

  <Card title="Webhooks" icon="bell" href="/it/how-webhooks-work">
    Ricevi una notifica automatica al completamento di un batch.
  </Card>
</CardGroup>