How to Use REST API for Email Verification & Configure Webhooks

Why Automate Email Verification with API and Webhooks?

You’re sending a campaign. The list is large. You check a few addresses manually. Then you hit send—and 18% of your emails bounce. Not because your content is bad. Because the addresses were outdated, invalid, or caught in a greylist. And now your sender reputation is at risk.

Manual verification is too slow. Even if you could check every email, you’d miss the real-time shift in status—like when a user’s domain starts rejecting mail, or when a catch-all server stops acting like one. You’re not just validating addresses. You’re building a live feedback loop between send and delivery, and you need tools that keep up.

Using a REST API for email verification and configuring webhooks for delivery status turns that loop into a real-time system. You verify at scale, instantly. You track results live. You know when a deliverability issue starts—and stop it before it harms your sender reputation.

Key takeaways

• API-based email verification checks 100+ addresses in under a second, eliminating manual delays.
• Webhooks for delivery status provide immediate alerts when emails fail, block, or land in spam—before reputation damage occurs.
• Together, they create a feedback loop: every verified address is tracked from validation to inbox placement, improving long-term deliverability.

How to Use the REST API for Email Verification in 5 Steps

You can verify individual or bulk email addresses in real time using the Email List Validation REST API. Start by getting your API key from the dashboard, then send a POST request to https://api.emaillistvalidation.com/v1/verify with your key in the Authorization header. Include the email in the body, and optionally use bulk=true and return_full_details=true to get full results. Parse the JSON response for verdict and risk_score to filter invalid or high-risk addresses. The API allows up to 100 requests per minute—use exponential backoff if you exceed it. This process works with any system that supports HTTP requests, including Node.js, Python, and custom scripts.

1. Go to your Email List Validation dashboard and navigate to Settings > API. Generate a new API key if you don’t have one. This key authenticates your requests and ensures you aren't rate-limited or blocked.
2. Use a POST request to https://api.emaillistvalidation.com/v1/verify. Include your API key in the Authorization: Bearer <your-key> header. Send the email address in the JSON request body, like {"email": "[email protected]"}. This ensures the API knows which address to validate.
3. Add optional parameters to customize your verification. Set bulk=true if you're verifying multiple emails (e.g., in an array). Use return_full_details=true to receive detailed verdicts and a risk_score from 0 to 100, which helps flag potentially problematic addresses. This improves decision-making in campaigns.
4. Parse the JSON response. Look for the verdict field—possible values are valid, invalid, catch-all, or risky. A valid verdict means the address is likely deliverable. A catch-all means the domain accepts all emails, which can lead to spam. A risky score suggests issues with deliverability, even if technically valid.
5. Handle rate limits: the API allows 100 requests per minute. If you exceed this, the server returns a 429 Too Many Requests status. Use HTTP status code 429 with exponential backoff in your code to retry gracefully. This prevents temporary blocks and keeps your system stable.

Real-time Integration and Scale

Let’s say you're building a sign-up flow. Every new email can be verified in real time via this API—no delays. For existing lists, use the bulk option to clean up thousands of addresses at once. The API returns results within milliseconds. For high-volume workflows, pair it with bulk email list cleaning to maintain healthy send rates and sender reputation.

Keep Delivery Rates High

Validating emails before sending reduces bounces, avoids spam traps, and protects sender reputation—key factors in inbox placement. According to Return Path’s deliverability research, high bounce rates correlate directly with email blocklists. Use the risk score to filter out addresses with known issues, such as those from disposable domains or role-based accounts. This keeps your messages where they belong: in the inbox.

What Each Email Verification Verdict Means in Practice

You need to know what each email verification result means so you can act on it correctly. A "valid" address is ready to send to. An "invalid" one should be removed. "Catch-all" domains accept everything but may not deliver. "Risky" addresses—like temporary, role-based, or disposable ones—should be excluded to protect your sender reputation. Understanding these verdicts prevents bounces, improves inbox placement, and stops your domain from being flagged.

How to Respond to Each Verification Verdict

