Skip to main content
Vérifier vos leads avant une campagne réduit les taux de rebond et protège votre réputation d’expéditeur. Ce playbook construit un workflow n8n qui lit une liste d’e-mails, vérifie chaque adresse avec l’Email Verifier, catégorise les résultats (valides, invalides, à risque) et exporte une liste propre prête à l’envoi. Si vous débutez avec n8n et Enrow, commencez par le guide de démarrage n8n.

​
Que allez-vous construire ?

Vous allez construire un workflow qui :
  1. Lit la liste d’e-mails depuis Google Sheets ou un CSV
  2. Vérifie chaque e-mail avec Enrow
  3. Catégorise les résultats (valides, invalides, à risque)
  4. Exporte une liste propre prête pour vos campagnes
Temps de construction : 10 minutes Difficulté : Débutant

​
Quand utiliser ce workflow ?

Utilisez ce workflow chaque fois que la délivrabilité des e-mails compte pour un processus en aval. Cas d’usage courants :
  • Nettoyer des listes d’e-mails avant des campagnes marketing
  • Vérifier les soumissions de formulaires en temps réel
  • Maintenir l’hygiène de votre base de données
  • Réduire les taux de rebond

​
De quoi avez-vous besoin avant de commencer ?

Avant de construire le workflow, assurez-vous de disposer des éléments suivants : La clé API Enrow authentifie chaque requête via l’en-tête x-api-key. Consultez Authentication pour savoir comment récupérer et transmettre la clé API, et Credits & billing pour comprendre comment les crédits de vérification sont consommés.

​
Comment configurer le Google Sheet ?

Créez une feuille contenant les adresses e-mail et des colonnes vides pour les résultats :
EmailStatusDeliverableRisk Factors
john@example.com
invalid@fake.com
temp@tempmail.com

​
Comment construire le workflow en 5 minutes ?

Le chemin le plus rapide consiste à importer un workflow prêt à l’emploi, à configurer vos identifiants et à l’exécuter.

​
Étape 1 : Importer le workflow

Copiez et importez ce workflow dans 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}]]
    }
  }
}

​
Étape 2 : Configurer

  1. Remplacez YOUR_SHEET_ID par l’ID de votre Google Sheet
  2. Ajoutez votre clé API Enrow à l’identifiant Header Auth
  3. Testez d’abord avec quelques e-mails

​
Étape 3 : Exécuter

  1. Cliquez sur « Execute Workflow »
  2. Attendez la fin de la vérification
  3. Consultez votre Google Sheet pour les résultats

​
Comment construire le workflow étape par étape ?

Si vous préférez construire le workflow nœud par nœud, suivez le guide détaillé ci-dessous.

​
Étape 1 : Lire la liste d’e-mails

Google Sheets :
  1. Ajoutez un nœud « Google Sheets »
  2. Opération : Read
  3. Sélectionnez votre feuille de calcul
  4. Plage : Sheet1!A:A (colonne e-mail uniquement)
Fichier CSV :
  1. Ajoutez un nœud « Read Binary Files »
  2. Ajoutez un nœud « CSV to JSON »
  3. Mappez le champ e-mail

​
Étape 2 : Créer des lots

Pour de meilleures performances, traitez les e-mails par lots :
  1. Ajoutez un nœud « Split In Batches »
  2. Taille du lot : 100 (ou moins pour des résultats plus rapides)
Cela envoie 100 e-mails à la fois à Enrow.

​
Étape 3 : Vérifier avec l’API Bulk d’Enrow

  1. Ajoutez un nœud « HTTP Request »
  2. Configurez :
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) }}
}
Cela retourne immédiatement un batch_id. Consultez Vérifier des e-mails pour la référence complète de la requête et de la réponse.

​
Étape 4 : Attendre les résultats

Ajoutez un nœud « Wait » avec un délai de 10 à 15 secondes. Pour les gros lots, attendez plus longtemps. Pour une récupération événementielle plutôt qu’un polling, transmettez une URL de webhook dans la requête — consultez Fonctionnement des webhooks.

​
Étape 5 : Récupérer les résultats

  1. Ajoutez un nœud « HTTP Request »
  2. Configurez :
Method: GET
URL: https://api.enrow.io/email/verify/bulk?id={{$json["batch_id"]}}
Authentication: Header Auth (reuse credential)
L’endpoint Récupérer des vérifications retourne les résultats de vérification du lot.

​
Étape 6 : Traiter les résultats

Ajoutez un nœud « Function » pour catégoriser les e-mails : 
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)
    }
  }
];

​
Étape 7 : Mettre à jour le Google Sheet

  1. Ajoutez un nœud « Google Sheets »
  2. Opération : Update
  3. Remappez les résultats vers les lignes d’origine
Ou créez des feuilles distinctes pour chaque catégorie :
  • E-mails valides → Feuille « Valid »
  • E-mails invalides → Feuille « Invalid »
  • E-mails à risque → Feuille « Risky »

​
Comment vérifier les e-mails d’un formulaire en temps réel ?

Pour vérifier les e-mails au fur et à mesure que les utilisateurs soumettent des formulaires, déclenchez le workflow avec un webhook et vérifiez chaque adresse individuellement :

