Verificare le email da Typeform senza un plugin

Typeform è bravissimo a raccogliere indirizzi email e, senza farlo notare, pessimo nel dirti quali sono veri. Il suo campo email controlla che quello che qualcuno ha digitato sembri un indirizzo: non può confermare che la casella esista, che non sia usa e getta o che il tuo primissimo follow-up non generi un hard bounce. Questa guida mostra due modi pratici per verificare le email da Typeform con Qualisend: in tempo reale, con un webhook che scatta non appena arriva una risposta, e in blocco, esportando le risposte in un CSV. Nessuno dei due richiede un plugin nativo (per ora non esiste): bastano i webhook integrati di Typeform o il suo pulsante di esportazione.

In breve#

Scegli il percorso in base a quando ti serve la risposta:

• In tempo reale: punta un webhook di Typeform verso una piccola funzione serverless. A ogni invio del form, Typeform manda la risposta con una POST al tuo endpoint; la funzione estrae l'email, chiama l'API di Qualisend e agisce in base all'esito: aggiunge un tag al contatto, lo indirizza alla lista giusta o sospende l'email di benvenuto se l'indirizzo non è valido.
• In blocco: esporta le risposte esistenti in CSV, passale alla verifica in blocco di Qualisend e sopprimi gli indirizzi non recapitabili prima del prossimo invio.

Perché il campo email di Typeform non basta#

Il tipo di domanda email di Typeform esegue un controllo del formato nel browser: si assicura che ci siano una @, un dominio e nessuna stringa palesemente senza senso. È lo stesso tipo di controllo di una regex, e fallisce per gli stessi motivi: il formato non è deliverability. jane@gmial.com supera il controllo del formato. Lo stesso vale per throwaway@mailinator.com e per un indirizzo dall'aspetto credibile su un dominio chiuso l'anno scorso.

Nessuno di questi viene intercettato finché non invii, e a quel punto un indirizzo morto è un hard bounce che intacca il tuo tasso di bounce e la reputazione del mittente. Una vera verifica aggiunge i livelli che Typeform non ha: una ricerca DNS/MX e un test SMTP della casella, più gli indicatori per indirizzi usa e getta, generici e catch-all. Se questa pipeline è nuova per te, cosa controlla davvero la verifica email è il punto di partenza.

Due modi per verificare le email da Typeform#

Prima il vincolo importante: Typeform non può bloccare un'email non valida a metà form. Non esiste un modo supportato per chiamare un'API esterna tra una domanda e l'altra e impedire a chi risponde di finire, quindi la verifica in tempo reale avviene subito dopo l'invio, in un webhook, e non come un blocco in linea. Questo condiziona entrambi i percorsi.

Percorso 1: in tempo reale con un webhook di Typeform#

Typeform può inviare ogni risposta a un URL che controlli tu. Nel pannello Connect del form, aggiungi un webhook e puntalo verso il tuo endpoint. Su Typeform i webhook sono una funzione dei piani a pagamento, quindi controlla il tuo piano prima di iniziare a sviluppare. Quando viene inviata una risposta, Typeform invia con una POST un payload JSON il cui array form_response.answers contiene ogni risposta: l'indirizzo email si trova nella risposta di tipo email.

Il tuo endpoint è una funzione serverless che custodisce la chiave API e trasforma l'esito in un'azione. Lo schema è lo stesso della guida alla verifica all'iscrizione: la chiave resta lato server e tu agisci sul risultato. Eccolo come Route Handler di Next.js (controlla la documentazione per sviluppatori per il percorso esatto dell'endpoint e la forma della richiesta):

// app/api/typeform-webhook/route.ts
import { NextResponse } from "next/server";

// Qualisend's verify endpoint (full request and response shapes in /developers).
const QUALISEND_ENDPOINT = "https://app.qualisend.com/api/v1/verify";

