Email and phone validation API: check contacts before you send
Why you validate emails and phone numbers before outreach, what a validation check returns, and where to put it in your pipeline.
Dag Holmen · Updated · 4 min read
An email verification API checks whether an address is likely to accept mail before you send to it. A phone validation API does the same job for numbers: is it real, and is it formatted so your dialer or SMS tool can use it. Both are cheap insurance. Every bounce you avoid protects the domain you send from.
This guide explains what a verification check does, what B2Benrich's validation endpoints take and return, and where to put the check in your pipeline so stale contacts never reach a sequence.
What email verification checks
Verification tests an address without sending it an email. A typical check runs in layers:
- Syntax. Is it a valid address format?
- Domain and mail server. Does the domain exist, and does it publish MX records that say where its mail goes?
- Mailbox. The verifier opens an SMTP conversation with that mail server, asks whether it would accept mail for the address, and disconnects before anything is sent.
- Catch-all detection. It also asks about an address that can't exist. If the server says yes to that one too, the domain accepts everything, and the real mailbox can't be confirmed from outside.
- Risk flags. Role addresses like info@ or sales@, disposable domains and free webmail.
People use "validation" and "verification" loosely. Strictly, validation often means the format check and verification means the live mailbox check. In practice, an email validation API and an email verification API usually do both.
Validate an email with B2Benrich
B2Benrich has two validation endpoints: POST /v1/validate/email and POST /v1/validate/phone. Send the address in the request body with your API key in the X-Api-Key header.
curl --request POST \
--url https://api.b2benrich.com/v1/validate/email \
--header 'Content-Type: application/json' \
--header 'X-Api-Key: YOUR_API_KEY' \
--data '{ "email": "maya.chen@acme.com" }'
The response includes a status for the address:
{
"status": "valid",
"email": "maya.chen@acme.com"
}
Build your logic on status, and check the API docs for the current status values before you hard-code them.
Validate a phone number
Phone validation works the same way. Send the number in international E.164 format (a plus sign, country code and number, no spaces), which avoids most country-code mix-ups:
curl --request POST \
--url https://api.b2benrich.com/v1/validate/phone \
--header 'Content-Type: application/json' \
--header 'X-Api-Key: YOUR_API_KEY' \
--data '{ "phone": "+15555550123" }'
Use the returned status to decide whether a number goes to your dialer or SMS tool. Normalize every number to E.164 before you store it, so duplicates with different formatting don't slip through.
Sort every result into three buckets
Whatever the exact status values, map them to three actions:
| Bucket | What it means | What to do |
|---|---|---|
| Send | The mailbox looks real | Add to sequences |
| Suppress | Invalid, or the domain doesn't take mail | Remove it, and mark it in your CRM so it isn't imported again |
| Hold | Catch-all, unknown or risky | Keep in its own segment, send in small batches, or reach the person another way |
Don't treat "unknown" as invalid. Some servers refuse verification checks or time out, and many of those addresses work. Don't treat it as valid either.
Where verification goes in your pipeline
- Right after the email finder. A found email is a candidate. Verify it before it goes into a sequence. The email finder API guide covers finding the address from a name and domain.
- Right before a large send. Verification is a snapshot. An address that passed last quarter can bounce today if the person left. Re-check lists that have been sitting.
- On sign-up forms. Check new sign-ups server side, so disposable and mistyped addresses don't end up in your CRM.
- During CRM cleanup. Verify emails when you re-enrich contacts, and suppress the ones that fail. CRM data enrichment covers how to write those flags back safely.
Find and verify in one pass
This Node script finds an email for each contact, verifies what it finds, and tags each row with a bucket:
const BASE = 'https://api.b2benrich.com';
const headers = { 'Content-Type': 'application/json', 'X-Api-Key': process.env.B2BENRICH_KEY };
const post = (path, body) =>
fetch(BASE + path, { method: 'POST', headers, body: JSON.stringify(body) }).then((r) => (r.ok ? r.json() : null));
const SEND = new Set(['valid']); // adjust to the documented status values
const SUPPRESS = new Set(['invalid']);
async function findAndVerify(contacts) {
const out = [];
for (const c of contacts) {
const found = await post('/v1/enrich/person/name-domain-to-email', {
first_name: c.first_name, last_name: c.last_name, domain: c.domain
});
if (!found?.email) { out.push({ ...c, email: '', bucket: 'not_found' }); continue; }
const check = await post('/v1/validate/email', { email: found.email });
const status = check?.status ?? 'unknown';
const bucket = SEND.has(status) ? 'send' : SUPPRESS.has(status) ? 'suppress' : 'hold';
out.push({ ...c, email: found.email, status, bucket, checked_at: new Date().toISOString() });
}
return out;
}
If you start from LinkedIn URLs instead of names, enrich them with the people enrichment API first to get the first name, last name and company domain. B2Benrich's plan is unlimited API usage for $500 a month, no credits, so checking a whole list again before each send doesn't add cost.
Hard bounces and soft bounces
Verification lowers your bounce rate. It doesn't take it to zero, so you still need to handle bounces when they come back. Mail servers answer with SMTP reply codes defined in RFC 5321. A reply starting with 5 is a permanent failure, like a mailbox that doesn't exist: remove that address everywhere, the same day. A reply starting with 4 is temporary, like a full mailbox or a busy server: let your sending tool retry, and treat repeated soft bounces from the same address as a hard bounce.
Feed bounces back into your CRM as suppressions, so the next list you build doesn't bring them back.
Frequently asked questions
- What is an email verification API?
- An API that checks whether an email address is likely to accept mail, without sending a message. It typically checks the format, the domain’s mail servers and the mailbox itself, and flags catch-all domains, role addresses and disposable domains.
- What’s the difference between email validation and email verification?
- Validation often means checking the format of an address. Verification means checking with the mail server that the mailbox can receive mail. Most tools sold under either name do both in one call.
- What is a catch-all email address?
- An address on a domain that accepts mail for any address, real or not. Because the server says yes to everything, a verifier can’t confirm whether a specific mailbox exists. Keep catch-all addresses in their own segment and send to them in small batches.
- Can a verified email still bounce?
- Yes. Verification is a snapshot. People leave companies and mailboxes get closed, so an address that passed months ago can bounce today. Verify close to the send, and remove hard bounces from every list as soon as they happen.
- Should I validate phone numbers too?
- If you call or text, yes. Normalize numbers to international E.164 format, validate them before they go to your dialer or SMS tool, and drop the ones that fail so reps don’t waste time on dead numbers.
Sources
Related guides
- Email finder API: find a work email from a name and domainHow to find work emails programmatically from a first name, last name and company domain, and how to run it across a whole list.
- People enrichment API: from a LinkedIn URL to a full profileHow a people enrichment API works, which fields come back, and how to enrich contacts from a LinkedIn URL, a name and domain or an ID.
- CRM data enrichment: keep HubSpot and Salesforce records completeHow to fill missing fields and fix stale records in HubSpot or Salesforce with an enrichment API, on new leads and on your whole database.