Verificare le email da Airtable senza plugin

Airtable è il posto in cui molti team tengono i propri contatti: un form di iscrizione alimenta una base, un'Interface raccoglie lead, un'importazione CSV aggiunge la lista dell'evento della settimana scorsa. Il campo email di Airtable però controlla solo che un indirizzo sembri corretto: non può dirti se la casella esiste davvero, se è usa e getta o se genererà un hard bounce al tuo primo invio. Questa guida mostra due modi pratici per verificare le email da Airtable con Qualisend: in tempo reale, con un'automazione che esegue un breve script su ogni nuovo record, e in blocco, esportando una vista in CSV. Nessuno dei due richiede un plugin nativo (che ancora non esiste): bastano le automazioni integrate di Airtable o il suo pulsante di esportazione.

In breve#

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

• In tempo reale: crea un'Automation di Airtable con un'azione Run a script. A ogni record nuovo (o aggiornato) legge l'email, chiama l'API di Qualisend con fetch e scrive l'esito in un campo della stessa riga. Il record ora contiene uno status e uno score che puoi usare per filtrare, raggruppare e instradare.
• In blocco: esporta una tabella o una vista in CSV, passala alla verifica in blocco di Qualisend e reimporta il file pulito per compilare una colonna di stato su tutto ciò che è già nella tua base.

Perché il campo email di Airtable non basta#

Il tipo di campo Email di Airtable esegue un controllo del formato: 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 è la deliverability. jane@gmial.com supera il controllo del formato. Lo stesso vale per throwaway@mailinator.com e per un indirizzo dall'aspetto reale su un dominio che ha chiuso senza clamore 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 un foglio di calcolo non ha: una ricerca DNS/MX e una verifica SMTP della casella, più gli 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 Airtable#

Prima di tutto il vincolo importante: la verifica avviene dopo che la riga esiste, non come controllo inline sul form o sull'Interface che l'ha creata. Airtable non offre un modo supportato per bloccare un invio durante l'inserimento in base a una chiamata API esterna, quindi verifichi il record appena arriva e poi agisci in base all'esito: questo condiziona entrambi i percorsi qui sotto.

La maggior parte dei team finisce per fare entrambe le cose: uno script sull'acquisizione in tempo reale, più una pulizia della lista occasionale per intercettare gli indirizzi diventati obsoleti da quando sono stati aggiunti.

Percorso 1: in tempo reale con un'automazione Airtable#

Le Automation di Airtable possono eseguire uno snippet JavaScript con un'azione Run a script, e quello snippet può chiamare un'API esterna con fetch: tutto ciò che ti serve per verificare un record senza uscire da Airtable.

1. Scegli il trigger. In Automations, creane una e scegli un trigger:

• When a record is created: la scelta più semplice per un form o un'Interface che aggiunge nuove righe.
• When a record matches conditions (es. Email status is empty): utile per saltare le righe già verificate.
• When a record enters a view: puntalo su una vista filtrata con Email status = empty, così le riesecuzioni non ti addebitano mai due volte lo stesso indirizzo.

2. Aggiungi l'azione "Run a script" e configura due variabili di input nel pannello sinistro dell'azione: associa email al campo email del record che ha attivato il trigger e recordId all'ID del record Airtable. Lo script le legge tramite input.config().

3. Scrivi lo script. Lo script chiama Qualisend, poi scrive l'esito sulla stessa riga. Conferma l'endpoint esatto e la forma della richiesta nella documentazione per sviluppatori; i segnaposto qui sotto sono da compilare:

// Airtable automation → "Run a script" action.
// Input variables (set in the action's left panel):
//   email     → the triggering record's email field
//   recordId  → the triggering record's record ID
let { email, recordId } = input.config();

let table = base.getTable("Contacts");

