Verify emails in Clay

Setup

1. Create an API key at simpleverifier.com/api-keys. It starts with sv_live_. API access comes with selected paid plans; a key on a plan without it gets a 402 that says so.
2. In your Clay table, click Add column, search for HTTP API and choose it.
3. Set the method to GET and the endpoint to https://simpleverifier.com/api/v1/verify?email=/Email, inserting your email column where /Email appears.
4. Add a header named Authorization with the value Bearer followed by your key. Clay stores it as an account credential, so it is not repeated per column.
5. Run the column on a few rows first. Each call can take up to about 30 seconds on a slow mail server, so keep auto-run off until you have checked the output.
6. Add action from the result as its own column, then a formula or run condition {{SV action}} == "send" so only confirmed mailboxes reach your sequencer. Keep reason and reason_code beside each row for the why.

The HTTP API column, field by field

In Clay, click Add enrichment, choose HTTP API and open the Configure tab. Clay references a column with a forward slash, so /Email inserts each row’s value; rename it to match your column.

Click Test on one row first, then ten, then the table. The same request from a terminal:

curl "https://simpleverifier.com/api/v1/[email protected]" \
  -H "Authorization: Bearer $SIMPLEVERIFIER_KEY"

What comes back

Every answered check carries four decision fields with a fixed shape and no null: action, risk, likely_invented and reason_code. They are never more hopeful than status: only valid gives action: "send", and a catch-all address is always risky, never valid. A confirmed mailbox:

{
  "email": "[email protected]",
  "status": "valid",
  "reason": "Mailbox exists",
  "send_advice": "safe",
  "reason_detail": "The mail server confirmed this mailbox exists.",
  "mailbox_probed": true,
  "action": "send",
  "risk": "low",
  "likely_invented": false,
  "reason_code": "mailbox_exists"
}

A catch-all domain, where no SMTP check can confirm the mailbox:

{
  "email": "[email protected]",
  "status": "risky",
  "reason": "Accepts all addresses",
  "send_advice": "care",
  "catch_all_confidence": "higher",
  "mailbox_probed": true,
  "action": "send_with_care",
  "risk": "medium",
  "likely_invented": false,
  "reason_code": "catch_all"
}

An address that looks made up, on a domain with no mail server (handy for catching AI-written or guessed emails in a waterfall):

{
  "email": "[email protected]",
  "status": "invalid",
  "reason": "No mail server",
  "send_advice": "do_not_send",
  "mailbox_probed": false,
  "action": "do_not_send",
  "risk": "high",
  "likely_invented": true,
  "reason_code": "no_mx"
}

The full field list and every reason_code are in the API docs. Codes are stable; treat a code you do not recognise like other and go by action.

Keep only the rows to send

In the HTTP API column’s output, add action as its own column (call it SV action). Then add a formula column, or a run condition on your push-to-sequencer column, with this JavaScript expression (Clay evaluates run conditions as expressions that return true or false):

{{SV action}} == "send"

If you would rather read straight from the HTTP API column (named Verify email here), use {{Verify email}}.action == "send". Filter the table view on that formula column to see only sendable rows. Test the expression on a few rows: Clay’s formula editor can also write it for you from “only run if SV action is send”.

Rate limits and speed

Each API key can make 120 calls a minute. Past that the API answers 429 with a Retry-After header. Setting Clay to 100 requests per 60,000 ms leaves headroom; give each table or tool its own key if several share one. At that rate 1,000 rows take at least 10 minutes, and longer when mail servers are slow: one check can take up to about 30 seconds. For tens of thousands of rows, export a CSV and upload it on the verify page; list jobs average about 30 rows a minute over a day, shared by all customers. Confirmed results are cached for 14 days, so re-running a recent table is quick.

Which plans include API access

On yearly billing the included calls are a fixed monthly quota. A key on a plan without API access gets a 402 that says so. Details on pricing. The longer walkthrough, with routing for risky rows and phone checks, is in how to verify emails in Clay.

Using the result

Route on the status field: valid means the mail server confirmed the mailbox, risky means delivery could not be confirmed (catch-all domain, role address, provider that hides mailbox status), invalid means it will bounce or is a throwaway address. Keep risky out of cold sequences unless you accept the bounce risk.

Full endpoint reference, error codes and an OpenAPI file are in the API docs. For lists of thousands of addresses, upload a CSV on the verify page instead.

Comparing tools? See email verifiers for Clay compared, with prices checked on each vendor’s site.

Common questions

Which plans include API access for Clay?

API access comes with Pro, Business and Agency, listed on the pricing page; Starter covers CSV verification only. A key on a plan without API access gets a 402 that says so. Each key can make 120 calls a minute.

Is there a native SimpleVerifier provider in Clay?

Not yet. Today you connect it with Clay's HTTP API column, which works with any REST API and a Bearer key.

What does it cost per row in Clay?

The HTTP API column calls our API with your own key, so each row uses one API call from your SimpleVerifier plan (included calls, then the per-1,000 rate on monthly billing). Check Clay's current pricing for what it charges, if anything, to run an HTTP API column on your Clay plan.

Are catch-all emails returned as valid?

No. A catch-all address is always status risky with action send_with_care, never valid, because the server accepts every address and an SMTP check cannot confirm the mailbox.

How fast can I call it?

Up to 120 calls a minute per API key. Set Clay's rate limit below it; on a 429 the Retry-After header says how long to wait.