Come verificare le email da Google Forms

Google Forms accetta senza battere ciglio jane@gmial.com, un indirizzo temporaneo di un dominio usa e getta o l'indirizzo di un'azienda fallita due anni fa. L'impostazione integrata "valid email" controlla solo che il testo somigli a un indirizzo: non chiede mai se dietro c'è una casella reale. Per verificare davvero le email da Google Forms serve un secondo passaggio: un vero controllo sul sistema di posta, nel momento in cui arriva una risposta oppure in un secondo momento in blocco. Questa guida mostra entrambe le strade, usando Google Apps Script come collante.

In breve#

Due strade, a seconda che ti serva l'esito in tempo reale o che tu possa pulire a blocchi:

1. Tempo reale: aggiungi in Apps Script un trigger onFormSubmit che legge l'indirizzo inviato, chiama l'API di Qualisend con UrlFetchApp e scrive l'esito nel Foglio Google collegato. Ogni nuova risposta riceve un punteggio appena arriva.
2. In blocco: le risposte si trovano già in un Foglio, quindi scaricale come CSV ed esegui un'unica verifica in blocco. È l'ideale per un modulo che raccoglie risposte da tempo, o se non vuoi toccare il codice.

Entrambe si basano sullo stesso esito (deliverable, risky, undeliverable o unknown), più gli indicatori aggiuntivi per indirizzi usa e getta, generici e gratuiti. A cambiare sono i tempi.

Strada 1: verificare le email da Google Forms in tempo reale con Apps Script#

Google Forms non può chiamare da solo un'API esterna, ma il Foglio in cui confluiscono le sue risposte sì, tramite Apps Script. Il piano è semplice: attivarsi a ogni invio, prendere l'email, sottoporla a Qualisend e scrivere la risposta accanto alla riga.

Configura lo script. Apri il Foglio Google che raccoglie le risposte (nell'editor del modulo, Responses → Link to Sheets se non l'hai già fatto). Dal Foglio, vai su Extensions → Apps Script. Prima di tutto salva la chiave, così non finirà mai nel codice: nell'editor di script apri Project Settings → Script Properties e aggiungi QUALISEND_API_KEY con il tuo valore. Lo script la legge in fase di esecuzione con PropertiesService.

Poi incolla un handler come questo. Chiama POST https://app.qualisend.com/api/v1/verify, e il riferimento API documenta richiesta e risposta complete:

// Bound to the responses spreadsheet.
// Runs on each new Form submission (see trigger setup below).

const QUALISEND_URL = 'https://app.qualisend.com/api/v1/verify';
const EMAIL_QUESTION = 'Email address'; // your exact question title
const STATUS_COL = 8;                    // first of 3 empty columns: verdict, score, pending job id

function onFormSubmit(e) {
  const email = (e.namedValues[EMAIL_QUESTION] || [])[0];
  if (!email) return;

  const apiKey = PropertiesService.getScriptProperties().getProperty('QUALISEND_API_KEY');

  const res = UrlFetchApp.fetch(QUALISEND_URL, {
    method: 'post',
    contentType: 'application/json',
    headers: { Authorization: 'Bearer ' + apiKey },
    payload: JSON.stringify({ email }),
    muteHttpExceptions: true, // handle errors ourselves instead of throwing
  });

  // Fail open: if the check errors, keep the response — never lose a real lead.
  if (res.getResponseCode() !== 200) return;

  const { job_id, result } = JSON.parse(res.getContentText());
  const row = e.range.getRow();
  const sheet = e.range.getSheet();

  sheet.getRange(row, STATUS_COL).setValue(result.status);       // deliverable | risky | undeliverable | unknown
  sheet.getRange(row, STATUS_COL + 1).setValue(result.score);    // 0-100
  // SMTP probe still running: keep the job id so finishPending() can fetch the final verdict.
  if (result.smtp === 'pending') sheet.getRange(row, STATUS_COL + 2).setValue(job_id);
}

La parte utile è l'oggetto e che ti passa un invio del modulo: e.namedValues associa il titolo di ogni domanda alla sua risposta, ed e.range è la riga appena scritta, quindi e.range.getRow() ti dice esattamente su quale riga scrivere. Fai corrispondere esattamente EMAIL_QUESTION al titolo della tua domanda e punta STATUS_COL sulla prima di tre colonne vuote (esito, punteggio e ID del job in sospeso).

Aggiungi il trigger. Un trigger semplice (la sola funzione onFormSubmit) non può chiamare UrlFetchApp, perché raggiungere un servizio esterno richiede un'autorizzazione che i trigger semplici non hanno. Ti serve invece un trigger installabile. Nell'editor di script apri Triggers (l'icona dell'orologio) → Add Trigger e scegli:

• Function: onFormSubmit
• Event source: From spreadsheet
• Event type: On form submit

Salva, approva una volta la richiesta di autorizzazione e sei operativo. Invia una risposta di prova e guarda comparire stato e punteggio nelle colonne che hai scelto.

Una nota sui tempi. Qualisend restituisce subito i controlli locali veloci (sintassi, dominio, usa e getta, indirizzo generico, errore di battitura), mentre il controllo SMTP più approfondito della casella termina poco dopo. Mentre questo controllo è in corso, la risposta indica result.smtp come "pending" e lo stato che hai scritto è l'esito preliminare (cached o skipped significano che è già definitivo). La risposta confermata via SMTP arriva sul job, che leggi con GET https://app.qualisend.com/api/v1/jobs/{job_id}. L'handler qui sopra salva l'ID del job proprio per questo, e una seconda funzione nello stesso script inserisce l'esito finale una volta completato il job:

