Google Forms

Intégrez EmailVerify avec Google Forms pour vérifier automatiquement les adresses e-mail lors de la soumission des réponses.

Méthodes d'intégration

Méthode	Idéal pour	Complexité
Apps Script	Vérification automatisée	Faible
Module complémentaire Sheets	Vérification manuelle	Faible
Zapier	Workflow sans code	Faible

Méthode 1 : Google Apps Script

Créez un workflow de vérification automatisé en utilisant Google Apps Script.

Étape 1 : Créer un projet Apps Script

Ouvrez votre Google Form
Cliquez sur le menu ⋮ → Éditeur de script
Cela ouvre l'éditeur Apps Script

Étape 2 : Ajouter le code de vérification

Remplacez le code par défaut par :

// Configuration
const CONFIG = {
  API_KEY: 'VOTRE_CLE_API_EMAILVERIFY',
  EMAIL_FIELD_INDEX: 1, // Ajuster selon votre formulaire (indexé à 0)
  BLOCK_DISPOSABLE: true,
  NOTIFY_ON_INVALID: true,
  NOTIFICATION_EMAIL: 'admin@votreentreprise.com',
};

/**
 * Fonction déclencheur - s'exécute lors de la soumission du formulaire
 */
function onFormSubmit(e) {
  const response = e.response;
  const email = getEmailFromResponse(response);

  if (!email) {
    Logger.log('Aucun e-mail trouvé dans la réponse');
    return;
  }

  // Vérifier l'e-mail
  const result = verifyEmail(email);

  // Stocker le résultat
  storeVerificationResult(response, result);

  // Gérer les e-mails invalides
  if (!result.isValid) {
    handleInvalidEmail(response, email, result);
  }
}

/**
 * Extraire l'e-mail de la réponse du formulaire
 */
function getEmailFromResponse(response) {
  const itemResponses = response.getItemResponses();

  // Essayer de trouver le champ e-mail par type
  for (const itemResponse of itemResponses) {
    const item = itemResponse.getItem();
    const itemType = item.getType();

    // Vérifier s'il s'agit d'un élément de texte avec validation e-mail
    if (itemType === FormApp.ItemType.TEXT) {
      const textItem = item.asTextItem();
      const validation = textItem.getValidation();

      // Si la validation exige le format e-mail
      if (validation) {
        return itemResponse.getResponse();
      }
    }
  }

  // Solution de secours : utiliser l'index configuré
  if (CONFIG.EMAIL_FIELD_INDEX < itemResponses.length) {
    return itemResponses[CONFIG.EMAIL_FIELD_INDEX].getResponse();
  }

  return null;
}

/**
 * Appeler l'API EmailVerify pour vérifier l'e-mail
 */
function verifyEmail(email) {
  const url = 'https://api.emailverify.ai/v1/verify';

  const options = {
    method: 'post',
    contentType: 'application/json',
    headers: {
      'Authorization': 'Bearer ' + CONFIG.API_KEY,
    },
    payload: JSON.stringify({ email: email }),
    muteHttpExceptions: true,
  };

  try {
    const response = UrlFetchApp.fetch(url, options);
    const data = JSON.parse(response.getContentText());

    const isValid = data.status === 'valid' &&
      !(CONFIG.BLOCK_DISPOSABLE && data.result?.disposable);

    return {
      email: email,
      status: data.status,
      score: data.score,
      isDisposable: data.result?.disposable || false,
      isRole: data.result?.role || false,
      isValid: isValid,
      raw: data,
    };
  } catch (error) {
    Logger.log('Erreur de vérification : ' + error.message);
    return {
      email: email,
      status: 'error',
      isValid: true, // Autoriser en cas d'erreur
      error: error.message,
    };
  }
}

/**
 * Stocker le résultat de vérification dans la feuille de calcul liée
 */
