🛠️ For Developers & Platform Architects

The Email Validation API That Never Lets You Down

The high-speed email validation API for developers and platform architects. 99.99% Uptime SLA. Sub-100ms global response times. Drop-in REST endpoints, ready code samples for cURL, Node.js, Python, & PHP, and asynchronous webhooks engineered for high-concurrency production scale.

api.bouncify.io/v1/verify
200 OK • 68ms
$ curl -X GET 'https://api.bouncify.io/v1/verify?apikey={KEY}&email=alex.dev@acme.corp'
{
  "success": true,
  "result": "deliverable",
  "message": "This address can receive emails.",
  "email": "alex.dev@acme.corp",
  "user": "alex.dev",
  "domain": "acme.corp",
  "accept_all": 0,
  "role": 0,
  "free_email": 0,
  "disposable": 0,
  "spamtrap": 0
}

Why Incumbent APIs Break

Engineered to Solve Legacy Verification Flaws

Most email verification APIs were built a decade ago as batch script wrappers. Our dedicated email list verifier eliminates painful latency on user signup forms, strict corporate mail servers, and rigid rate limits that crash high-volume queues.

Zero Friction at Point of Entry

Legacy verification APIs take 500ms to 1,500ms per verification call, introducing noticeable friction during checkout, lead form submission, and user registration. Bouncify's globally distributed SMTP ping network responds in sub-100ms, validating addresses inline on form blur without degrading user conversion rates.

Anti-Greylisting & Catch-All Precision

Cheap verifiers mark up to 10% of legitimate business traffic as "Unknown" when encountering greylisting or rate-limiting on Microsoft 365, Exchange, and Yahoo mail servers. Bouncify utilizes adaptive multi-pass retry logic and deep MX DNS heuristics to resolve edge cases into definitive deliverable or undeliverable verdicts.

High Concurrency Without Throttling

Other providers choke burst traffic with 5 requests/sec caps or charge thousands for enterprise rate increases. Bouncify offers a generous 120 req/min baseline, multi-threaded parallel queues, and custom high-throughput enterprise pipelines capable of handling millions of records daily.

Unified Developer Endpoints

One REST API. Every Verification Workflow Covered.

From single-email synchronous lookups to multi-million contact asynchronous batch jobs, integrate clean, deterministic email hygiene into your production stack in minutes.

Synchronous Point-of-Entry API

Prevent fake accounts, disposable mailboxes, and registration typos before they enter your database. A single lightweight HTTP GET request returns comprehensive deliverability status, syntax checks, and risk flags in under 100ms.

Fire-and-Forget Bulk Scrubbing

Submit lists of 1,000 to 1,000,000+ emails via a single HTTP POST request. Bouncify queues the job across distributed workers for asynchronous email list validation in parallel, keeping your servers free from long-running synchronous timeouts.

Automated Callback Hooks

Eliminate expensive polling loops. Configure an HTTPS webhook endpoint to receive automated JSON event payloads the moment your bulk batch verification completes, including full summary counts and one-click download URLs.

Programmatic Balance Monitoring

Query your real-time credit balance and account status programmatically. Set up automated Slack or email alerts in your internal systems when credits drop below your custom operational safety threshold.

10+ Diagnostic Data Points

Make intelligent business routing decisions with detailed attributes: boolean flags for free consumer domains (Gmail, Yahoo), disposable burner addresses, role-based mailboxes (billing@, support@), and spam traps.

Free Health & Deduplication Preview

Never pay for duplicate data. Every bulk list uploaded via API or web receives automatic free syntax analysis, deduplication removal, and an estimated health breakdown before consuming a single verification credit.

Drop-In Code Integration

Start Verifying in Under 5 Lines of Code

Copy, paste, and run. Use native HTTP clients and drop-in code snippets across any modern backend runtime.

Bash / Shell Terminal bash
$ curl -X GET 'https://api.bouncify.io/v1/verify?apikey=YOUR_API_KEY&email=alex.dev@acme.corp' \
  -H 'Accept: application/json'
Node.js (Fetch / TypeScript) javascript
import fetch from 'node-fetch';

const apiKey = process.env.BOUNCIFY_API_KEY;
const email = 'alex.dev@acme.corp';

const response = await fetch(
  `https://api.bouncify.io/v1/verify?apikey=${apiKey}&email=${encodeURIComponent(email)}`,
  { headers: { 'Accept': 'application/json' } }
);

const data = await response.json();
if (data.result === 'deliverable' && !data.disposable) {
  // Allow registration to proceed safely
  console.log(`Email verified: ${data.email}`);
} else {
  console.warn(`Blocked invalid or risky address: ${data.result}`);
}
Python (Requests Library) python
import requests
import os

api_key = os.getenv("BOUNCIFY_API_KEY")
email = "alex.dev@acme.corp"

response = requests.get(
    "https://api.bouncify.io/v1/verify",
    params={"apikey": api_key, "email": email},
    headers={"Accept": "application/json"}
)

data = response.json()
if data.get("result") == "deliverable":
    print(f"Address is safe to send. Latency: <100ms")
else:
    print(f"Risk status: {data.get('result')}, Reason: {data.get('message')}")
PHP (cURL) php
<?php
$apiKey = getenv('BOUNCIFY_API_KEY');
$email = 'alex.dev@acme.corp';

$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, "https://api.bouncify.io/v1/verify?apikey=" . $apiKey . "&email=" . urlencode($email));
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, array('Accept: application/json'));

$response = curl_exec($ch);
curl_close($ch);

