Single Verification Endpoint

The single verification endpoint lets you verify one email address at a time in real-time. Perfect for registration forms, lead capture, and instant validation.

Endpoint Details

Property	Value
URL	`https://app.validemailchecker.com/api/verify-single`
Method	`POST`
Content-Type	`application/json`
Authentication	Bearer token (API key)
Credits	1 credit per verification

Request Format

Headers

Authorization: Bearer YOUR_API_KEY
Content-Type: application/json

Body

{
  "email": "user@example.com"
}

Field	Type	Required	Description
`email`	string	Yes	The email address to verify

Basic Example

cURL

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 showing single verification example

Response Format

Successful Response (200 OK)

{
    "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-01-03T20:35:27.124Z",
    "reason": "Role account detected"
}

info

This is a real response from our API! The screenshot below shows the actual Postman test.

Postman showing real API response

Response Fields Explained

Let's break down each field in the response:

Core Fields

Field	Type	Description
`email`	string	The email address that was verified
`status`	string	The verification result status (see Status Values)
`is_valid`	boolean	`true` if the email is deliverable
`reason`	string	Human-readable explanation of the result

Email Characteristics

Field	Type	Description
`is_disposable`	boolean	`true` if it's a temporary/throwaway email
`is_role_account`	boolean	`true` if it's a role-based address (info@, support@, admin@)
`is_catch_all`	boolean	`true` if the domain accepts all emails
`is_free_email`	boolean	`true` if from a free provider (Gmail, Yahoo, Outlook, etc.)
`mx_found`	boolean	`true` if valid MX records exist
`domain`	string	The domain portion of the email

Risk Assessment

Field	Type	Description
`risk_score`	integer	Risk score from 0-100 (lower = safer)
`deliverability`	string	Overall rating: `high`, `medium`, `low`, or `unknown`

Metadata

Field	Type	Description
`credits_used`	integer	Credits consumed (usually 1)
`verified_at`	string	ISO 8601 timestamp of when verification occurred

Status Values

The status field indicates the verification result:

✅ Safe Statuses

Status	Description	Action
`safe`	Valid, deliverable email address	Send emails confidently

⚠️ Risky Statuses

Status	Description	Action
`risky`	Deliverable but has risk factors	Use with caution
`catch_all`	Domain accepts all emails (can't confirm mailbox exists)	May bounce
`role_account`	Generic address like info@, admin@, support@	Usually valid but not personal
`unknown`	Verification couldn't complete	Retry later

❌ Invalid Statuses

Status	Description	Action
`invalid`	Email address doesn't exist	Do not send
`disposable`	Temporary/throwaway email	Do not send
`spamtrap`	Known spam trap address	Do not send - dangerous!

warning

Never send emails to invalid, disposable, or spamtrap addresses. This will harm your sender reputation and deliverability.

Error Responses

Invalid API Key (401)

{
  "error": true,
  "message": "Invalid or inactive API key",
  "code": "UNAUTHORIZED"
}

Invalid Request (400)

{
  "error": true,
  "message": "Email is required",
  "code": "BAD_REQUEST"
}

Rate Limited (429)

{
  "error": true,
  "message": "Rate limit exceeded. Please slow down.",
  "code": "RATE_LIMITED",
  "retry_after": 60
}

Insufficient Credits (402)

{
  "error": true,
  "message": "Please purchase more credits to continue",
  "code": "INSUFFICIENT_CREDITS",
  "current_balance": 0
}

Server Error (500)

{
  "error": true,
  "message": "Internal server error",
  "code": "SERVER_ERROR"
}

tip

For high-volume verification, consider using the Bulk Verification Endpoint instead. It's more efficient for verifying multiple emails.

Use Cases

Registration Form Validation

app.post('/register', async (req, res) => {
  const { email, password } = req.body;
  
  // Verify email before creating account
  const verification = await verifyEmail(email);
  
  if (!verification.is_valid) {
    return res.status(400).json({
      error: 'Please provide a valid email address'
    });
  }
  
  if (verification.is_disposable) {
    return res.status(400).json({
      error: 'Temporary email addresses are not allowed'
    });
  }
  
  // Proceed with registration
  await createUser(email, password);
});

Lead Qualification

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: getRecommendation(result)
  };
}

function getRecommendation(result) {
  if (result.status === 'safe' && !result.is_free_email) {
    return 'HIGH_PRIORITY'; // Business email, verified
  }
  if (result.status === 'safe') {
    return 'NORMAL'; // Personal email, verified
  }
  if (result.is_valid) {
    return 'LOW_PRIORITY'; // Valid but risky
  }
  return 'SKIP'; // Invalid
}

Common Questions

How fast is the verification?

Most verifications complete in 1-3 seconds. Complex domains or those with aggressive anti-spam measures may take up to 10 seconds.

What if I get "unknown" status?

The unknown status means we couldn't definitively verify the email. This can happen due to:

Server timeouts
Aggressive anti-spam measures
Temporary server issues

Consider retrying later or treating as risky.

Are credits refunded for invalid emails?

You're charged 1 credit regardless of the result. However, if verification completely fails (our system error), credits are not deducted.

Can I verify my own email domain?

Yes! You can verify any email address, including those on your own domain. This is useful for testing.

Is there a sandbox/test mode?

Currently, all API calls use real credits. We recommend using a small test batch to verify your integration works before going to production.

Next Steps

Ready for more?

-> Bulk Verification Endpoint - Verify multiple emails efficiently

-> Rate Limits & Error Handling - Understand limits and handle errors

Endpoint Details​

Request Format​

Headers​

Body​

Basic Example​

cURL​

Response Format​

Successful Response (200 OK)​

Response Fields Explained​

Core Fields​

Email Characteristics​

Risk Assessment​

Metadata​

Status Values​

✅ Safe Statuses​

⚠️ Risky Statuses​

❌ Invalid Statuses​

Error Responses​

Invalid API Key (401)​

Invalid Request (400)​

Rate Limited (429)​

Insufficient Credits (402)​

Server Error (500)​

Use Cases​

Registration Form Validation​

Lead Qualification​

Common Questions​

How fast is the verification?​

What if I get "unknown" status?​

Are credits refunded for invalid emails?​

Can I verify my own email domain?​

Is there a sandbox/test mode?​

Next Steps​