Let’s break down what each status means and what you should do next. If you're using an email verification API or integrated with tools like Mailchimp or HubSpot, these verdicts feed directly into your list hygiene workflow.

For real-time integration with your workflows, consider how your email verification API handles these statuses. You can programmatically exclude "invalid" or "risky" addresses before sending, and log "catch-all" results for review. This reduces churn and keeps your sender reputation healthy.

Learn more about how our API and bulk verification tools help you act on these results in real time: integrate email verification into your signup or CRM flow, or clean large databases before campaign launches. The goal isn’t just accuracy—it's sustainable sending. You’re not just removing bad addresses; you’re protecting your domain’s reputation across providers.

Why Webhooks Matter for Delivery Status Tracking

You can verify an email address as valid all day long, but that doesn’t mean it will actually land in the inbox. Webhooks give you real-time feedback when messages are delivered, bounced, or marked as spam—critical data for maintaining sender reputation and improving long-term deliverability. Without this feedback, you're guessing. With it, you're adjusting.

Verification Isn’t Delivery – Feedback Is What Closes the Loop

Just because an email passes validation doesn’t mean it’ll ever reach a user’s inbox. Some addresses are technically valid but are configured to auto-drop messages, or their providers throttle sends from unknown senders. The real test happens after send, not before.

That’s where webhooks come in. They act as an automatic reporter, notifying your system when an email is delivered, delayed, bounced, or flagged as spam. You don’t need to poll servers or scrape logs—status changes come directly to you.

Industry standards like the IETF’s SMTP RFCs define the protocols behind delivery, but the feedback loop is what turns those technical signals into actionable insights. Real-time status tracking helps you refine which users to keep, which to re-verify, and which to remove.

Keep Sender Reputation in Real Time

Spam filters don’t just care about the email content—they track how often your domains or IPs fail to deliver or get marked by recipients. If you keep sending to invalid or inactive addresses, your reputation suffers.

Webhooks allow you to respond to bounces and spam complaints instantly. You can remove problematic emails from your list, pause sends to risky domains, or trigger re-verification workflows. This keeps your sender reputation healthy and your inbox placement stable.

Tools like real-time email verification APIs help clean your list before send, but webhooks ensure you’re not just cleaning—it’s the ongoing feedback that protects your reputation. It’s a continuous improvement loop.

For a complete view, consider testing your delivery path with inbox placement reports, which simulate real-world delivery across multiple providers. Combined with webhooks, they give you the full picture: which emails go to junk, which bounce, and which actually get seen.

How to Set Up Webhooks for Delivery Status Updates

You can track delivery status in real time by setting up webhooks in your Email List Validation dashboard. Enter your HTTPS endpoint URL, choose which events to monitor—delivered, bounced, or spam-reported—and test it with a sample payload. Your server must respond within 5 seconds with a 2xx status; otherwise, the system retries up to three times.

Step-by-step: Configure Webhooks for Real-Time Delivery Tracking

1. Navigate to Integrations > Webhooks in your Email List Validation dashboard. This is where you manage all event-based notifications from your verification and delivery workflows.
2. Enter your HTTPS endpoint URL. This is the public URL on your server where delivery updates will be sent. Make sure it's publicly accessible and supports POST requests. Use a secure endpoint—HTTP is not allowed. Refer to RFC 7231 for guidance on HTTP status codes and their meaning during API interactions.
3. Select the event types you want to track. You can choose delivered, bounced, or spam-reported events. Selecting only what's relevant reduces noise and keeps your event processing system efficient.
4. Test the webhook with a sample payload. Use the built-in test button to send a simulated event. This checks that your endpoint accepts data and parses it correctly. It’s a quick way to validate your server logic before going live.
5. Ensure your server responds within 5 seconds. The system waits up to 5 seconds for a 2xx response before retrying. If your server takes longer, or returns 4xx/5xx codes, the webhook will retry. This can cause delays or duplicate events if not handled properly.

Why This Matters for Deliverability