​
Workflow :

  1. Webhook Trigger : Reçoit les soumissions de formulaires
  2. Extract Email : Récupère l’e-mail depuis les données du formulaire
  3. Verify : Appelle Enrow /email/verify/single
  4. Décision :
    • Valide → Enregistre dans le CRM (Salesforce, HubSpot, etc.)
    • Invalide → Renvoie une réponse d’erreur ou signale pour révision
// 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 vérification d’une adresse unique utilise l’endpoint Vérifier un e-mail. Pour pousser les leads acceptés dans votre CRM, consultez les intégrations HubSpot et Salesforce.

​
Comment exporter la liste propre ?

Une fois les résultats catégorisés, vous pouvez exporter la liste propre dans le format dont votre stack a besoin.

​
Option 1 : Google Sheets

C’est déjà fait ! Les résultats sont dans votre feuille.

​
Option 2 : Export CSV

  1. Ajoutez un nœud « Move Binary Data »
  2. Ajoutez un nœud « Write Binary File »
  3. Enregistrez sur disque ou envoyez par e-mail

​
Option 3 : Envoyer vers une plateforme d’e-mailing

  1. Ajoutez un nœud « HTTP Request » pour l’API de votre plateforme d’e-mailing
  2. Exemples :
    • Mailchimp : Ajouter à l’audience
    • SendGrid : Mettre à jour les contacts
    • Customer.io : Synchroniser les attributs

​
Comment suivre les métriques de vérification ?

Ajoutez un nœud de synthèse pour calculer les métriques de délivrabilité de chaque exécution : 
// 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 }];
Envoyez cette synthèse vers :
  • Slack : Publier la synthèse dans un canal
  • Email : Rapports quotidiens/hebdomadaires
  • Base de données : Suivi dans le temps

​
Comment réduire la consommation de crédits ?

La vérification consomme des crédits par e-mail, alors réduisez le travail avant chaque exécution. Trois tactiques permettent de limiter les coûts.

​
Dédupliquer avant de vérifier

// 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 } }));
Supprimer les doublons économise des crédits en ne vérifiant chaque adresse qu’une seule fois.

​
Mettre en cache les résultats

Stockez les résultats de vérification pendant 30 à 90 jours : 
// 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;

​
Ignorer les adresses déjà vérifiées

Ne vérifiez que les e-mails dont le statut est vide : 
// IF node
{{$json["Status"]}} === "" || {{$json["Status"]}} === null
Consultez Credits & billing pour le coût en crédits par endpoint.

​
Bonnes pratiques

Vérifiez toujours votre liste 24 à 48 heures avant l’envoi. La validité des e-mails peut changer.
Décidez selon le cas d’usage :
  • B2B : Les e-mails de rôle (info@, support@) peuvent convenir
  • B2C : Rejetez les e-mails jetables
  • Cold outreach : N’utilisez que des e-mails à haute confiance
Suivez les taux de rebond après l’envoi. S’ils sont élevés, vérifiez à nouveau votre liste.
Vérifiez l’ensemble de votre liste tous les 3 à 6 mois pour supprimer les e-mails invalides.

​
Dépannage

La vérification prend trop de temps ?
  • Réduisez la taille du lot à 50-100 e-mails
  • Augmentez le temps d’attente entre les lots
Certains e-mails apparaissent comme « risky » ?
  • Vérifiez metadata.is_disposable - il peut s’agir d’e-mails temporaires
  • Examinez metadata.is_catch_all - serveurs accept-all
Vous êtes limité en débit ?
  • Ajoutez des délais entre les lots
  • Réduisez la taille du lot
  • Passez à un forfait Enrow supérieur
Pour les plafonds de requêtes et la gestion des 429, consultez Rate limits. Pour les codes de statut et les formats d’erreur, consultez Error handling.

​
FAQ

Utilisez le nœud Batch Emails pour traiter les e-mails par groupes (l’exemple utilise une taille de lot de 100). Pour de très grandes listes, divisez le travail en lots plus petits et ajoutez une attente plus longue entre les requêtes pour éviter d’être limité en débit. Consultez Rate limits pour les plafonds de requêtes.
valid signifie que l’adresse est délivrable, invalid qu’elle rebondirait, et risky couvre les adresses catch-all, jetables ou de rôle dont la délivrabilité est incertaine. Utilisez les champs metadata (is_disposable, is_role, is_catch_all, is_free) pour décider comment traiter les résultats à risque selon votre cas d’usage.
Utilisez Vérifier des e-mails pour les listes et le nettoyage planifié, et Vérifier un e-mail pour les contrôles en temps réel comme les soumissions de formulaires.
Dédupliquez les adresses avant de vérifier, mettez en cache les résultats pendant 30 à 90 jours et ignorez les lignes qui ont déjà un statut. Consultez Credits & billing pour les coûts par endpoint.

​
Prochaines étapes

Enrichissement d'e-mails

Trouvez les e-mails de vos contacts avec un workflow n8n.

Vérifier des e-mails

Explorez la référence de l’endpoint de vérification en masse.

Authentication

Comment transmettre votre clé API dans l’en-tête x-api-key.

Webhooks

Soyez notifié automatiquement lorsqu’un lot est terminé.