function storeVerificationResult(response, result) {
  const form = FormApp.getActiveForm();
  const destinationId = form.getDestinationId();

  if (!destinationId) {
    Logger.log('Aucune feuille de calcul liée trouvée');
    return;
  }

  const spreadsheet = SpreadsheetApp.openById(destinationId);
  const sheet = spreadsheet.getSheets()[0];

  // Trouver la ligne de réponse
  const responseRow = findResponseRow(sheet, response);

  if (responseRow === -1) {
    Logger.log('Impossible de trouver la ligne de réponse');
    return;
  }

  // Ajouter des colonnes de vérification si elles n'existent pas
  ensureVerificationColumns(sheet);

  // Obtenir les indices de colonnes
  const headers = sheet.getRange(1, 1, 1, sheet.getLastColumn()).getValues()[0];
  const statusCol = headers.indexOf('Statut E-mail') + 1;
  const scoreCol = headers.indexOf('Score E-mail') + 1;
  const disposableCol = headers.indexOf('Est Jetable') + 1;

  // Mettre à jour la ligne
  if (statusCol > 0) {
    sheet.getRange(responseRow, statusCol).setValue(result.status);
  }
  if (scoreCol > 0 && result.score !== undefined) {
    sheet.getRange(responseRow, scoreCol).setValue(result.score);
  }
  if (disposableCol > 0) {
    sheet.getRange(responseRow, disposableCol).setValue(result.isDisposable ? 'Oui' : 'Non');
  }

  // Appliquer la mise en forme conditionnelle
  if (result.status === 'invalid' || result.isDisposable) {
    sheet.getRange(responseRow, 1, 1, sheet.getLastColumn())
      .setBackground('#ffcccb');
  }
}

/**
 * Trouver le numéro de ligne pour une réponse
 */
function findResponseRow(sheet, response) {
  const timestamp = response.getTimestamp();
  const data = sheet.getDataRange().getValues();

  for (let i = 1; i < data.length; i++) {
    const rowTimestamp = data[i][0];
    if (rowTimestamp instanceof Date &&
        Math.abs(rowTimestamp.getTime() - timestamp.getTime()) < 5000) {
      return i + 1; // indexé à 1
    }
  }

  return -1;
}

/**
 * Ajouter des colonnes de vérification à la feuille de calcul
 */
function ensureVerificationColumns(sheet) {
  const headers = sheet.getRange(1, 1, 1, sheet.getLastColumn()).getValues()[0];
  const columnsToAdd = ['Statut E-mail', 'Score E-mail', 'Est Jetable'];

  for (const column of columnsToAdd) {
    if (!headers.includes(column)) {
      const newCol = sheet.getLastColumn() + 1;
      sheet.getRange(1, newCol).setValue(column);
    }
  }
}

/**
 * Gérer les soumissions d'e-mails invalides
 */
function handleInvalidEmail(response, email, result) {
  if (!CONFIG.NOTIFY_ON_INVALID) {
    return;
  }

  const form = FormApp.getActiveForm();
  const formTitle = form.getTitle();

  const subject = `[${formTitle}] Soumission d'e-mail invalide`;
  const body = `
Un e-mail invalide a été soumis à votre formulaire.

Formulaire : ${formTitle}
E-mail : ${email}
Statut : ${result.status}
${result.isDisposable ? 'Note : E-mail jetable détecté' : ''}
Score : ${result.score || 'N/D'}

Horodatage : ${response.getTimestamp()}
  `.trim();

  MailApp.sendEmail({
    to: CONFIG.NOTIFICATION_EMAIL,
    subject: subject,
    body: body,
  });
}

/**
 * Configurer le déclencheur de soumission de formulaire
 * Exécutez cette fonction une fois pour installer le déclencheur
 */
function installTrigger() {
  const form = FormApp.getActiveForm();

  // Supprimer les déclencheurs existants
  const triggers = ScriptApp.getUserTriggers(form);
  for (const trigger of triggers) {
    if (trigger.getHandlerFunction() === 'onFormSubmit') {
      ScriptApp.deleteTrigger(trigger);
    }
  }

  // Installer un nouveau déclencheur
  ScriptApp.newTrigger('onFormSubmit')
    .forForm(form)
    .onFormSubmit()
    .create();

  Logger.log('Déclencheur installé avec succès');
}

/**
 * Tester la vérification (exécution manuelle)
 */
function testVerification() {
  const result = verifyEmail('test@example.com');
  Logger.log(JSON.stringify(result, null, 2));
}

Étape 3 : Installer le déclencheur

Dans l'éditeur Apps Script, sélectionnez installTrigger dans la liste déroulante des fonctions
Cliquez sur Exécuter
Accordez les autorisations requises lorsqu'on vous le demande

Étape 4 : Tester l'intégration

Soumettez une réponse de test à votre formulaire
Vérifiez la feuille de calcul liée pour les résultats de vérification
Consultez les journaux Apps Script : Exécutions dans la barre latérale gauche

Méthode 2 : Module complémentaire Spreadsheet

Vérifiez les e-mails directement dans Google Sheets avec une barre latérale personnalisée.