Webhooks transform your email system from reactive to proactive. Instead of manually checking logs, you receive immediate alerts for bounces or spam reports—critical for maintaining sender reputation. According to Return Path’s deliverability research, even a 1% increase in inbox placement can improve engagement by over 10%, especially in competitive industries.

When combined with real-time verification via the Email Verification API, webhooks ensure you only send to addresses that are valid, active, and likely to engage—reducing the risk of spam filtering and blacklisting.

Integrating with SendGrid, Mailchimp, Klaviyo, and HubSpot

You can use the Email List Validation API to clean your lists before sending through SendGrid, Mailchimp, Klaviyo, or HubSpot. Verify emails in bulk or in real time, then sync results via webhooks to track delivery status and prevent bounces. This reduces spam complaints and improves inbox placement across all platforms.

Pre-verify with the API, then send

• Use the real-time verification API to check every email in your list before sending, reducing invalid addresses by up to 30%—a common benchmark in deliverability best practices.
• Filter out disposable domains, catch-all addresses, and role accounts that risk reputation damage or low engagement.
• Use the bulk verification tool to process thousands of emails offline and export only those confirmed valid.

Platform-specific integration patterns

• SendGrid: Run verification via the API prior to sending. Then use webhooks to receive delivery status updates and flag undeliverable or risky addresses in real time.
• Mailchimp: Build a custom integration that pulls verified emails into your account. Sync only valid addresses, preventing campaigns from being sent to bad data.
• Klaviyo: Use API-verified segments to create targeted campaigns. This avoids sending to risky or invalid domains, which can slow down or halt delivery.
• HubSpot: Integrate verification into automation workflows. Prevent invalid contacts from being added during form submissions or import processes.

Webhooks deliver delivery outcomes directly to your system. Use them to update your CRM, log bounces, or flag addresses needing follow-up. This real-time feedback loop maintains list hygiene and sender reputation.

Consistently verifying email addresses before sending is an industry-standard practice supported by RFC 7505, which outlines best practices for email validation and sender accountability.

How Webhooks Improve Sender Reputation Over Time

Webhooks give you real-time proof of delivery—when emails land in inboxes, not just attempts. This lets you refine your list over time by removing addresses that bounce or fail to engage, reducing hard bounces and blacklisting risks. Consistently clean data builds a trustworthy sending profile, improving domain authority and inbox placement during warm-up.

Delivery Status, Not Just Attempts, Builds Trust

Most tools only confirm SMTP handshake success, but you need to know if the email actually reached the inbox. Webhooks capture real delivery events—delivered, opened, bounced, or blocked—so you can see how many of your messages succeed in practice, not just in theory.

For example, an email might “connect” but get filtered to spam. Without webhooks, you wouldn’t know. With real-time delivery tracking, you adjust your list faster, improve sender reputation, and avoid penalties from providers like Gmail or Outlook.

Over Time, Clean Lists Improve Domain Warm-Up and Authority

Domain reputation isn’t built overnight. It relies on consistent sending patterns and clean recipient data. When your webhooks show low bounce rates and high deliverability over weeks, ISPs begin to see your domain as reliable—even during early warm-up phases.

Let’s say you send 10,000 emails per month. With webhooks, you identify and remove 15% of addresses that repeatedly bounce. That reduces your bounce rate from 8% to around 6.8%—a meaningful drop in the eyes of deliverability systems. ISPs reward that stability with better inbox placement.

This is how domain warm-up works: predictable, low-bounce volume over time signals trustworthiness. Tools like real-time email verification APIs help you scrub your list upfront, while webhooks keep your data accurate as lists evolve.

For deeper insight, industry practices from RFC 6221 (SPF) and Spamhaus' best practices show that sustained low bounce rates are a key factor in avoiding blacklisting.

Rate Limits, Idempotency, and Retries

You're limited to 100 API requests per minute, so you must plan for rate limits. Use idempotency keys to prevent duplicate processing if a request fails or times out. When you hit a 429 Too Many Requests error, retry with exponential backoff. Queue failed requests and process them during off-peak hours to sustain performance. This keeps your system robust and avoids blocking legitimate traffic.

