MillionVerifier Clay integration: step by step
Connect MillionVerifier to Clay with the native action or an HTTP API column, then send only to addresses that come back ok, holding out catch-all and unknown.
The MillionVerifier Clay integration works two ways. Clay lists a native action, Validate Emails with MillionVerifier, that uses your own MillionVerifier account. You can also call the MillionVerifier single API from an HTTP API column, which shows the full response and lets you pick the fields to keep. Either way, every row gets a status you can filter on.
This guide compares the two routes, then covers the HTTP API column in detail: the request, a one-row test, what each result means for a cold list, and the filter that decides who gets emailed. It assumes your leads already sit in a Clay table with one email address per row.
Does Clay have a native MillionVerifier integration?
Yes. Clay lists a Validate Emails with MillionVerifier action on its MillionVerifier integration page, and it needs your own MillionVerifier account. MillionVerifier’s Clay setup guide has you find it in the table’s Tools menu, paste your key and map the email column.
Clay also has built-in verification, which runs through third-party providers with ZeroBounce as the default. Its email refresh page cites a 2025 benchmark of non-catch-all verifiers that names ZeroBounce and does not mention MillionVerifier. So calling MillionVerifier from Clay is a choice, not a necessity. The practical reasons to make it are that you already hold MillionVerifier credits, which its homepage says “never expire”, or that you want one verifier across every tool you use.
Native action or HTTP API column?
Both routes call the same verifier. They differ in setup and in how much of the response you handle.
| Native action | HTTP API column | |
|---|---|---|
| Where you add it | The table’s Tools menu, Validate Emails with MillionVerifier | A new enrichment, HTTP API |
| Where the key goes | The action’s api field | The api query parameter |
| Default timeout | 10 seconds, per MillionVerifier’s Clay guide | 20 seconds, per the API reference |
| What you configure | The key, the email column and an optional timeout | Method, URL, parameters, field paths and rate limit |
The HTTP API column takes more setup. In return:
- You see the whole response, including
quality,subresult,roleanddidyoumean, and choose which fields to keep. - You set a rate limit in the column settings, which Clay documents for HTTP API columns.
- The same request works outside Clay, in any tool that can send a GET request.
We do not publish an accuracy benchmark of our own, and nothing here claims one route or one verifier beats another. A similar setup works with any verifier that exposes a GET endpoint, with that vendor’s parameters and field names.
What do you need before you start?
You need five things in place before building the column: an account, a key, a table, a destination and the right Clay plan.
- A MillionVerifier account. New accounts get 100 free credits with no card required, according to MillionVerifier’s homepage. That is plenty for testing.
- Your API key, copied from your MillionVerifier account.
- A Clay table with email addresses in their own column, one address per row.
- A sending tool to receive the filtered list once verification is done.
- A Clay plan that includes HTTP API integrations. Clay’s pricing page lists them on Growth and Enterprise, not on Free or Launch.
If you do not have the list yet, our guide to choosing a cold email scraper covers sourcing it. For a full build from one source, see the Google Maps lead generation workflow.
How do you set up the MillionVerifier Clay integration?
For the HTTP API route, you build one enrichment column with five settings: method, URL, query parameters, a field path and a rate limit. The steps follow Clay’s HTTP API documentation and MillionVerifier’s API reference.
Step 1: add the HTTP API enrichment
Open the table that holds your leads and add an enrichment. Choose HTTP API rather than a named provider.
Step 2: set the method and the URL
Set the method to GET, because you are retrieving a verdict, not storing anything. Paste the endpoint without a query string:
https://api.millionverifier.com/api/v3/
Enter the base URL here and the parameters in the next step. Pasting a full example URL from the docs is how a placeholder address ends up in every request.
Step 3: add the query parameters
MillionVerifier’s single API takes two required parameters and one optional one. Enter each as a key and value pair in Clay’s query parameters section.
| Key | Value in Clay | Required | What it does |
|---|---|---|---|
api | Your MillionVerifier API key | Yes | Identifies your account |
email | /Email, a reference to your email column | Yes | The address to verify, one per row |
timeout | A whole number of seconds | No | How long MillionVerifier waits for the recipient’s mail server |
The slash in the email value is how Clay references a column. Clay’s docs show the same pattern with /Email Column. Type the slash and pick your column from the list, so each row sends its own address.
Leave timeout out at first. MillionVerifier’s API reference says you can set it between 2 and 60 seconds and that the default is 20 seconds.
Step 4: return only the result field
Set Field paths to return to result. Clay describes this setting as choosing which parts of the response to keep, so the column holds the status itself instead of a JSON object you would need to unpack.
The full response carries more than the verdict. MillionVerifier’s reference lists fields such as quality, subresult, free, role and didyoumean. Leave the field path empty on your test row once to see them all, then decide which ones you want to keep.
Step 5: set a rate limit
Clay lets you cap how many requests the column sends per time window. MillionVerifier’s API help article sets the single API rate limit at 160 requests per second per account. Even so, start with a conservative cap on a large table and raise it only once rows come back clean.
How do you test the column before running the whole table?
Run the column on a single row first, as Clay’s documentation recommends, and read the response before touching the rest. One row shows whether the URL, the key and the column mapping all work. A full run against a broken setup spends credits to teach you the same thing.
MillionVerifier also publishes demo keys in its API reference. It says API_KEY_FOR_TEST returns “a random response”, which lets you check the column wiring before your real key goes in.
Once the single row passes, we run a small batch before the full table. That is our own habit, not a Clay rule. One good row can hide a column that is empty or malformed further down.
What do the common failures mean?
Most failures come from the setup, not from MillionVerifier:
- Every row returns the same result. The email value is a typed address, not a column reference. Clear it, type a slash and pick the column.
- Access or authentication errors. The key is wrong, has a stray space, or was regenerated after you pasted it.
- Only addresses with symbols fail. MillionVerifier’s reference says special characters in the email address “should be encoded”. Check those rows by hand.
- A wave of unknown results. Often the recipient servers did not answer in time. Raise
timeoutor re-run those rows later. - 429 errors. Clay’s error reference lists 429 as too many requests. Lower the rate limit and re-run the failed rows.
What do the MillionVerifier results mean for a cold email list?
MillionVerifier’s results guide defines five results, and only ok is safe to cold email by default. The definitions below are quoted from that guide. The third column is our own recommendation for cold email.
| Result | MillionVerifier’s definition | What we recommend for cold email |
|---|---|---|
| Ok | ”the email address exists” | Send |
| Catch-all | ”the email server is set to accept all mail, even emails sent to an account that does not exist” | Hold out of the first send |
| Unknown | ”we couldn’t determine whether the email address exists at the time of the verification” | Re-verify later, then decide |
| Invalid | ”the email address does not exist” | Remove |
| Disposable | ”this email account is hosted on a temporary email address provider” | Remove |
The API reference does not list its result strings, and its demo keys include unverified and error cases. Treat anything other than ok as not send-ready.
Read the exact strings on your test row before you build a filter. The API sample in MillionVerifier’s reference returns values in lowercase, and the filter has to match what the column actually holds.
MillionVerifier’s good, bad and risky guide groups catch-all and unknown as risky. It allows risky addresses only for genuine, recent subscribers, and rules out purchased lists and lists collected from the internet. That describes most cold lists, so we recommend excluding risky addresses from cold sends.
The same guide says “never use bad emails”, meaning invalid and disposable. It also suggests filtering out role-based addresses. Clay’s verification statuses page describes those as “tied to a job function”, such as a shared sales or info inbox rather than the person you wrote to.
How do you filter the Clay table to send-ready emails?
Filter the result column to ok only, save that filter as its own view, and send exclusively from that view. Every other row stays in the table for reference but never reaches a campaign.
- Filter the result column to ok, matching the exact string your test row returned.
- Exclude role addresses if you kept the
rolefield from the response. - Save the view with a plain name such as “Send-ready”, so nobody exports the unfiltered table by mistake.
- Push only that view into your sequencer. Our guide to connecting Clay to Instantly covers that step.
A verified list does not stay verified. Clay’s statuses page notes that statuses can change and recommends re-verifying regularly. If a list has sat unsent since its last check, run the column again right before upload.
How we run this for clients
Cold Agency runs client lists in this order: source the leads, filter them on the client’s ICP, verify the emails, enrich, then upload to the sending tool. Verification comes before enrichment and upload, so no address reaches the sequencer unverified.
Across 7 client campaigns (several clients), all time to 21 Oct 2026, our sending dashboard shows a recipient bounce rate of 1%. Bounces depend on more than one tool, so we read that figure as the result of the whole pipeline, not of verification alone.
Verification protects the sending domains. The work that pays comes after it. We read every reply and forward each qualified lead to the client, who books its own meetings. A qualified lead is a positive reply from a contact who matches the client’s agreed ideal customer profile (ICP), expressing interest.
What should you check before you send?
Run through this list once the column has finished and before any address leaves Clay:
- The
emailparameter references your email column, not a typed address. - A single test row returned a clean result string, and you copied that exact string into the filter.
- The
resultfield path is set, so the column holds a status, not raw JSON. - The send-ready view shows ok only, with role addresses excluded if you track them.
- Catch-all and unknown rows sit outside the view, flagged for a separate decision.
- The list was verified recently enough that nothing has sat unsent since the check.
Verification is one stage in a longer pipeline, and it is the cheapest one to get right. If you would rather hand the whole pipeline over, from the sending infrastructure to forwarding qualified leads, that is what our done-for-you cold email service runs for you.
Frequently asked questions
Can you connect MillionVerifier to Clay without Zapier?
Yes, two ways. Clay lists a native Validate Emails with MillionVerifier action that uses your own MillionVerifier account, and Clay's HTTP API enrichment can call the MillionVerifier single API from a column. Neither route needs middleware. You need your MillionVerifier API key and an email column to reference, and Clay lists both routes on its Growth plan and above.
Should you send cold emails to catch-all addresses?
Not by default. A catch-all server accepts mail for any address on the domain, so MillionVerifier cannot confirm the person exists. MillionVerifier treats catch-all as risky and allows risky addresses only for genuine recent subscribers, which a scraped cold list is not. Our recommendation is to hold catch-all addresses out of the first send and decide on them separately.
Why does every row in my Clay column return the same MillionVerifier result?
The email parameter holds a typed address instead of a column reference. Clay then sends that one address on every row and gets the same verdict back each time. Open the column settings, clear the email value, type a slash and pick your email column from the list. Re-test on a single row before running the table.
Is MillionVerifier more accurate than Clay's built-in email verification?
We publish no accuracy benchmark and make no claim either way. Clay's own 2025 verifier benchmark, as summarized on its email refresh page, names ZeroBounce and does not mention MillionVerifier. The fair test is your own data: run both on the same sample, look at where they disagree, and send only to addresses both mark as valid. Then compare bounce rates over time.
How often should you re-verify an email list in Clay?
Re-verify any list that has sat unsent since its last check, right before you upload it to a campaign. Clay's documentation notes that verification statuses can change over time as domains update their settings or addresses become inactive, and recommends verifying lists regularly. Running the check again costs credits, but sending to addresses that went bad costs deliverability.