Airtable email verification

Verify an email column in Airtable

Run an Airtable script or automation that calls Verifly for each row and writes the verdict back to a status field. Undeliverable, disposable, and role addresses get flagged right in your base.

Verify an email from an Airtable scriptAPI
const res = await fetch(
  'https://verifly.email/api/v1/verify?email=' + encodeURIComponent(email),
  { headers: { Authorization: 'Bearer vf_your_api_key' } }
);
const { result } = await res.json(); // deliverable | undeliverable | risky

Real-time SMTP mailbox checks

Single, batch, and async bulk verification

Disposable, role account, and catch-all detection

Pay-as-you-go credits with no subscription lock-in

Search fit

Built for Airtable email verification

Use Verifly when you need a simple API, predictable pricing, and clean JSON results before emails hit your product, CRM, or campaign tool.

Verify an email column with an Airtable scripting-app script
Trigger verification automatically when a new record is created
Write the deliverable / undeliverable verdict back to a status field
Flag disposable and role addresses inside the base for review

Why an Airtable email column needs verification

Airtable's Email field type validates format only — it accepts anything shaped like an address. Bases fill up with emails from form submissions, imports, CSV pastes, and connected apps, and plenty of those addresses are mistyped, disposable, or long dead. When you sync that base to a sender, a CRM, or a Mailchimp import, every bad row becomes a bounce.

Because Airtable is so often the source of truth that other tools pull from, a dirty email column quietly pollutes everything downstream. Verifying inside the base — and writing the verdict next to each address — means the clean/dirty decision travels with the data, so every automation and sync that reads the base can respect it.

Verifly runs a live SMTP mailbox check and returns a deliverable / undeliverable / risky verdict with disposable, role, and catch-all flags. Airtable's Scripting app and automation scripts both run standard fetch, so calling Verifly and writing the result back is a short script.

Verify the whole column with a scripting-app script

  1. Grab a free Verifly key at verifly.email/api/v1/autonomous/register — 100 credits, no card, no captcha.
  2. Add a single-line-text or single-select field named Email Status and (optionally) a checkbox named Disposable.
  3. Open the Scripting app, paste the script below, and set your table, email field, and status field names.
  4. Run it to loop the records, call Verifly for each address, and update the status field in place.
  5. Filter or group by Email Status to isolate and remove the undeliverable rows before your next sync.
Airtable Scripting app
const table = base.getTable('Contacts')
const query = await table.selectRecordsAsync({
  fields: ['Email', 'Email Status'],
})

for (const record of query.records) {
  const email = record.getCellValueAsString('Email')
  if (!email || record.getCellValueAsString('Email Status')) continue

  const res = await fetch(
    'https://verifly.email/api/v1/verify?email=' + encodeURIComponent(email),
    { headers: { Authorization: 'Bearer vf_your_api_key' } }
  )
  const data = await res.json()

  await table.updateRecordAsync(record, {
    'Email Status': data.disposable ? 'disposable' : data.result,
  })

  await new Promise(r => setTimeout(r, 200)) // gentle pacing
}

Do it automatically on new records

To verify addresses as they arrive rather than in a batch, use an automation: trigger When a record is created (or matches a view), add a Run script action, and verify just the triggering record. Airtable passes the record ID into the script through input config, so you fetch that one email, call Verifly, and write the verdict back. This keeps the column continuously clean without anyone running the batch by hand.

Automation Run-script action
const { recordId } = input.config()
const table = base.getTable('Contacts')
const record = await table.selectRecordAsync(recordId, { fields: ['Email'] })
const email = record.getCellValueAsString('Email')

const res = await fetch(
  'https://verifly.email/api/v1/verify?email=' + encodeURIComponent(email),
  { headers: { Authorization: 'Bearer vf_your_api_key' } }
)
const data = await res.json()

await table.updateRecordAsync(recordId, {
  'Email Status': data.disposable ? 'disposable' : data.result,
})

FAQ

Frequently asked questions

Do I need an external tool like Zapier or Make?

No. Airtable's built-in Scripting app and automation Run-script action both support the standard fetch API, so you can call Verifly and write the verdict back without any middleware. Those tools are an option, but they aren't required.

Where does the verdict get stored?

In whatever field you point the script at — the examples write to an Email Status field, mapping deliverable / undeliverable / risky (and disposable) straight into a single-select or text column so you can filter and group by it.

Won't a big base hit Airtable's script limits?

For large bases, verify in chunks or export the email column and run it through POST /verify/batch, then import the verdicts back. Batch is faster and cheaper per address than looping thousands of single calls inside a script.

Can I verify records automatically as they come in?

Yes. Use a record-created (or enters-view) automation trigger with a Run-script action that verifies just the new record, so the column stays clean without a manual batch run.

How are catch-all and role addresses handled?

Every response includes disposable, role, and catch-all flags. Catch-all domains accept mail for any address so no verifier can confirm the mailbox; Verifly flags them rather than guessing, and you choose how to treat them in your view.

What does verifying an Airtable column cost?

Pricing is pay-as-you-go from $2 per 1,000 checks down to $0.60 per 1,000 at volume, with 100 free credits to start and no monthly minimum, so a small base costs a few cents to clean.