Handle API Limits with Care

• Respect the 100 requests per minute cap—exceeding it triggers a 429 response, which blocks further requests temporarily.
• Monitor your request frequency using a token bucket or similar algorithm to stay within bounds.
• Use the HTTP 429 status code as a signal to pause and retry, not to fail silently.
• Adjust your rate based on real-time feedback, not just a fixed schedule. Some servers may throttle more aggressively than others.

Build Resilience with Idempotency and Backoff

• Always include an idempotency key in your request headers when calling the real-time verification API. This ensures repeated attempts with the same key don’t cause duplicate verification jobs.
• If a request times out, use the same idempotency key to safely retry. The server will recognize it and return the prior result instead of reprocessing.
• When receiving a 429 response, implement exponentially increasing delays (e.g., 1s, 2s, 4s, 8s) before retrying. This reduces load and avoids overwhelming the service.
• Store failed requests in a queue with metadata (timestamp, retry count, failure reason). Process them during low-traffic periods—like overnight or weekends—to preserve performance during peak usage.
• Keep a cap on retry attempts (e.g., max 5) to prevent infinite loops in case of persistent errors.

These practices aren’t just best practice—they’re required to maintain a stable integration with any email validation service. Without idempotency, you risk paying for repeated validations or corrupting your delivery data. Without backoff, your app can be blocked by throttling.

Accuracy: What 98.9% Verification Accuracy Actually Means

For every 1,000 emails you verify with our system, fewer than 12 will be misclassified—meaning you’ll catch invalid formats, non-existent domains, disposable addresses, and role-based emails before sending. This accuracy is based on real-world inbox placement outcomes, not just syntax checks, and is validated over time with actual delivery data.

How Real-World Accuracy Is Measured

Most email verification tools rely on basic syntax rules or outdated blacklists. Ours goes further: it checks domain existence, MX records, SMTP server responses, and behavior patterns—like whether a domain accepts mail for a given address. This means we don’t just flag a bad format; we confirm whether an inbox is likely to accept mail, which aligns with actual delivery success rates.

We measure accuracy not just against a static list of known invalid domains, but against real-world delivery results. For example, when we validate a list, we compare the final deliverability rate of the verified addresses—what actually makes it into inboxes—against the initial list. This long-term feedback loop ensures that our 98.9% figure is not theoretical, but grounded in actual performance.

Why It Matters in Practice

If you're using real-time email verification or bulk validation, a 98.9% accurate system means fewer bounces, less time spent managing blocklists, and better sender reputation. That’s especially important at scale—sending to lists of 10,000+ emails without the risk of clogging your sender reputation by hitting rate limits or triggering spam filters.

Still, no system is perfect. Some legitimate addresses may be flagged as risky or catch-all due to strict domain policies. But compared to industry-standard tools—like those relying only on syntax or simple DNS checks—our accuracy is significantly higher. According to industry benchmarks, many real-time solutions operate below 95% accuracy, especially with disposable or obscure domains.

For instance, a domain like RFC 5321 outlines the SMTP protocol that governs email delivery. Our system follows these standards strictly, validating against the actual SMTP handshake process. That’s why our results align with how email actually works, not just how it’s supposed to look on paper.

When you use our real-time API or perform bulk verification, you’re getting a service designed to mirror real inbox behavior, not just a syntax checker. The difference shows up in deliverability: fewer bounces, no wasted sends, and a lower chance of being marked as spam.

Start Free, Scale Without Expiry: How Credits Work

You get 100 free email verifications right after signing up—no trial period, no expiry. Each verification uses one credit, and any unused credits stay yours forever. Buy more credits on-demand, pay only for what you use, and never hit a monthly cap or face surprise billing. It’s designed to grow with your needs, not against them.

Free to Start, Never Expire

On sign-up, you’re granted 100 free verifications—no time limit, no strings. Use them all, or save them for later. Unlike trials that vanish after 14 days, your credit balance does not reset or expire, even if you don’t use it for months.