export async function POST(req: Request) {
  const payload = await req.json();

  // The email lives in the answer whose type is "email".
  const answers = payload.form_response?.answers ?? [];
  const email = answers.find((a) => a.type === "email")?.email;
  if (!email) return NextResponse.json({ ok: true }); // nothing to verify

  const res = await fetch(QUALISEND_ENDPOINT, {
    method: "POST",
    headers: {
      // Store YOUR_API_KEY server-side, never in the browser.
      Authorization: `Bearer ${process.env.QUALISEND_API_KEY!}`,
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ email }),
    signal: AbortSignal.timeout(4000),
  }).catch(() => null); // timeout or network error: fail open too

  if (!res?.ok) return NextResponse.json({ ok: true, degraded: true }); // fail open
  const { job_id, result } = await res.json();

  // The submit already happened — route on the verdict instead of blocking.
  if (result.status === "undeliverable" || result.sub_flags?.disposable) {
    // Skip the welcome email, tag the contact for review, keep it off the main list.
  } else if (result.smtp === "pending") {
    // The mailbox probe is still running. Queue job_id for a background job that
    // polls GET https://app.qualisend.com/api/v1/jobs/{job_id} and routes the final
    // verdict; don't wait for it here, and don't call /verify again.
  }

  return NextResponse.json({ ok: true, status: result.status });
}

Tre accorgimenti rendono robusto questo schema. Rispondi in fretta: Typeform si aspetta rapidamente un 2xx, quindi tieni leggero l'handler e rispondi subito. Lascia passare in caso di errore (fail open): se l'API va in timeout o restituisce un errore, non perdere il lead: accettalo e ricontrollalo più tardi, ed è per questo che il ramo !res?.ok restituisce comunque ok: true. E verifica la firma inviata da Typeform, così un estraneo non può mandare risposte false al tuo endpoint: il pannello Connect ti fornisce un secret apposta.

La prima risposta è l'esito immediato. Quando result.smtp è cached o skipped, l'esito è già definitivo. Finché result.smtp è pending, il test SMTP della casella è ancora in corso, quindi status indica unknown e l'esito definitivo arriva su GET https://app.qualisend.com/api/v1/jobs/{job_id}. Interroga quell'endpoint da un job in background anziché dentro il webhook, e mai chiamando di nuovo /verify.

Un'insidia nel payload: se il tuo form ha più di una domanda email, o se vuoi essere al riparo da un riordino delle domande, basati sul field.ref della risposta invece di prendere la prima risposta con type === "email". Imposta un ref stabile sulla domanda email nel builder di Typeform e leggi a.field?.ref === "your_ref", così verifichi sempre l'indirizzo giusto.

A valle, l'esito è solo una diramazione. Un risultato deliverable passa direttamente al tuo CRM o strumento email; un undeliverable o disposable riceve un tag, viene escluso dalla sequenza di benvenuto o finisce in una coda di revisione, secondo ciò che serve al tuo processo. Il webhook è l'infrastruttura; l'instradamento lo decidi tu.

La logica di verifica in sé non dipende dal linguaggio: la stessa chiamata funziona da una funzione Python o PHP, se è il tuo stack. Il codice dell'endpoint nella guida per Node.js o nella guida per Python si inserisce senza modifiche in un handler del webhook: solo l'analisi del payload vista sopra è specifica di Typeform.

Percorso 2: verificare in blocco un'esportazione CSV#

Se hai già una montagna di risposte, o preferisci pulire a intervalli regolari anziché collegare un webhook, procedi a blocchi. In Typeform, apri Results → Responses e scarica i dati in CSV (o XLSX). Otterrai una riga per ogni risposta, con l'email in una colonna a sé.

Poi:

1. Carica il CSV nella verifica in blocco di Qualisend e lascia che esegua l'intero processo (MX, SMTP e gli indicatori per usa e getta, generici e catch-all) su ogni riga.
2. Scarica il file annotato. Ogni indirizzo torna con uno stato, un codice motivo e un punteggio da 0 a 100.
3. Sopprimi gli indirizzi non recapitabili nello strumento da cui invii davvero e gestisci con cautela le righe a rischio. La procedura completa, compresa la destinazione di ogni stato, è in come pulire una lista email.

La verifica in blocco è lo strumento giusto per un arretrato, ma è pulizia, non prevenzione: un indirizzo che intercetti qui di solito era già nella tua lista da tempo. Abbina un passaggio periodico in blocco al webhook in tempo reale, così i nuovi indirizzi errati vengono segnalati nel momento in cui arrivano.

Agire in base all'esito#

Qualunque sia il percorso che fornisce il risultato, la forma è la stessa: uno status, un reason, uno score e gli indicatori aggiuntivi. Associa ciascuno a un'azione:

Pronto a collegare tutto? Prendi una chiave con gli scope giusti e il formato esatto della richiesta nella documentazione per sviluppatori, fai un controllo rapido su un singolo indirizzo con la verifica email gratuita oppure parti dai 100 crediti gratuiti disponibili su ogni piano per testare il flusso dall'inizio alla fine.