$result = json_decode($response);
if (isset($result->result) && $result->result === 'deliverable') {
    // Address is valid, proceed with registration flow
}
?>

Response Schema Specification

Every API verification request returns a standardized, deterministic JSON payload with complete deliverability classification and risk indicators:

Field Key Type Description
success Boolean true when verification executed successfully.
result String Primary status: deliverable, undeliverable, accept_all, or unknown.
message String Human-readable explanation (e.g., "This address can receive emails.").
email String Normalized email address evaluated.
user / domain String Parsed local mailbox account and fully qualified domain name.
accept_all Integer 1 if domain operates as a catch-all server; 0 if verified specifically.
role Integer 1 for generic departmental accounts (support@, admin@); 0 for individual.
free_email Integer 1 for public consumer webmail (Gmail, Yahoo, Hotmail); 0 for custom business domain.
disposable Integer 1 if identified as a temporary burner service (Mailinator, 10MinuteMail); 0 for real host.
spamtrap Integer 1 if flagged in known spam-trap and honeypot registries; 0 if clean.

Deterministic Verification Pipeline

Under the Hood: 9 Multi-Stage Verification Checks

Every email submitted through our API passes through an intelligent, multi-layer inspection pipeline before returning a verdict, ensuring 99%+ deliverability accuracy.

01

RFC Syntax & Format Validation

Validates character encoding, regex syntax, illegal characters, domain structure, and top-level domain (TLD) existence against IETF RFC 5322 specifications.

02

DNS & MX Record Query

Queries authoritative nameservers to confirm active Mail Exchange (MX), Address (A), and Canonical Name (CNAME) records for the recipient domain.

03

Real-Time SMTP Handshake

Initiates a low-level SMTP conversation with the recipient mail server, establishing an EHLO/HELO dialogue without ever transmitting an actual marketing message.

04

Deep Mailbox Ping

Simulates the envelope sender address (RCPT TO) to verify whether the individual mailbox exists, is active, and can receive incoming messages.

05

Anti-Greylisting Resolution

When receiving temporary server delays (451 / 421 SMTP codes), our retry worker intelligently schedules an exponential-backoff ping to obtain a definitive deliverability verdict.

06

Catch-All (Accept-All) Resolution

Sends targeted test probes to random addresses on the domain to determine if the mail server accepts all incoming mail indiscriminately.

07

Disposable / Burner Email Filtering

Cross-references recipient domains against our dynamically updated database of over 100,000+ temporary email providers (e.g., GuerrillaMail, Mailinator).

08

Role-Based Account Identification

Detects departmental and system aliases (support@, billing@, sales@, admin@) that lead to high spam complaint rates in cold outreach.

09

Spam Trap & Honeypot Detection

Identifies recycled email addresses and honeypots maintained by blacklist operators (Spamhaus, Sorbs) to protect your sender domain reputation.

Built for Mission-Critical Infrastructure

Enterprise Security & Reliability by Default

Designed for data protection officers and DevOps engineers who demand zero downtime, zero data leakage, and rigorous privacy compliance.

99.99% Guaranteed Uptime SLA

Our distributed verification infrastructure is deployed across multi-region edge servers with automated failover routing, guaranteeing 99.99% system availability around the clock.

Strict TLS 1.3 Encryption in Transit

Every API call is enforced over modern TLS 1.3/1.2 protocols with 256-bit SSL encryption. Plaintext HTTP traffic is rejected at the edge.

IP Allowlisting & Token Revocation

Lock API key access strictly to your production server IP addresses. Generate, cycle, or revoke API keys instantly from the Bouncify developer dashboard.

Automated 30-Day Data Purging & GDPR

We act strictly as a secure data processor under GDPR. Bulk files and verification logs are automatically purged from our servers after 30 days, or you can delete them immediately via API.

Zero List Sharing or Monetization

Your email data belongs entirely to you. Bouncify never shares, rents, resells, or aggregates your contact lists. Your proprietary customer records remain strictly confidential.

Developer FAQ

Frequently Asked Questions by Engineers

Technical answers regarding rate limits, webhooks, error codes, and credit billing.

The baseline rate limit for the Bouncify Real-Time Verification API is 120 requests per minute per API key. For high-volume enterprise applications requiring thousands of requests per second, custom elevated concurrency tiers and dedicated verification pipelines are available upon request.
You submit your email list using a single HTTP POST request to /v1/bulk with your base64 CSV or file payload. The API immediately responds with a unique job_id. You can configure an HTTPS webhook callback URL to receive an automated notification when processing finishes or poll the job status endpoint.
Yes. Bouncify operates on a unified credit system where 1 credit equals 1 verified email address. The credits in your account balance are interchangeable and can be consumed via single real-time API calls, bulk async API jobs, or manual CSV uploads on the web dashboard. Pay-as-you-go credits never expire.
Greylisting is a spam-prevention mechanism where receiving mail servers temporarily reject incoming SMTP connection attempts with a 451 or 421 status code. Unlike primitive verifiers that immediately mark these as Unknown, Bouncify's engine intelligently executes multi-pass retries over configured intervals to achieve a definitive deliverable or undeliverable status.
Our API uses standard HTTP response codes. A 200 OK indicates a successful verification lookup. Standard client error codes include 400 Bad Request for malformed parameters, 401 Unauthorized for invalid API keys, 402 Payment Required for insufficient credits, 429 Too Many Requests when exceeding rate limits, and 500 Internal Server Error.
Yes. Every new account receives 100 free verification credits immediately upon registration with no credit card required. You can generate your API key in seconds and test live calls against both single validation and bulk endpoints right away.
WhatsApp Chat