This allows you to test the system with real data, clean critical lists, or run inbox placement tests without upfront cost. The credit system is built around usage, not time. You’re in control.

Purchase On-Demand, Scale Flexibly

Once you’ve used your free credits, buy more as your sending volume grows. There’s no recurring subscription, no minimum spend. Just add credits when needed and only pay for the checks you run.

Because there are no monthly caps, you can verify thousands of addresses in a single batch without worrying about being throttled. This avoids the hidden cost traps common in services that bill based on volume tiers or limit usage per month.

Real-time email verification via API or bulk uploads through email list cleaning works seamlessly with this model. Whether you're validating 100 emails or 100,000, you’re only paying for the checks done.

For teams using tools like Mailchimp, HubSpot, or SendGrid, the integrated email verification tools make it easy to validate addresses before sending, without changing workflow. Your credit balance keeps track across all use cases.

For more context on how email infrastructure operates, the SMTP specification (RFC 5321) outlines how email systems validate and deliver messages, showing why accurate, real-time verification matters in practice.

It’s a simple, transparent model: verify more, pay more, but only when and how you want. There are no surprises. Your credits are yours to keep, spend, or save—forever.

Final Take: Automation Is the Only Reliable Path to Deliverability

Email verification isn’t a one-time cleanup. It’s an ongoing requirement that must adapt to changing data, new signups, and shifts in sender reputation.

Using a REST API for real-time validation and configuring webhooks for delivery feedback turns static checks into a dynamic system. Each new email is verified before sending, and delivery results are fed back automatically to flag issues.

By integrating verification and status updates directly into your workflow, you maintain a clean list, avoid hard bounces, protect your sender reputation, and ensure consistent inbox placement.

Keep reading

• List validation API and automation for marketing teams (complete guide)
• How to Adjust Precedence Field in Python smtplib Automated Responses
• Email Verification API with Content Analysis for Unwanted Message Flagging
• Email Validation API That Identifies 410 4.7.15 DSN Retention Issues
• How to Reduce 503 Errors in Email Validation with Retry Delay Logic

Ready to put this into practice? Email List Validation verifies emails with 98.9% accuracy — start with 100 free verifications.

Frequently asked questions

How does the REST API verify email addresses?

It performs real-time checks using DNS, SMTP, and pattern analysis. It validates syntax, domain existence, mailbox presence, and spam trap detection.

Can I use the API with Python or JavaScript?

Yes. The API supports any HTTP client. Examples are available in our documentation for Python, JavaScript, and other common stack languages.

What’s the difference between a webhook and a polling endpoint?

Webhooks push real-time delivery data to your server immediately upon event. Polling requires your system to repeatedly check status, increasing load and latency.

Do webhooks send data about every email I send?

No. Webhooks only notify you of delivery status for emails sent via Email List Validation's verified list or integration-enabled pipelines.

How do I test my webhook endpoint before going live?

Use the test button in the dashboard to send a sample event. You’ll see the payload and response code in real time.

Can I verify a list of 10,000 emails with a single API call?

Yes. Set the `bulk` parameter to true and send the list as an array in the request body. The API processes batches up to 100 emails per request.

What kind of events does the webhook notify about?

Delivered, bounced, spam-reported, or failed to send due to policy violations or domain rejection.

Is the API free to use?

You get 100 free verifications. Beyond that, credits are purchased at a fixed rate per use—no subscriptions.

How long does an email verification take?

Typically under 1 second per email for valid and invalid addresses. Catch-all or risky addresses may take longer due to deeper checks.

Does this API handle role-based email addresses like support@ or info@?

Yes. It identifies them as 'risky' and suggests exclusion, especially if you're targeting individual users.

Do I need to configure DNS records to use the API?

No. The API works independently of your DNS setup. You only need your API key and a secure endpoint.

Can I integrate this with internal CRM or database systems?

Yes. Use the API to validate inputs or sync verification results with your CRM. Webhooks can trigger updates in real time.