Single verification endpoint: real-time email verification

Last updated May 19, 2026API

The single-verification endpoint is the right choice for synchronous flows — signup forms, lead capture, anywhere you need a verdict on one address in the same request cycle. Typical response time is 1–3 seconds.

Endpoint details

PropertyValue
URLhttps://app.validemailchecker.com/api/verify-single
MethodPOST
Content-Typeapplication/json
AuthenticationBearer token (API key)
Credits1 per call (unknown is auto-refunded)

Request format

Headers

Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

Body

json
{
  "email": "user@example.com"
}
FieldTypeRequiredDescription
emailstringYesThe address to verify

cURL example

bash
curl -X POST https://app.validemailchecker.com/api/verify-single \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"email": "user@example.com"}'
API documentation page showing a single verification example with the request body and Postman-style preview
The single-verify call shape: POST + Bearer + JSON body.

Successful response (200)

json
{
  "email": "support@validemailchecker.com",
  "status": "role_account",
  "is_valid": true,
  "is_disposable": false,
  "is_role_account": true,
  "is_catch_all": false,
  "is_free_email": false,
  "mx_found": true,
  "domain": "validemailchecker.com",
  "risk_score": 7,
  "deliverability": "high",
  "credits_used": 1,
  "verified_at": "2026-05-19T20:35:27.124Z",
  "reason": "Role account detected"
}
Postman client showing a real 200 OK response with the JSON verification result for a role account address
A real response in Postman — every field above, every time.

Response fields

Core

FieldTypeDescription
emailstringThe address that was verified
statusstringVerification result (see status values below)
is_validbooleantrue if deliverable
reasonstringHuman-readable explanation

Email characteristics

FieldTypeDescription
is_disposablebooleanThrowaway/temporary email
is_role_accountbooleanTeam email (info@, support@, admin@)
is_catch_allbooleanDomain accepts all addresses
is_free_emailbooleanFree provider (Gmail, Yahoo, Outlook)
mx_foundbooleanValid MX records exist on the domain
domainstringDomain portion of the email

Risk assessment

FieldTypeDescription
risk_scoreinteger0–100 (lower = safer)
deliverabilitystringhigh, medium, low, or unknown

Metadata

FieldTypeDescription
credits_usedintegerCredits consumed (usually 1)
verified_atstringISO 8601 timestamp of the check

Status values

Safe

StatusDescriptionAction
safeValid, deliverable mailboxSend

Risky / conditional

StatusDescriptionAction
riskyDeliverable but flagged (uncommon)Send with care
catch_allServer accepts everything; can't confirm mailboxTest small batch first
role_accountTeam address (info@, support@)Send, segment separately
inbox_fullMailbox at capacityRetry later
unknownCouldn't complete verificationRetry later (auto-refunded)

Invalid

StatusDescriptionAction
invalidMailbox does not existDrop
disposableThrowaway/temporary emailDrop
disabledAccount was deactivatedDrop
spamtrapHoneypot — sending will hurt your reputationNever send

See result types explained for the long-form breakdown of each status and what to do with it.

Error responses

See rate limits and error handling for the full error matrix. Quick reference:

HTTPWhen it happens
400Missing email field in the request body
401Missing/invalid Authorization header, or invalid API key
402Insufficient credits
403API key suspended, or IP blocked
429Rate limit exceeded (per-minute or per-day)
500Internal server error

Use case: registration-form validation

javascript
app.post('/register', async (req, res) => {
  const { email, password } = req.body;

  const response = await fetch(
    'https://app.validemailchecker.com/api/verify-single',
    {
      method: 'POST',
      headers: {
        'Authorization': `Bearer ${process.env.VEC_API_KEY}`,
        'Content-Type': 'application/json',
      },
      body: JSON.stringify({ email }),
    }
  );

  const result = await response.json();

  if (!result.is_valid) {
    return res.status(400).json({ error: 'Please use a valid email address.' });
  }

  if (result.is_disposable) {
    return res.status(400).json({ error: 'Temporary email addresses are not allowed.' });
  }

  await createUser(email, password);
  res.json({ success: true });
});

Use case: lead qualification

javascript
async function qualifyLead(email) {
  const result = await verifyEmail(email);

  return {
    email,
    isValid: result.is_valid,
    quality: result.deliverability,
    risk: result.risk_score,
    isBusinessEmail: !result.is_free_email,
    recommendation: recommend(result),
  };
}

function recommend(r) {
  if (r.status === 'safe' && !r.is_free_email) return 'HIGH_PRIORITY';
  if (r.status === 'safe')                     return 'NORMAL';
  if (r.is_valid)                              return 'LOW_PRIORITY';
  return 'SKIP';
}

Common questions

How fast is the verification?

Most calls finish in 1–3 seconds. Complex domains or those with aggressive anti-spam measures can take longer. The connection holds open until the answer is back.

What if I get `unknown`?

The mail server didn't respond, timed out, or rate-limited the check. The credit is auto-refunded. Retry later, or treat as risky if the contact is valuable.

Are credits refunded for any non-safe result?

No. A successful verification consumes a credit regardless of the verdict — invalid is still an answer. Only unknown is refunded, because we genuinely couldn't produce an answer.

Is there a sandbox or test mode?

No dedicated sandbox right now. The recommended pattern is to verify a small set of known-good addresses (your own email, a teammate's) during integration testing before going to production.

Next steps