Créer le code du module complémentaire

// Code.gs
function onOpen() {
  const ui = SpreadsheetApp.getUi();
  ui.createMenu('EmailVerify')
    .addItem('Vérifier les e-mails sélectionnés', 'verifySelected')
    .addItem('Vérifier tous les e-mails', 'verifyAll')
    .addItem('Paramètres', 'showSettings')
    .addToUi();
}

function verifySelected() {
  const sheet = SpreadsheetApp.getActiveSheet();
  const range = sheet.getActiveRange();
  const values = range.getValues();

  const results = [];

  for (let i = 0; i < values.length; i++) {
    const email = values[i][0];

    if (!email || !isValidEmailFormat(email)) {
      results.push(['Format invalide']);
      continue;
    }

    const result = verifyEmail(email);
    results.push([result.status + (result.isDisposable ? ' (jetable)' : '')]);
  }

  // Écrire les résultats dans la colonne suivante
  const startCol = range.getColumn() + range.getNumColumns();
  sheet.getRange(range.getRow(), startCol, results.length, 1).setValues(results);
}

function verifyAll() {
  const sheet = SpreadsheetApp.getActiveSheet();
  const ui = SpreadsheetApp.getUi();

  // Demander la colonne des e-mails
  const response = ui.prompt(
    'Vérifier tous les e-mails',
    'Entrez la lettre de la colonne contenant les e-mails (ex. B) :',
    ui.ButtonSet.OK_CANCEL
  );

  if (response.getSelectedButton() !== ui.Button.OK) {
    return;
  }

  const column = response.getResponseText().toUpperCase();
  const colIndex = column.charCodeAt(0) - 64; // A=1, B=2, etc.

  const lastRow = sheet.getLastRow();
  const emailRange = sheet.getRange(2, colIndex, lastRow - 1, 1);
  const emails = emailRange.getValues().flat().filter(e => e);

  ui.alert(`Démarrage de la vérification de ${emails.length} e-mails...`);

  // Vérifier par lots
  const batchSize = 50;
  let processed = 0;

  for (let i = 0; i < emails.length; i += batchSize) {
    const batch = emails.slice(i, i + batchSize);

    for (let j = 0; j < batch.length; j++) {
      const email = batch[j];
      const rowIndex = i + j + 2; // +2 pour l'en-tête et l'index 0

      if (!isValidEmailFormat(email)) {
        sheet.getRange(rowIndex, colIndex + 1).setValue('Format invalide');
        continue;
      }

      const result = verifyEmail(email);

      // Écrire le statut
      sheet.getRange(rowIndex, colIndex + 1).setValue(result.status);

      // Écrire le score
      if (result.score !== undefined) {
        sheet.getRange(rowIndex, colIndex + 2).setValue(result.score);
      }

      // Mettre en surbrillance les invalides
      if (result.status === 'invalid' || result.isDisposable) {
        sheet.getRange(rowIndex, 1, 1, sheet.getLastColumn()).setBackground('#ffcccb');
      }
    }

    processed += batch.length;
    SpreadsheetApp.flush();

    // Éviter les limites de débit
    if (i + batchSize < emails.length) {
      Utilities.sleep(1000);
    }
  }

  ui.alert(`Vérification terminée ! ${processed} e-mails traités.`);
}

function isValidEmailFormat(email) {
  return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(email);
}

function showSettings() {
  const html = HtmlService.createHtmlOutputFromFile('Settings')
    .setWidth(400)
    .setHeight(300);
  SpreadsheetApp.getUi().showModalDialog(html, 'Paramètres EmailVerify');
}

function saveSettings(apiKey) {
  PropertiesService.getUserProperties().setProperty('EMAILVERIFY_API_KEY', apiKey);
  return { success: true };
}

function getApiKey() {
  return PropertiesService.getUserProperties().getProperty('EMAILVERIFY_API_KEY') || '';
}

HTML des paramètres

<!-- Settings.html -->
<!DOCTYPE html>
<html>
<head>
  <style>
    body {
      font-family: Arial, sans-serif;
      padding: 20px;
    }
    .form-group {
      margin-bottom: 15px;
    }
    label {
      display: block;
      margin-bottom: 5px;
      font-weight: bold;
    }
    input[type="text"] {
      width: 100%;
      padding: 8px;
      border: 1px solid #ddd;
      border-radius: 4px;
      box-sizing: border-box;
    }
    button {
      background-color: #4285f4;
      color: white;
      padding: 10px 20px;
      border: none;
      border-radius: 4px;
      cursor: pointer;
    }
    button:hover {
      background-color: #357abd;
    }
    .success {
      color: #28a745;
      margin-top: 10px;
    }
  </style>
