Use case · Lead validation
Lead form email validation: check every lead before it reaches sales.
Lead validation for web forms means checking each submitted email address the moment the form is sent, so mistyped, fake and throwaway addresses are caught before they land in your CRM. Your server sends the address to the EasyMailVerify API, reads the result and flags, and then accepts the lead, asks for a correction, or routes it for review.
By Steve Smith, EasyMailVerify team
Last updated · Editorial standards
No monthly subscription · Credits never expire · Unknown results use no credits
What goes wrong without lead validation
- A real prospect mistypes their domain (gmial.com, outlok.com) and never receives the demo confirmation
- Throwaway inboxes are used to download gated content, then disappear
- Made-up addresses such as test@test.com fill the CRM and skew lead counts and cost-per-lead
- Sales spends time on contacts that bounce on the first follow-up
- Invalid addresses synced into your email platform raise bounce rates on the next campaign
How lead form validation works
The check runs on your server when the form is submitted, not in the visitor's browser, so your API key stays private. Your backend sends POST /api/v1/verify with the email address and an optional label such as "Demo request form". Most checks come back within seconds with a status (passed, failed or unknown), a result_code, a plain-language reason, a suggested_email when a typo is likely, and flags such as disposable and role_account.
If a mail server is slow to answer, the API returns 202 with an ID instead of making the visitor wait. Accept the lead, then fetch the result with GET /api/v1/verify/{id} and update the lead in your CRM when it arrives.
Example only: per-form rules you set yourself (JavaScript, server-side)
// Example settings for one form. These are choices, not recommendations:
// pick values that fit the form and your own lead policy.
const RULES = {
failed: "ask_to_correct", // or "accept_and_flag"
unknown: "accept_unconfirmed", // or "ask_to_confirm", "send_to_review"
disposable: "ask_for_other", // or "block", "accept_and_flag"
roleAccount: "accept", // or "accept_and_score_lower"
freeProvider: "accept", // or "ask_for_work_email"
};
const res = await fetch("https://easymailverify.com/api/v1/verify", {
method: "POST",
headers: {
Authorization: `Bearer ${process.env.EMV_API_KEY}`,
"Content-Type": "application/json",
"Idempotency-Key": submissionId, // a retry won't be charged twice
},
body: JSON.stringify({ email, label: "Demo request form" }),
});
const r = await res.json();
if (res.status === 202) return acceptLead({ emailStatus: "pending", checkId: r.id });
if (r.status === "failed") return apply(RULES.failed, r);
if (r.disposable) return apply(RULES.disposable, r);
if (r.status === "unknown") return apply(RULES.unknown, r);
if (r.role_account) return apply(RULES.roleAccount, r);
if (r.free_provider) return apply(RULES.freeProvider, r);
return acceptLead({ emailStatus: "passed" });
// apply() is your own code: show a prompt, accept, flag or route the lead.Options for each result
There's no single right policy. A gated whitepaper, a demo request and a webinar sign-up can reasonably treat the same result differently, so choose per form. The table lists common options, not recommendations; whichever you choose, tell the visitor what to fix rather than rejecting silently.
| Result or flag | What it means | Options on the form | Options in your CRM |
|---|---|---|---|
| Passed | The mail server confirmed the mailbox exists | Accept | Route to sales or nurture as normal |
| Failed with suggested_email | Likely typo in the domain, e.g. gmial.com | Show "Did you mean …?" and let the visitor confirm, or accept as typed | Store the confirmed address; flag it if left uncorrected |
| Failed, no suggestion | Mailbox or domain doesn't exist, or the address is malformed | Ask the visitor to check the address, or accept and flag it | Hold the lead for review, or create it marked undeliverable |
| Unknown (often catch_all) | The server accepts every address, or didn't answer clearly; many real company addresses land here | Accept, ask the visitor to double-check, or send to manual review | Mark unconfirmed; confirm later with a reply or double opt-in if you need to |
| disposable | A throwaway inbox service | Ask for another address, block it, or accept and flag it | Exclude from sales follow-up, or keep with a low score |
| role_account | A shared inbox such as info@ or sales@ | Accept, or ask for a named contact | Treat as normal, or score lower |
| free_provider | Gmail, Outlook, Yahoo and similar; many real buyers use them | Accept, or ask for a work email where that matters to you | Treat as normal, or use as one scoring signal |
Where to call the API from
- Your own backend: the form handler calls the API before saving the lead
- Form builders and workflow tools that can send an HTTPS request (webhooks), passing the result into your CRM
- A CRM workflow that checks new contacts as they are created
- Never from browser or mobile app code, where the API key could be copied
What lead validation costs
Each Passed or Failed check uses one credit; Unknown results use none. Credits are one-time packages that never expire, shared between the API and the dashboard. Check on submit rather than on every keystroke, and send an Idempotency-Key so a retried request returns the original result instead of being charged again.
Leads already in your CRM
Real-time checks only cover new submissions. For leads collected before you added validation, export them as CSV and run bulk email verification, then import the results back matched on your contact IDs. CRM email cleaning covers the routine for keeping a CRM clean.
Limits to keep in mind
- A Passed address can receive mail; it doesn't prove the lead is real, interested or the person they claim to be
- Bots can submit real addresses, so keep CAPTCHA, honeypot fields or rate limiting
- Catch-all company domains never confirm individual mailboxes, so many B2B leads come back Unknown
- A result reflects the moment of the check; people leave jobs and mailboxes close later
- Verification isn't consent: only add leads to marketing lists if they agreed to it
Step by step
- 1
Create an API key
Open the API page in your dashboard and create a key for the server that handles your form.
- 2
Verify on submit
Send POST /api/v1/verify with the address and a label naming the form.
- 3
Prompt for corrections
For Failed results, show the suggested address or the reason and let the visitor fix it.
- 4
Apply your rules for this form
Route each lead using the options you chose for Unknown, disposable, role and free-provider results.
- 5
Handle slow checks
If the API returns 202, accept the lead and update it when GET /api/v1/verify/{id} returns the result.
Frequently asked questions
What is lead validation?
Checking that the contact details on a lead are real and usable before anyone follows up. For email, that means confirming the address is correctly formatted, on a working domain, and accepted by its mail server.
Will validation block real people?
That depends on the rules you set. Prompting for corrections instead of rejecting silently helps. Blocking Unknown results is the setting most likely to turn away real people, because many company domains are catch-all and never confirm individual mailboxes.
Does it slow down the form?
Most checks return within seconds. When a mail server is slow, the API returns 202 with an ID so you can accept the lead and pick up the result afterwards.
Should I block free email addresses like Gmail?
It's your call per form. Many real buyers use free addresses, especially at small companies, so blocking them has a cost. Some teams use free_provider as one scoring signal or ask for a work email only on specific forms.
Does the person get an email when their address is checked?
No. The check asks the receiving mail server about the mailbox without sending a message.
Related
Ready to check your list?
Pay only for Passed and Failed results. Credits never expire.
Create account