Article
How to Verify Emails in Clay Tables: Practical Steps for GTM Teams
By Unlimited Verifier Team ·

Summary
To verify emails in a Clay table, add a verification column after each enrichment step, check syntax, domain, MX record and SMTP mailbox, then sort results into Valid, Risky and Invalid. Only Valid rows should reach a sequencer, with Risky rows held for later testing and Invalid rows suppressed.To verify emails in a Clay table, add a verification column after your enrichment waterfall, check each address's syntax, domain, MX record and SMTP mailbox, and filter the results into Valid, Risky and Invalid before any sequencer sees them.
A Clay table is a spreadsheet-style workspace where each column holds either source data or the output of an enrichment step. That layout is why verification gets skipped. The email column fills up, the table looks finished, and nobody checks whether the address will accept mail. This guide covers where verification belongs in a waterfall, which method fits which table size, and how to write results back without losing rows. For the wider context, see our pillar on email verification for sales prospecting.
Quick answer
- Verify each waterfall candidate before moving to the next provider. A "found" address that bounces should not end the waterfall as if it were good.
- Use a CSV round trip for batch work. Export the table, verify it in Unlimited Verifier, and re-import the results keyed on a row ID. Unlimited standard verification is included on every plan, including Free.
- Use the API for tables that refresh. API access is on Pro only, which includes 100,000 API emails a month and bulk requests of up to 10,000 emails.
- Send only Valid rows. Hold Risky rows (catch-all, role-based and disposable addresses) for a later test, and suppress Invalid rows.
What does it mean to verify emails in a Clay table?
It means adding a column that records whether each address is deliverable, not whether a provider returned one. Enrichment answers "where might this person's email be?" Verification answers "will this mailbox accept mail?" A table can answer the first question well and the second one badly. For the distinction in depth, read email finder vs email verifier difference.
Measure two rates. The found rate is the share of rows with any address. The deliverable rate is the share of rows whose address passes verification. Teams running multi-provider waterfalls often find the gap is widest in later rounds, because fallback providers tend to return addresses with less supporting evidence. That gap is where hard bounces come from.
Verification also does not prove consent. A live mailbox is not an opted-in contact, a distinction that matters for the compliance section below.
Bottom line: Treat every email a waterfall returns as a candidate until a verification column says otherwise.
Why does verification matter more in a waterfall than in a plain CSV?
A waterfall stops at the first address it finds, so an invalid address counts as a success unless you check it. Each added provider raises coverage, but it also adds addresses that nobody has validated.
Mailbox providers judge you by bounces and complaints, not by how many rows your table produced. Google's sender guidelines set 0.3% as the spam-rate line bulk senders must stay under. Amazon SES's public documentation names 5% as the bounce level that triggers review.
The sources disagree on bounce thresholds, and many ESPs act earlier on a single campaign to an unproven list. We recommend a 2% total bounce ceiling and a 1% target for the first sends from any new table. That leaves room below the automated triggers.
Here is what that looks like at table scale. Suppose a waterfall returns 4,300 addresses and 480 are invalid. Sending all of them unverified produces 480 ÷ 4,300 = 11.2% bounces, more than twice the SES review level, from one table.
If a bounce spike has already happened, Smartlead's bounce-rate fix guide covers recovery. For context on what "normal" looks like, see average cold email bounce rate benchmarks.
Labels also vary. An enrichment platform's "verified" tag is not a universal standard, as Apollo's verified vs guessed status explains. A mailbox check is what turns a label into evidence.
Bottom line: A waterfall optimizes for coverage, so verification must supply the quality check the waterfall skips.
Which method should you use to verify a Clay table?
For most tables, start with a CSV round trip through Unlimited Verifier. Move to the API only when the same table has to be verified repeatedly. Choose a verifier using the criteria in how to choose an email verifier and the shortlist in best email verifiers for Clay waterfall enrichment.
| Method | Where it runs | What you get back | Best for | Drawback specific to this method |
|---|---|---|---|---|
| Provider's own verification step inside Clay | Inside the table, using a provider you already connect | That provider's status label for each row | Quick checks on small tables with one provider | Labels differ between providers, so mixing them in one column makes filters unreliable |
| CSV round trip through Unlimited Verifier | Export from Clay, verify in the web app, re-import | Valid, Risky or Invalid, with catch-all, disposable and role-based flags; export as CSV, Excel or JSON | Batch runs and campaign prep, from a few hundred rows to 25,000 per list | Manual steps; results must be joined back to the table on a row ID |
| API call from the table | An HTTP request on each run, authenticated with your API key | Statuses returned for writing back to columns | Tables that refresh on a schedule | Pro only; you build the request and map the response fields yourself |
| Free single-email checker | Browser tool | A result for one address | Spot-checking a VIP contact or a disputed row | Not a table workflow; one address at a time |
Unlimited Verifier has no native Clay integration, so bulk work runs either as a CSV round trip or as API calls. To start the round trip, upload and verify a list. For one disputed row, use the free email checker.
Bottom line: Use the CSV round trip for most tables, and reserve the API for tables that need refreshing.
Where should verification sit in your waterfall?
Verify inside the loop, after each provider round, then run one final pass over the whole table before anything reaches a sequencer. Verifying only at the end is cheaper but loses rows.
- Verify at the end. Run the full waterfall, then verify the final column once. This uses the fewest verifications. But an address that fails early stops the waterfall, so those rows finish with nothing usable.
- Verify in the loop. Verify each round's output before running the next provider. Invalid addresses go back into the waterfall, so rows that would have been lost get another chance.
The extra verifications are cheap relative to the cost of a bounce. A bad address that reaches a sequence costs a bounce and can cost sender reputation too. Avoid re-verifying addresses that already have a current result. Keep the result column, and skip rows already marked Valid in later rounds.
Bottom line: Verify inside the loop after every round, then do one whole-table pass before sending.
How does the verify-route-send loop work?
Each row moves through the loop until it resolves as Valid or runs out of providers. Use this six-step framework for any waterfall table.
- Tag every row with a stable ID. A row ID that never changes is the only reliable way to write results back after sorting or re-importing.
- Run one waterfall round. Use one provider per round, in the order you chose.
- Verify that round's output. Check every address the round returned, not a sample.
- Route each row. Valid rows are done. Invalid and no-email rows go to the next round. Risky rows go to a separate, named list.
- Repeat until rows resolve or rounds run out. Stop when every row is resolved or you reach your last provider.
- Run a final pass and send only Valid rows. Log the counts so future runs can be compared. If you sequence in Instantly, the same logic applies; see how to verify Instantly leads before launching.
Bottom line: The loop turns one guess per row into a sorted list with evidence behind each row.
How do you round-trip a Clay table through Unlimited Verifier?
Follow these ten steps. They assume you are running a table of a few thousand rows, which needs a paid plan.
- Count your rows and pick a plan. Free accepts lists of up to 150 emails, with 25 lists a month. Pro accepts lists of up to 25,000 emails, with unlimited lists. A 5,000-row table on Free needs 34 lists (5,000 ÷ 150 = 33.3, rounded up), more than the 25-list monthly cap, so use Pro. A 5,000-row table fits in a single Pro list.
- Add a row ID column. Use the source record's unique ID or a sequential number. Without it, you cannot reliably join results back.
- Trim the export. Keep the row ID, the email and, optionally, the name. Long enrichment text fields can push a large file past the 10MB upload limit.
- Export the table to CSV using Clay's export option, and save the file somewhere you can find it.
- Sign up for an account. The Free plan is enough to test on a sample before you commit to a full table.
- Upload the file. Confirm the email column was detected automatically, then run deep verification on the rows you plan to send.
- Export the results as CSV, Excel or JSON. Free keeps results for 24 hours and Pro for 30 days, so download promptly.
- Re-import into Clay as a new table or column, joining on the row ID. Check that the row count matches the original before filtering anything.
- Create three filters: status is Valid (send), status is Risky (hold), and status is Invalid or no email (next waterfall round).
- Save the counts of Valid, Risky, Invalid and total rows in a log, so each run can be compared with the last.
Bottom line: Count rows, protect the row ID, and check the row count before you filter.
What does a 5,000-row Clay table look like in numbers?
This example uses hypothetical results to show the arithmetic. It assumes 5,000 target contacts, each needing one usable email, and a Pro plan at $29 a month.
Round 1. Provider A returns addresses for 3,400 of the 5,000 rows (68%). Verification gives:
- Valid: 2,550 (75% of returned addresses)
- Risky: 480 (14%)
- Invalid: 370 (11%)
Round 2. The rows still needing an address are the 1,600 with no email plus the 370 invalid rows, for 1,970 in total. Provider B returns addresses for 900 of them. Verification gives:
- Valid: 640
- Risky: 150
- Invalid: 110
Final tally:
| Outcome | Rows | Share of 5,000 |
|---|---|---|
| Valid (send) | 2,550 + 640 = 3,190 | 63.8% |
| Risky (hold) | 480 + 150 = 630 | 12.6% |
| No deliverable address | 110 invalid + 1,070 with no email found = 1,180 | 23.6% |
Verification volume. 3,400 + 900 = 4,300 verifications. If all of them run as deep verifications, that is 17.2% of Pro's 25,000 monthly allowance. Free's 750 deep verifications would cover under a fifth of that run.
Sending math. The 3,190 Valid rows should produce no more than 31 bounces to stay under 1%, since 1% of 3,190 is 31.9. Start with the most engaged subset to protect that number.
Why the loop mattered. Without verification, all 4,300 addresses would go out, including the 480 invalid ones (370 from round 1 and 110 from round 2). That is the 11.2% scenario from earlier. With the loop, the invalid addresses are removed before sending.
Bottom line: You end with 3,190 sendable rows out of 5,000, and you can show exactly how each one got there.
How do you read Valid, Risky and Invalid results in Clay?
Each result calls for a different action in the table.
| Result | Typical reason | What to do in Clay |
|---|---|---|
| Valid | Passed the syntax, domain, MX and SMTP mailbox checks | Send, starting with the most engaged subset |
| Risky: catch-all domain | The domain accepts any address, so the mailbox cannot be confirmed | Hold, then include in a small test send later |
| Risky: role-based (info@, sales@) | A shared inbox with no single owner | Exclude from personal sequences; use only if your offer targets shared inboxes |
| Flagged disposable | A temporary address service | Drop from B2B sequences |
| Invalid | Failed a check, such as no MX record or a nonexistent mailbox | Remove from the table and suppress; don't re-run unless the source changes |
| No deliverable address | Every waterfall provider was tried | Research manually or leave the row out |
Catch-all domains need the most care. A catch-all server accepts mail for any address, so a pass tells you the domain is live but not that the person exists. Hold those rows, send a small test batch, and watch the bounces. If bounces appear, suppress the domain. The catch-all email verification page explains how these results are handled.
Compliance goes beyond deliverability. The FTC's CAN-SPAM compliance guide sets out the rules for commercial email in the US, including opt-out and sender identification requirements. Email verification compliance and hygiene is about keeping lists clean, but it does not replace those obligations.
Bottom line: Valid rows go out, Risky rows wait for a test, and Invalid rows are removed.
How do you automate Clay verification with the API?
Use the API when the same table needs refreshing, and write every returned status back into the table itself. API access is included only on Pro, which covers 100,000 emails a month. Free has no API access.
Single-email checks and bulk requests of up to 10,000 emails are both supported. The arithmetic: 100,000 ÷ 10,000 = 10 full batches a month. A 25,000-row table takes three requests (10,000 + 10,000 + 5,000), using 25,000 of your 100,000 API emails.
The usual pattern is to send a batch from the table, write the returned statuses to new columns, and filter on those columns. Keep results in Clay, because Pro keeps results on the platform for only 30 days.
If you want to build this, get an API key and review email verification API and automation for workflow patterns. Confirm that your Clay setup can send HTTP requests before you design the workflow around them.
Bottom line: Automate only the tables you refresh, and store every result in the table.
What does verifying a Clay table cost?
Plan facts drive the cost. Verification costs are separate from any enrichment credits or provider fees you pay inside Clay.
| Factor | Free | Pro |
|---|---|---|
| Price | $0 | $29 a month, or $25 a month billed annually |
| Standard verification | Unlimited | Unlimited |
| Deep verifications per month | 750 | 25,000 |
| Maximum emails per list | 150 | 25,000 |
| Lists per month | 25 (up to 3,750 emails total) | Unlimited |
| API access | None | 100,000 emails a month |
| Results kept | 24 hours | 30 days |
If you use Pro's full deep allowance, the cost per 1,000 deep verifications is about $1.16 on monthly billing ($29 ÷ 25) and $1.00 on annual billing ($25 ÷ 25). If you use less, the effective price rises. In the worked example, $29 spread over 4,300 verifications is about $6.74 per 1,000 for that month. Price your plan against the rows you will actually verify each month, not against the allowance.
For a broader view of how plans are priced across vendors, see email verification pricing.
Bottom line: Choose the plan by monthly volume. At low volume, the effective cost per email is higher than the headline price suggests.
What are the common mistakes when verifying a Clay table?
Most of these mistakes come from row handling and sequencing, not from the verifier's output.
- Verifying after the sequencer. By then the bounces have happened. Verify before the table reaches any sending tool.
- Treating a provider's "verified" label as a mailbox check. Labels show what a provider believes. A mailbox check tests the address.
- Re-verifying rows that already have a current result. This burns deep allowance on addresses you have already resolved.
- Losing row alignment on re-import. A sorted or deduplicated table can shift rows. Compare row counts and spot-check IDs before filtering.
- Mixing labels from two providers in one status column. Filters then return inconsistent results. Map each provider's labels to Valid, Risky and Invalid first.
- Dropping Risky rows silently. They disappear from reporting and then reappear in a later campaign. Keep them in a named list.
- Letting results expire. Free results last 24 hours and Pro results last 30 days. Download them into Clay promptly.
- Sending catch-all rows first. They belong at the end of your ramp, after the Valid segment has proven stable.
- Assuming verification proves consent. A deliverable address is not an opted-in contact.
- Running old tables without re-verifying. Contacts change jobs and domains lapse. Re-verify any table that is months old before a campaign. Email list maintenance best practices sets a schedule.
To keep bad addresses out of the table at capture, add real-time email validation to your forms and signup flows.
Bottom line: Verify before sending, keep row IDs intact, and never let a Risky row disappear unlabeled.
How we compared (and limitations)
This guide is based on public documentation of Clay's workflow and on Unlimited Verifier's published plan facts. We have not run controlled tests of Clay's provider waterfalls or benchmarked individual data providers. Treat the workflow as a method, not a measured result.
The worked example uses hypothetical numbers to show the arithmetic. The percentages are illustrative, not measured from a real table. Unlimited Verifier states 99.5% accuracy for deep verification. That is the company's own figure, not an independent benchmark.
The thresholds in this guide (a 2% bounce ceiling and a 1% target for first sends) are our recommendations. They leave room below the review levels that Amazon SES documents and that other ESPs apply. Clay's features, providers and pricing change over time, so check your workspace before you build.
Bottom line: Use the method, confirm the current Clay features, and verify your own table before you send.
Routing rules for verified rows
| Status | Meaning | Action |
|---|---|---|
| Valid | Passed syntax, domain, MX and SMTP checks | Send to sequencer |
| Risky | Catch-all, role-based or disposable | Hold; test in a small batch first |
| Invalid | Failed a check or mailbox does not exist | Suppress; keep the status on the row |
Frequently asked questions
Can I verify emails inside a Clay table?
Yes. You can add a verification step as a column, either by calling a verification service through an integration or API, or by exporting the table, verifying the addresses and re-importing results. The best method depends on table size and how often the table refreshes.
Where should email verification go in a Clay waterfall?
Verify each candidate address before moving to the next provider in the waterfall. A found address that fails verification should not end the waterfall as if it were a success, so the waterfall should keep searching when a candidate is invalid.
What is the difference between Valid, Risky and Invalid?
Valid addresses passed every check and are likely to accept mail. Invalid addresses failed a check such as syntax, domain or mailbox existence and should be suppressed. Risky addresses, such as catch-all, role-based or disposable ones, may deliver but cannot be confirmed, so they are best held for a separate test.
What checks does email verification run?
Typical checks run in order: syntax validation, domain check, MX record lookup to confirm the domain accepts mail, and an SMTP check that asks the mail server whether the mailbox exists. Each stage filters out addresses that would bounce, and the final status depends on how these results combine.
Does a verified email mean the contact opted in?
No. Verification only shows that a mailbox is likely to accept mail. It does not prove the person agreed to receive your messages, so you still need a lawful basis and an opt-out path under the rules that apply to your outreach.
What is a catch-all email and should I send to it?
A catch-all domain accepts mail for any address, so verification cannot confirm whether a specific mailbox exists. Treat these as Risky, send them only after a small test batch, and watch bounce and complaint rates before expanding.
How do I match verification results back to the right rows?
Use a unique row ID when exporting and re-importing. Export the ID with each email, verify the file, then join the results back on that ID. Matching on the email address alone can break when the same address appears in more than one row.
Why do bounce rates often rise when I add more waterfall providers?
Later providers often return addresses with less supporting evidence, so a larger share of them fail verification. Each extra provider raises coverage but also adds unvalidated addresses unless every candidate is checked.
How often should I re-verify a Clay table?
Re-verify before each campaign and whenever the table refreshes or pulls in new enrichment data. Addresses decay over time as people change jobs, so a list verified months ago should be checked again before it is used.
Should I delete Invalid rows from the table?
Keep them but mark them as suppressed rather than deleting them. Retaining the status prevents the same bad address from being re-enriched and sent again, and it preserves an audit trail of why a row was excluded.
Cut Bounces and Protect Your Sender Reputation With Unlimited Email Verification
Every invalid address you send to hurts your sender reputation and your inbox placement. Verifying your list before each send means fewer bounces, healthier deliverability, and a predictable cost. With Unlimited Verifier, standard verification is unlimited on every plan, with no per-email fees.
Unlimited Verifier checks syntax, domain, MX records and the SMTP mailbox. It also detects catch-all domains and flags disposable and role-based addresses. Export a CSV from your email platform or CRM, upload and verify the list, then re-import the clean results. You can also automate checks with the email verification API.
| Free | Pro | |
|---|---|---|
| Price | $0 | $29/month ($25/month billed annually) |
| Lists | 25 a month, up to 150 emails each | Unlimited, up to 25,000 emails each |
| Deep verifications | 750 a month | 25,000 a month |
| API access | No | Yes (100,000 emails a month) |
| Result retention | 24 hours | 30 days |
Why teams choose Unlimited Verifier
- Unlimited standard verification on all plans, including Free, with no per-email fees.
- Catch-all detection so you know which domains accept every address.
- Clear Valid / Risky / Invalid results, exportable as CSV, Excel or JSON.
- An open-source verification engine you can inspect on GitHub.
Unlimited Verifier states 99.5% accuracy for deep verification.
Create a free account and verify your next list before you hit send.
Want to test a single address first? Try the free email checker.