</head>
<body>
  <div class="form-group">
    <label for="apiKey">Clé API EmailVerify</label>
    <input type="text" id="apiKey" placeholder="bv_live_xxx" />
  </div>

  <button onclick="saveSettings()">Enregistrer les paramètres</button>

  <div id="message" class="success" style="display: none;"></div>

  <script>
    // Charger les paramètres existants
    google.script.run.withSuccessHandler(function(apiKey) {
      document.getElementById('apiKey').value = apiKey;
    }).getApiKey();

    function saveSettings() {
      const apiKey = document.getElementById('apiKey').value;

      google.script.run.withSuccessHandler(function(result) {
        if (result.success) {
          document.getElementById('message').textContent = 'Paramètres enregistrés !';
          document.getElementById('message').style.display = 'block';
          setTimeout(function() {
            google.script.host.close();
          }, 1500);
        }
      }).saveSettings(apiKey);
    }
  </script>
</body>
</html>

Méthode 3 : Intégration Zapier

Connectez Google Forms à EmailVerify en utilisant Zapier.

Configuration du Zap

Déclencheur : Google Forms → Nouvelle réponse dans la feuille de calcul
Action 1 : Webhooks by Zapier → POST vers EmailVerify
Action 2 : Google Sheets → Mettre à jour la ligne de la feuille de calcul

Configuration du Webhook

URL : https://api.emailverify.ai/v1/verify
Méthode : POST
En-têtes :
  Authorization: Bearer VOTRE_CLE_API
  Content-Type: application/json
Données :
{
  "email": "{{valeur_champ_email}}"
}

Mise à jour de la ligne

Mappez le résultat de vérification dans votre feuille de calcul :

Colonne : Statut de l'e-mail → {{status}}
Colonne : Score de l'e-mail → {{score}}
Colonne : Est jetable → {{result__disposable}}

Script de vérification en masse

Pour vérifier de grands ensembles de données existants :

/**
 * Vérifier en masse les e-mails d'une colonne
 * Traite par lots avec suivi de progression
 */
function bulkVerifyEmails() {
  const sheet = SpreadsheetApp.getActiveSheet();
  const ui = SpreadsheetApp.getUi();

  // Configuration
  const EMAIL_COL = 2;      // Colonne B (indexé à 1)
  const STATUS_COL = 3;     // Colonne C pour le statut
  const SCORE_COL = 4;      // Colonne D pour le score
  const START_ROW = 2;      // Ignorer l'en-tête
  const BATCH_SIZE = 100;

  const lastRow = sheet.getLastRow();
  const totalEmails = lastRow - START_ROW + 1;

  const proceed = ui.alert(
    'Vérification en masse',
    `Cela vérifiera ${totalEmails} e-mails. Continuer ?`,
    ui.ButtonSet.YES_NO
  );

  if (proceed !== ui.Button.YES) {
    return;
  }

  // Obtenir tous les e-mails
  const emailRange = sheet.getRange(START_ROW, EMAIL_COL, totalEmails, 1);
  const emails = emailRange.getValues().flat();

  // Obtenir la clé API
  const apiKey = PropertiesService.getUserProperties().getProperty('EMAILVERIFY_API_KEY');
  if (!apiKey) {
    ui.alert('Veuillez d\'abord configurer votre clé API dans les paramètres.');
    return;
  }

  // Traiter par lots
  let processed = 0;
  const stats = { valid: 0, invalid: 0, disposable: 0, errors: 0 };

  for (let i = 0; i < emails.length; i++) {
    const email = emails[i];
    const row = START_ROW + i;

    // Ignorer si déjà vérifié
    const existingStatus = sheet.getRange(row, STATUS_COL).getValue();
    if (existingStatus) {
      processed++;
      continue;
    }

    if (!email || !isValidEmailFormat(email)) {
      sheet.getRange(row, STATUS_COL).setValue('format_invalide');
      stats.errors++;
      processed++;
      continue;
    }

    // Vérifier
    const result = verifyEmailWithKey(email, apiKey);

    // Écrire les résultats
    sheet.getRange(row, STATUS_COL).setValue(result.status);
    if (result.score !== undefined) {
      sheet.getRange(row, SCORE_COL).setValue(result.score);
    }

    // Mettre à jour les statistiques
    if (result.status === 'valid') stats.valid++;
    else if (result.status === 'invalid') stats.invalid++;
    if (result.isDisposable) stats.disposable++;
    if (result.error) stats.errors++;

    // Mettre en surbrillance les lignes invalides
    if (result.status === 'invalid' || result.isDisposable) {
      sheet.getRange(row, 1, 1, sheet.getLastColumn()).setBackground('#ffcccb');
    }

    processed++;

    // Mise à jour de progression toutes les 50 e-mails
    if (processed % 50 === 0) {
      SpreadsheetApp.flush();
      Logger.log(`Progression : ${processed}/${totalEmails}`);
    }

    // Limitation de débit
    Utilities.sleep(100);
  }

  // Statistiques finales
  const message = `
Vérification terminée !

Total : ${processed}
Valides : ${stats.valid}
Invalides : ${stats.invalid}
Jetables : ${stats.disposable}
Erreurs : ${stats.errors}
  `.trim();

  ui.alert('Résultats', message, ui.ButtonSet.OK);
}

