Come verificare le email da Jotform

Jotform è un modo rapido per proporre un modulo alle persone e raccogliere i loro indirizzi email ma, come ogni strumento per creare moduli, è più bravo a catturare gli indirizzi che a dirti quali sono reali. Il suo campo email conferma che un indirizzo sembra corretto; non può confermare che la casella esista, che non sia usa e getta o che non generi un hard bounce alla tua prima risposta. Questa guida mostra due modi pratici per verificare le email da Jotform con Qualisend: in tempo reale, con un webhook che scatta nel momento in cui arriva un invio, e in blocco, esportando gli invii in un foglio di calcolo. Nessuno dei due richiede un plugin nativo (per ora non esiste): bastano i webhook integrati di Jotform o il suo pulsante di esportazione.

In breve#

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

• In tempo reale: collega un webhook di Jotform a una piccola funzione serverless. A ogni invio Jotform manda via POST i dati del modulo al tuo endpoint; la funzione legge l'email, chiama l'API di Qualisend e agisce in base all'esito: aggiunge un tag al contatto, lo instrada alla lista giusta o sospende l'email di benvenuto se l'indirizzo è errato.
• In blocco: esporta gli invii esistenti in CSV o Excel, passali alla verifica in blocco di Qualisend e sopprimi gli indirizzi non recapitabili prima del prossimo invio di email.

Perché il campo email di Jotform non basta#

Il tipo di domanda email di Jotform esegue un controllo del formato nel browser: si assicura che ci siano una @, un dominio e nessun errore di battitura evidente. È 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 test@mailinator.com e per un indirizzo dall'aspetto reale su un dominio che l'anno scorso ha smesso silenziosamente di funzionare.

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. La vera verifica aggiunge i livelli che Jotform non può offrire: una ricerca DNS/MX e un test SMTP della casella, più indicatori per gli 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 Jotform#

Prima il vincolo importante: Jotform non può bloccare in modo affidabile un'email errata a metà modulo. Non esiste un modo supportato, su tutti i piani, per chiamare un'API esterna tra un campo e l'altro e impedire a qualcuno di inviare il modulo, quindi la verifica in tempo reale avviene subito dopo l'invio, in un webhook, e non come filtro in linea. Questo condiziona entrambi i percorsi.

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

Jotform può inviare ogni modulo compilato a un URL che controlli tu. Apri il modulo, vai su Settings → Integrations, cerca Webhooks e incolla l'URL del tuo endpoint. A differenza di alcuni strumenti per moduli che riservano i webhook ai piani più alti, l'integrazione Webhooks di Jotform è ampiamente disponibile, anche sul piano gratuito: a essere limitato in base al piano è il numero mensile di invii, non l'accesso al webhook.

Una particolarità di Jotform condiziona il codice: Jotform non invia via POST un JSON pulito. Invia il modulo compilato come campi form-encoded, in cui ogni risposta prende il nome dalla sua domanda: un campo email di solito arriva con un nome come q3_email. C'è anche un campo rawRequest con una stringa JSON dell'intero invio, se preferisci analizzare quella. In ogni caso il tuo endpoint legge il corpo del modulo, non req.json().

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/jotform-webhook/route.ts
import { NextResponse } from "next/server";

// Single-address check; full reference in /developers.
const QUALISEND_ENDPOINT = "https://app.qualisend.com/api/v1/verify";

export async function POST(req: Request) {
  // Jotform POSTs form-encoded fields, not JSON.
  const form = await req.formData();

  // Jotform names email fields like q3_email — check yours in the builder.
  const email = form.get("q3_email")?.toString();
  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

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

  // The submission already landed — 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") {
    // Mailbox probe still running: queue job_id and read the final verdict from
    // GET https://app.qualisend.com/api/v1/jobs/{job_id} in a background job.
  }

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

Tre accorgimenti rendono robusto questo schema. Rispondi in fretta: Jotform si aspetta rapidamente un 2xx, quindi mantieni il gestore snello 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. Infine proteggi l'endpoint: Jotform non firma i suoi webhook con un segreto condiviso come fanno altri strumenti, quindi proteggi l'URL in un altro modo: rendilo impossibile da indovinare e rifiuta ogni richiesta il cui formID non corrisponde al modulo che ti aspetti, prima di spendere un credito di verifica.

Un dettaglio sui tempi: quando result.smtp risulta "pending", il test della casella è ancora in corso e l'esito finale arriva poco dopo su GET /api/v1/jobs/{job_id}. Leggilo da un processo in background, non dentro il gestore, così Jotform riceve comunque il suo 2xx rapido.

Se il tuo modulo ha più di una domanda email, non limitarti a prendere la prima che trovi: leggi il nome specifico del campo (q7_email, q12_workEmail o quello assegnato dal builder), così verifichi sempre l'indirizzo giusto. Puoi vedere il nome di ogni campo nel builder di Jotform oppure ispezionando una volta il payload di un invio di prova.

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, e lo stesso approccio con webhook vale per qualsiasi strumento per moduli. Vedi verificare le email da Typeform per una configurazione quasi identica, in cui l'unica vera differenza è come viene analizzato il payload. Solo quel passaggio di analisi è specifico di Jotform; la parte di verifica e instradamento è uguale ovunque.

Percorso 2: verificare in blocco un'esportazione CSV o Excel#

Se hai già una montagna di invii, o preferisci pulire a intervalli regolari anziché collegare un webhook, procedi a lotti. In Jotform apri la tabella Submissions del modulo (oppure Reports → Excel/CSV) e scarica i dati. Otterrai una riga per ogni invio, con l'email in una colonna a sé.

Poi:

1. Carica il file nella verifica in blocco di Qualisend e lascia che esegua l'intero processo (MX, SMTP e gli indicatori usa e getta, generico e catch-all) su ogni riga.
2. Scarica il file annotato. Ogni indirizzo torna con uno status, un codice reason e uno score 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 i sub_flags. 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.