// Same script. Run by a time-driven trigger: once a pending job completes,
// replace the instant verdict with the SMTP-confirmed one.
function finishPending() {
  const sheet = SpreadsheetApp.getActive().getSheetByName('Form Responses 1'); // your responses tab
  const apiKey = PropertiesService.getScriptProperties().getProperty('QUALISEND_API_KEY');
  const lastRow = sheet.getLastRow();
  if (lastRow < 2) return;

  const jobIds = sheet.getRange(2, STATUS_COL + 2, lastRow - 1, 1).getValues();
  jobIds.forEach(([jobId], i) => {
    if (!jobId) return;
    const res = UrlFetchApp.fetch(
      'https://app.qualisend.com/api/v1/jobs/' + jobId + '?include=results',
      { headers: { Authorization: 'Bearer ' + apiKey }, muteHttpExceptions: true }
    );
    if (res.getResponseCode() !== 200) return; // try again on the next run

    const job = JSON.parse(res.getContentText());
    if (job.status === 'pending' || job.status === 'processing') return; // still probing

    const row = i + 2;
    const verdict = (job.results || [])[0];
    if (verdict) {
      sheet.getRange(row, STATUS_COL).setValue(verdict.status);
      sheet.getRange(row, STATUS_COL + 1).setValue(verdict.score);
    }
    sheet.getRange(row, STATUS_COL + 2).clearContent(); // settled: stop checking this row
  });
}

Eseguila da un secondo trigger installabile: Function finishPending, Event source Time-driven, tipo Minutes timer, ogni 5 minuti. Chiama l'API solo per le righe che contengono ancora un ID del job. Non chiamare di nuovo /verify per aggiornare una riga: avvieresti un secondo controllo e spenderesti un altro credito. Come funziona la verifica email spiega perché la fase SMTP è quella lenta.

Strada 2: verificare in blocco il foglio delle risposte#

Se il tuo modulo raccoglie risposte da mesi, o preferisci non mantenere uno script, salta del tutto il trigger. Le tue risposte sono già un foglio di calcolo: verificale in un solo passaggio.

1. Apri il Foglio Google collegato (o la scheda Responses del modulo → Link to Sheets).
2. File → Download → Comma-separated values (.csv).
3. Carica quel CSV nella verifica in blocco di Qualisend, indica la colonna delle email ed esegui il job.
4. Scarica i risultati e abbinali alle tue righe tramite l'email, oppure incolla la colonna dello stato nel Foglio.

La verifica in blocco esegue l'intera pipeline, compreso il controllo SMTP, su ogni riga, quindi intercetta le caselle morte che un controllo della sintassi non troverebbe mai. È la stessa procedura che useresti per qualsiasi lista esportata: la nostra guida su come pulire una lista email spiega come eliminare i duplicati, gestire gli indirizzi generici e cosa fare con quelli a rischio. Per un controllo occasionale su un singolo indirizzo, la verifica gratuita di un singolo indirizzo non richiede alcun CSV.

Agire sugli esiti#

Un esito serve solo se cambia ciò che fai dopo. Comunque tu l'abbia ottenuto, tratta i quattro stati così:

Gli indicatori aggiuntivi affinano il quadro. Un indicatore disposable su una partecipazione a un concorso è di solito un indirizzo temporaneo che puoi scartare; un indicatore role (info@, support@) può contare o meno a seconda dello scopo del modulo. Indirizzi generici, usa e getta e gratuiti spiega quando conviene filtrare ciascuno di essi. Nello script in tempo reale puoi agire subito su questi valori, ad esempio scrivendo una nota "review" in una colonna quando result.sub_flags.disposable è true.

Quale strada scegliere?#

Scegli il trigger Apps Script in tempo reale quando le risposte sono lead che ricontatti in fretta (richieste di demo, liste d'attesa, contenuti riservati) e vuoi avere l'esito accanto a ogni riga nel momento in cui arriva. Costa un credito per invio e un po' di manutenzione dello script.

Scegli la verifica in blocco quando hai un arretrato da pulire, quando preferisci evitare il codice o quando un modulo molto attivo supererebbe la quota di UrlFetchApp degli account personali. Nulla ti impedisce di fare entrambe le cose: esegui il trigger sulle nuove risposte e un passaggio in blocco mensile per ricontrollare gli indirizzi che potrebbero essere diventati obsoleti.

In ogni caso vale lo stesso principio della nostra guida alla verifica in fase di iscrizione: verifica prima che un indirizzo raggiunga il tuo strumento di invio, così un errore di battitura diventa un lead corretto invece di un bounce che paghi più avanti. Se i tuoi moduli si trovano su più strumenti, lo schema si generalizza: un passaggio no-code con Zapier o un webhook di Typeform fa lo stesso lavoro per quelle piattaforme.

Pronto a ripulire le risposte di Google Forms? Il piano Free include 100 crediti per provare entrambe le strade, la verifica gratuita di un singolo indirizzo non richiede alcuna configurazione e il riferimento API contiene l'endpoint /verify con esempi da copiare e incollare in sette linguaggi.