function verifyEmailWithKey(email, apiKey) {
  const url = 'https://api.emailverify.ai/v1/verify';

  const options = {
    method: 'post',
    contentType: 'application/json',
    headers: {
      'Authorization': 'Bearer ' + apiKey,
    },
    payload: JSON.stringify({ email: email }),
    muteHttpExceptions: true,
  };

  try {
    const response = UrlFetchApp.fetch(url, options);
    const data = JSON.parse(response.getContentText());

    return {
      status: data.status,
      score: data.score,
      isDisposable: data.result?.disposable || false,
    };
  } catch (error) {
    return {
      status: 'error',
      error: error.message,
    };
  }
}

Notifications par e-mail conditionnelles

Envoyez différents e-mails en fonction des résultats de vérification :

/**
 * Envoyer un e-mail de confirmation uniquement aux adresses vérifiées
 */
function sendConditionalConfirmation(e) {
  const response = e.response;
  const email = getEmailFromResponse(response);

  if (!email) return;

  // Vérifier l'e-mail d'abord
  const result = verifyEmail(email);

  if (!result.isValid) {
    // Envoyer une notification à l'administrateur à la place
    notifyAdminOfInvalidSubmission(response, email, result);
    return;
  }

  // Envoyer une confirmation à l'e-mail valide
  const formTitle = FormApp.getActiveForm().getTitle();

  MailApp.sendEmail({
    to: email,
    subject: `Merci pour votre soumission à ${formTitle}`,
    htmlBody: `
      <h2>Merci !</h2>
      <p>Nous avons reçu votre soumission et vous contacterons bientôt.</p>
      <p>Cordialement,<br>L'équipe</p>
    `,
  });
}

function notifyAdminOfInvalidSubmission(response, email, result) {
  const formTitle = FormApp.getActiveForm().getTitle();

  MailApp.sendEmail({
    to: CONFIG.NOTIFICATION_EMAIL,
    subject: `[Alerte] Soumission d'e-mail invalide - ${formTitle}`,
    body: `
Une soumission avec un e-mail invalide a été reçue.

E-mail : ${email}
Statut : ${result.status}
Jetable : ${result.isDisposable}

Veuillez consulter la soumission dans votre feuille de calcul.
    `,
  });
}

Bonnes pratiques

1. Stocker la clé API en toute sécurité

// Utiliser Properties Service au lieu de coder en dur
const apiKey = PropertiesService.getScriptProperties().getProperty('API_KEY');

2. Gérer les limites de débit

function verifyWithRetry(email, maxRetries = 3) {
  for (let i = 0; i < maxRetries; i++) {
    const result = verifyEmail(email);

    if (result.status !== 'error' || !result.error.includes('rate')) {
      return result;
    }

    // Attendre et réessayer
    Utilities.sleep(2000 * (i + 1));
  }

  return { status: 'error', error: 'Nombre maximum de tentatives atteint' };
}

3. Gestion élégante des erreurs

// Ne jamais bloquer les soumissions de formulaire en cas d'erreurs API
if (result.error) {
  Logger.log('Échec de la vérification, autorisation de la soumission');
  return; // Ne pas bloquer la soumission
}

Ressources associées

Intégration Typeform

Un autre constructeur de formulaires

Intégration JotForm

Plateforme de formulaires alternative

Référence API

Documentation API complète

Google Forms

Intégration Typeform

Intégration JotForm

Référence API

On this page