try {
  let response = await fetch("https://app.qualisend.com/api/v1/verify", {
    method: "POST",
    headers: {
      // Use a scoped, verify-only key — see the note below on key safety.
      "Authorization": "Bearer YOUR_API_KEY",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({ email }),
  });
  // 402 (out of credits), 429 (rate limited) or 5xx: fail open in the catch below.
  if (!response.ok) throw new Error(`Qualisend returned ${response.status}`);

  // Response shape: { job_id, result: { status, score, reason, sub_flags, smtp } }
  let { job_id, result } = await response.json();

  if (result.smtp === "pending") {
    // The mailbox probe is still running, so result.status is only a
    // preliminary "unknown". Park the job ID; the follow-up script writes
    // the final verdict.
    await table.updateRecordAsync(recordId, {
      "Email status": "pending",
      "Qualisend job ID": job_id,
    });
  } else {
    await table.updateRecordAsync(recordId, {
      "Email status": result.status, // text: deliverable / risky / undeliverable / unknown
      "Email score": result.score,   // number: 0–100
    });
  }
} catch (err) {
  // Fail open: never lose a contact if the API is briefly unreachable.
  await table.updateRecordAsync(recordId, { "Email status": "unknown" });
}

4. Recupera gli esiti ancora in sospeso. La risposta arriva subito, ma in quel momento la verifica SMTP della casella può essere ancora in corso: in tal caso result.smtp è "pending" e result.status è solo un unknown preliminare. Per questo lo script salva invece il job_id in un campo di testo Qualisend job ID. Aggiungi una seconda automazione con un trigger At a scheduled time e un'azione Run a script che legge l'esito finale di ogni riga in sospeso da GET /jobs/{job_id}. Non chiama mai di nuovo /verify, quindi nessun indirizzo viene addebitato due volte:

// Second automation: "At a scheduled time" trigger → "Run a script" action.
// Writes the final verdict onto every row the first script left "pending".
let table = base.getTable("Contacts");
let query = await table.selectRecordsAsync({
  fields: ["Email status", "Qualisend job ID"],
});

for (let record of query.records) {
  if (record.getCellValueAsString("Email status") !== "pending") continue;

  let jobId = record.getCellValueAsString("Qualisend job ID");
  let response = await fetch(
    `https://app.qualisend.com/api/v1/jobs/${jobId}?include=results`,
    { headers: { "Authorization": "Bearer YOUR_API_KEY" } },
  );
  if (!response.ok) continue; // leave it pending; the next run retries

  let job = await response.json();
  if (job.status === "pending" || job.status === "processing") continue; // still probing

  let final = (job.results || [])[0] || { status: "unknown", score: null };
  await table.updateRecordAsync(record.id, {
    "Email status": final.status,
    "Email score": final.score,
  });
}

Alcuni accorgimenti rendono tutto questo robusto e sicuro:

• Usa una chiave con ambito limitato. Gli script di automazione di Airtable conservano la chiave nel testo dello script, dove qualsiasi collaboratore della base può leggerla, e non esiste un archivio di segreti lato server per uno snippet del genere. Crea quindi per questa automazione una chiave di sola verifica invece di una con accesso completo: se dovesse trapelare, potrà verificare indirizzi e leggere i risultati delle verifiche, ma non modificare il tuo account, le chiavi API o la fatturazione. La documentazione per sviluppatori spiega come limitare l'ambito di una chiave. È l'equivalente Airtable della regola "la chiave resta lato server" nello schema serverless di verifica all'iscrizione.
• Applica il fail open. Se la richiesta va in errore, scade o restituisce 402 (crediti esauriti), 429 (limite di frequenza) o 5xx, non scartare il record: il blocco catch scrive unknown, così una persona (o una riesecuzione successiva) può riprenderlo. Un'API di verifica è un filtro di qualità, non un controllo di autenticazione; un'interruzione temporanea non deve mai cancellare un lead reale.
• Evita i loop di riattivazione. Se il tuo trigger è When a record is updated, osserva un campo specifico (il campo email), non "any field", altrimenti la scrittura qui sopra riattiverà l'automazione su se stessa. Usare come trigger la creazione di un record o una vista filtrata elimina del tutto il problema.
• Usa i tipi di campo giusti. Un campo di testo a riga singola accetta la stringa di stato così com'è. Se preferisci una selezione singola, passa { name: result.status } e crea prima le cinque opzioni (deliverable, risky, undeliverable, unknown, pending), così la scrittura non fallisce.

La chiamata di verifica in sé non dipende dal linguaggio: la stessa richiesta funziona da un webhook di Typeform o da una Custom Request di Zapier, se parte del tuo stack è fuori da Airtable. Solo il raccordo input.config() / updateRecordAsync qui sopra è specifico di Airtable.

Percorso 2: verificare in blocco un'esportazione CSV#

Se hai già una base piena di contatti, o preferisci pulire a intervalli regolari invece di eseguire uno script per riga, procedi a lotti. È anche la scelta giusta quando un'automazione per record consumerebbe tutta la quota di esecuzioni del tuo piano.

1. Esporta una vista in CSV. Nella griglia, apri view menu → Download CSV (oppure seleziona prima una vista filtrata, così esporti solo le righe che ti interessano). Otterrai una riga per record con l'email in una colonna a sé.
2. Passa il file alla verifica in blocco e lascia che Qualisend applichi l'intera pipeline (MX, SMTP e gli indicatori usa e getta / generico / catch-all) a ogni riga.
3. Scarica il file annotato. Per ogni indirizzo ottieni uno status, un codice reason e uno score da 0 a 100.
4. Reimporta in Airtable. Riporta il CSV pulito in Airtable, abbinando le righe sulla colonna email, per compilare un campo di stato in tutta la base. Poi sopprimi gli indirizzi non recapitabili prima del prossimo invio e gestisci con cautela le righe a rischio: la procedura completa è in come pulire una lista email.

Il percorso in blocco è lo strumento giusto per un arretrato, ma è pulizia, non prevenzione: un indirizzo che intercetti qui di solito è già da tempo nella tua base. Abbina un passaggio periodico in blocco all'automazione del percorso 1, così i nuovi indirizzi non validi vengono contrassegnati appena 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:

Poiché l'esito sta in un campo, tutto ciò che viene dopo diventa un semplice filtro Airtable: una vista "lista pulita" con Email status = deliverable, una vista di soppressione per undeliverable. Per il quadro completo di come la pipeline arriva a ogni stato, vedi come funziona la verifica email.

Pronto a collegare tutto? Crea una chiave con ambito limitato, di sola verifica, e trova il formato esatto della richiesta nella documentazione per sviluppatori, prova un singolo indirizzo nella verifica email gratuita, oppure parti dai 100 crediti gratuiti di ogni piano per testare entrambi i percorsi dall'inizio alla fine prima di impegnarti.