Set Up Webhook Delivery for Email Verification

Why automate email verification results with AWS Lambda?

You've just run a bulk email verification. Thousands of addresses processed. Now you’re staring at a CSV file, manually filtering out invalid emails, flagging risky ones, and updating your CRM—again. It’s not just tedious. It’s a bottleneck that slows down campaigns and hurts deliverability.

What if that process ran itself the moment results came in? With a webhook from Email List Validation and AWS Lambda, you can route each verified address—valid, invalid, catch-all, or risky—directly into your workflow, no manual step required. It’s like setting up a self-cleaning inbox: the data arrives, the logic runs, and actions follow—all in under a second.

Automating email verification results with AWS Lambda isn’t a luxury. It’s how high-volume senders maintain list hygiene at scale, reduce bounce rates, and protect sender reputation.

Key takeaways

Webhooks from Email List Validation send real-time verification results directly to AWS Lambda, eliminating manual CSV downloads and processing.
Serverless functions in AWS Lambda scale automatically to handle spikes in verification volume without provisioning servers.
Immediate processing of results—valid, invalid, catch-all, or risky—enables automatic list updates, segment filtering, or suppression of problematic addresses.

What you need to set up webhook delivery to AWS Lambda

You need an active Email List Validation account with API access, an AWS account with IAM permissions to manage Lambda functions, a publicly accessible HTTPS endpoint (like one exposed via API Gateway), and basic familiarity with JSON, REST, and event-driven systems. Let’s break down each requirement so you know exactly what to prepare.

Core prerequisites

Sign up for an Email List Validation account with API access—this is how you’ll trigger verifications and receive results via webhooks.
Have an active AWS account with the ability to create and manage AWS Lambda functions, including configuring execution roles and permissions via IAM.
Set up a publicly accessible HTTPS endpoint using AWS API Gateway. This endpoint must be reachable over the internet and configured to accept POST requests from Email List Validation’s webhook system.
Understand how REST APIs work, including handling JSON payloads, status codes, and event-driven workflows. You’ll be receiving structured data in real time.

Key setup notes

API Gateway acts as a proxy between your Lambda function and the external world. It’s responsible for authenticating incoming requests and routing them correctly. Without a public HTTPS endpoint, your Lambda function won’t receive webhook triggers.

Security matters: ensure your API Gateway endpoint includes proper authentication (e.g., API keys or Lambda authorizers) to prevent unauthorized access. You’re sending sensitive data—verify your endpoint’s configuration aligns with industry-standard practices like those outlined in RFC 7231.

When designing your Lambda function, plan for idempotency—webhooks can be resent in case of delivery failure. Use unique IDs from the webhook payload to prevent duplicate processing.

You don’t need to store results locally unless you’re building a custom dashboard. Many teams use Lambda to log results to a database (like DynamoDB) or trigger downstream workflows.

The key to reliable webhook delivery isn’t just the endpoint—it’s consistency in handling payloads, managing retries, and validating signatures if supported.

Once your Lambda function is deployed and reachable via HTTPS, register the URL as your webhook receiver in Email List Validation’s dashboard. You’ll receive real-time verification results in JSON format, including verdicts like valid, invalid, catch-all, or risky.

How Email List Validation’s webhook system works

You can set up real-time delivery of email verification results to any HTTPS endpoint using Email List Validation’s webhook system. Each verified email triggers a JSON payload sent immediately—within seconds—containing the email address, verification verdict (valid, invalid, catch-all, or risky), and timestamp. If delivery fails, the system retries up to three times with exponential backoff, ensuring no results are lost.

What’s in the webhook payload

The JSON payload is straightforward and machine-readable. It always includes the original email address, the verdict, and a timestamp indicating when the verification completed. This structure makes it easy to route results into your internal systems—whether a database, CRM, or analytics engine—without complex parsing.

For example: a valid verdict means the email is deliverable and likely active. An invalid verdict signals a syntax or domain-level error. A catch-all address can receive mail for any address under that domain—often a false positive in list hygiene. A risky verdict flags addresses with behaviors that raise red flags, like those tied to disposable domains or known spam traps.

Reliability and delivery guarantees

Webhook delivery is designed for reliability. We retry failed deliveries up to three times using increasing delays—10 seconds, then 30, then 60—based on standard industry patterns for backoff strategies. This aligns with best practices outlined in RFC 6522, which governs email delivery protocols and retry logic.

If a webhook endpoint is unreachable after three attempts, you’re notified via the Email List Validation dashboard, so you can take corrective action. This ensures your systems stay in sync with the latest verification status. The system never drops a result due to a transient network issue.

Webhooks integrate seamlessly with AWS Lambda, which makes them ideal for serverless automation. You can process each result in real time—filtering out risky or invalid addresses and updating your customer database automatically. For detailed setup steps, see the real-time verification API documentation or try a bulk verification to test the system in your workflow.

Set up an API Gateway proxy to receive webhooks

You configure API Gateway to receive email verification results by creating a REST API endpoint with a Lambda proxy integration, enabling full request forwarding. This setup lets your AWS Lambda function process raw webhook payloads directly, including headers, body, and context. Once deployed, you get a public URL to register with your email verification provider.

Create the API and resource

Log in to the AWS Management Console and open API Gateway. Choose "Create API" and select "REST API" from the options.
Create a new resource named /webhook/verification. This endpoint will be the target for incoming verification results from your email validation service.
Within the resource, create a POST method. This method will handle incoming webhooks, as most email validation providers use POST to send data.
Set the integration type to "Lambda Function". In the Lambda Function field, select your existing verification processor function. Choose "Proxy" integration to pass the full HTTP request, including the body, headers, and query parameters, directly to your function.
Save the method. API Gateway will generate a deployment endpoint automatically. You’ll later deploy it to a stage, such as prod, to make it public.

Deploy and secure your API

After configuring the method, go to the "Actions" dropdown and choose "Deploy API". Select a stage—prod is standard—and specify a deployment description. API Gateway will generate a public URL in the format https://your-api-id.execute-api.region.amazonaws.com/prod/webhook/verification.

The 5 steps described in “Create the API and resource”, in order.

This URL is the webhook endpoint your email verification service will call when a verification completes. Use it when setting up integrations with tools like Email List Validation. For example, if you're using their real-time verification API, you can configure the callback URL to send results here.

For security, consider adding IAM authorization or API keys. While not required for basic use, these controls help prevent unauthorized access. You can also use AWS WAF to block known malicious traffic patterns. Refer to the AWS API Gateway security documentation for guidance on securing public endpoints.

Create and configure an AWS Lambda function

You’ll create a Lambda function to process real-time email verification results from Email List Validation by setting up a Python 3.12 runtime with proper permissions. This function will receive webhook payloads, validate them, and store results in S3 or DynamoDB. You’ll use the AWS Console to define the function, assign roles, and deploy a minimal handler to confirm connectivity.

Set up the function in the AWS Console

Go to the AWS Lambda console and click “Create function.” Choose “Author from scratch” to start with a clean slate. This ensures no default configurations interfere with your webhook logic.
Name your function something descriptive like process-verification-webhook and select Python 3.12 as the runtime. Python 3.12 is stable, well-supported, and compatible with most third-party libraries used in verification pipelines.
For the execution role, pick “Create a new role with basic Lambda permissions.” This includes access to CloudWatch Logs, which is essential for monitoring errors and debug messages. You’ll later add specific permissions for S3 or DynamoDB as needed.

Paste the following minimal handler into the function code editor:

def lambda_handler(event, context): return {"statusCode": 200, "body": "Received"}

This returns a 200 status to acknowledge receipt. Even with no logic, it’s a valid baseline to confirm your webhook endpoint is callable.

Add permissions and deploy

After saving the code, go back to the function’s configuration. Under “Permissions,” find the execution role and attach a policy granting access to your target service. For example, if you’re writing to S3, attach a policy with s3:PutObject and s3:PutObjectAcl permissions. If using DynamoDB, add dynamodb:PutItem. These permissions are required to persist data from the webhook.

Once configured, test the function using a sample event that mimics the webhook payload structure from Email List Validation. You can create this in the console’s “Test” tab. The response should return {"statusCode": 200, "body": "Received"}, confirming Lambda is ready to accept real data.

For real-world use, integrate your function with Email List Validation’s real-time API to process results at scale. You can trigger the Lambda function directly from webhook delivery after verifying a list, ensuring only valid emails move forward.

Configure Email List Validation to send webhooks to your Lambda endpoint

You can set up Email List Validation to push verification results to your AWS Lambda function via a webhook by navigating to the Webhooks section in your account, entering your API Gateway endpoint URL, selecting 'Send on verification completion' as the trigger, setting a 200 status code expectation, enabling retries, and testing the connection. This ensures your system automatically processes results without manual polling.

Set up the webhook in Email List Validation

Log in and go to Webhooks — Access your Email List Validation account and navigate to the Webhooks section under Settings. This is where you define how and when results are delivered.
Enter your API Gateway endpoint URL — Use the full public URL of your deployed API Gateway stage (e.g., https://your-api-id.execute-api.region.amazonaws.com/prod/webhook/verification). This must be accessible over HTTPS and publicly reachable.
Select 'Send on verification completion' — Choose this trigger type so the webhook fires only after each email has been verified. This avoids unnecessary calls and keeps data processing efficient.
Set expected status code and enable retries — Specify 200 as the expected response code. Enable retries (up to 3 attempts) to handle transient network issues. AWS Lambda may take a few seconds to respond, so giving the system time to recover is crucial.
Test the connection — Use the built-in Test Connection button to validate reachability. The API should receive a test payload and return 200. If not, check your gateway's resource policy or Lambda’s IAM permissions. For reference, AWS Lambda documentation outlines how to configure proper execution roles and VPC access.

Finalize and monitor

Your webhook now routes real-time verification outcomes directly to your Lambda function. This allows you to process valid, invalid, and catch-all results programmatically — for example, updating databases, triggering campaigns, or filtering out bounces.

For ongoing maintenance, check logs in AWS CloudWatch to monitor delivery success and failures. If you’re running bulk validations, consider setting up a companion API endpoint to store results in a database or stream to another service.

Want to clean a large list before sending? Explore our bulk email list cleaning tool, which integrates smoothly with webhooks and delivers results you can automate.

Parse and validate incoming webhook payloads

You receive webhook payloads in JSON format from Email List Validation, so your Lambda function must parse the body as JSON to extract fields like email, verification_status, and timestamp. Before processing, check that the email value matches a valid email format using a standard regex pattern—this prevents malformed data from triggering downstream errors. Then inspect the verification_status to route results correctly: valid means deliverable, invalid means undeliverable, catch-all indicates a mailbox that accepts all emails, and risky means potential deliverability issues like temporary unavailability or blacklisted IPs.

Check payload integrity and structure

Not all incoming requests are legitimate. Always validate that the payload includes essential fields—especially email and verification_status—and reject requests missing them. You can use a simple if (!event.email || !event.verification_status) check early in your function. This stops malformed or spoofed data from reaching later stages, avoiding unnecessary processing and reducing cold start overhead. For added security, consider validating incoming signatures if your service supports HMAC or similar mechanisms, though this depends on the sender’s implementation.

Once the payload passes structural checks, log the full event to CloudWatch with a timestamp and a unique trace ID. This isn’t just for debugging—it’s critical for audit tracking. If a recipient reports not receiving an email, you’ll need to trace back the verification state at the time of send. Store the raw payload as a JSON string in the log, and include context like the processing time and function name. This makes it easy to correlate logs across systems, especially when integrated with tools like Splunk or Datadog.

Understand the status meanings

Each status from Email List Validation carries real-world meaning. A valid result means the address is accepted by the receiving server and likely deliverable. An invalid address means it fails basic syntax checks or no domain exists. A catch-all account accepts all messages, even for fictitious users—this can lead to high bounce rates or spam complaints. A risky status typically indicates temporary issues like greylisting, high volume, or a blacklisted IP, and should trigger a delay or manual review before sending.

For detailed verification workflows, consider using the Email List Validation real-time API for on-demand checks or bulk verification to clean entire lists before campaigns. Both options help minimize delivery issues and protect sender reputation. See how the API integrates with Lambda for real-time validation in your workflows.

Handle different verification verdicts in your Lambda function

You can route each email verification result from your AWS Lambda function based on its status—valid emails go to your clean list or CRM, invalid ones get suppressed immediately, catch-all emails are flagged for review, and risky ones go into quarantine for manual assessment. This reduces bounces, protects sender reputation, and keeps your list healthy.

Map verdicts to actions

If verification_status is valid, persist the email to your primary contact database or send it to a CRM like HubSpot or Salesforce via their API.
When the status is invalid, remove the email from all mailing lists immediately and add it to a suppression list to prevent future delivery attempts.
If the status is catch-all, flag the email for manual review. These often indicate role accounts (e.g., [email protected]) or shared mailboxes that may not be personally managed.
For risky results—common with disposable domains, high-risk TLDs, or recently created accounts—queue the email for delayed delivery or store it in a quarantine bucket for later validation.

Use real-time validation for proactive hygiene

Let’s say you’re processing a high-volume list. You can integrate Email List Validation’s real-time verification API directly into your sign-up flow or backend workflow to catch bad addresses early. This prevents them from ever hitting your send queue.

According to an industry report by Return Path, consistently removing invalid emails reduces bounce rates by up to 40%—a key factor in maintaining good sender reputation. Return Path data shows that high bounce rates correlate strongly with inbox placement failures.

You can also bulk-validate existing lists using our bulk email list cleaning tool. It handles thousands of emails at once and returns detailed verdicts—valid, invalid, catch-all, risky—so you can act on each in real time.

Store results securely and scale with event-driven architecture

You can securely store email verification results in DynamoDB with each record including the email address, verification status, timestamp, and metadata like source or validation type. Use Lambda’s event-driven setup to trigger processing on every incoming webhook, letting it scale automatically—each verification event spawns a new instance without manual provisioning. Costs are tied strictly to execution time, typically around $0.000016 per 100ms, making it cost-effective at scale.

Build a durable, queryable data layer with DynamoDB

DynamoDB works well for storing verification outcomes because it’s serverless, low-latency, and fully managed. Each verification result can be saved as an item with a unique key (like the email address) and attributes for status (valid, invalid, catch-all, etc.), timestamp, and any additional metadata your system needs. You can query results by date, status, or domain, making it easy to audit deliverability trends or debug bounce issues.

For compliance or long-term analysis, consider copying logs and full results to Amazon S3. This gives you durable storage with versioning and retention policies. It’s common practice in regulated environments to retain verification data for months or years; S3 makes that feasible without locking up your Lambda or DynamoDB resources.

Scale automatically with no infrastructure tuning

When you set up Lambda to respond to incoming webhooks from an email verification service, each event triggers a new function instance. There’s no need to pre-scale, monitor load, or adjust concurrency settings. AWS handles cold starts and scaling transparently—whether you run 10 or 10,000 verifications per day, Lambda adapts instantly.

This event-driven model is standard in modern serverless architectures and is documented in AWS’s own best practices for building scalable applications. The model reduces latency, cuts maintenance overhead, and aligns with industry standards for processing asynchronous data streams. You’re not just running code—you're building a resilient, self-adjusting pipeline.

For example, if you’re using the Email List Validation real-time verification API to validate inbound leads, each response can trigger Lambda to store the result, update your CRM, or send a notification. The same setup works for bulk lists processed via bulk email list cleaning. The architecture scales from one test to millions of addresses with no change in configuration.

Cost remains predictable: you pay only for compute time, not for idle capacity. This makes it practical to verify large, dynamic lists without worrying about over-provisioning. It’s a core reason why event-driven architectures like this dominate modern data pipelines.

How to test and validate your webhook integration

Send a test email from a disposable domain through the Email List Validation API and confirm your AWS Lambda function receives the event, logs the payload correctly, and handles errors with retries. Use CloudWatch to inspect execution details and simulate failure scenarios to verify resilience.

Set up a known test case

Submit a known valid test email (like [email protected]) via the Email List Validation API. This domain is commonly used for testing because it reliably returns a valid status.
Ensure your webhook endpoint in AWS Lambda is properly configured and deployed. The API should send a POST request to your function’s URL when verification completes.
Trigger the verification and monitor your Lambda function’s execution logs in Amazon CloudWatch. This is where you’ll see the raw event payload delivered from the API.

Verify delivery and error handling

Check the CloudWatch logs for the HTTP status code returned by the Lambda function. A 200 response confirms successful receipt. Any 5xx status indicates the webhook will be retried.
Inspect the payload body. It should include the email address, verification verdict (e.g., "valid"), and timestamp. Use the integration dashboard to ensure the response format aligns with your expected schema.
Modify your Lambda function to return a 500 error on purpose. This simulates a temporary failure during processing.
Re-run the same test email verification. Confirm the API retries the webhook delivery, as per industry-standard practices for reliable messaging. The email verification service uses a backoff strategy—typically exponential—consistent with RFC 7231’s definition of 5xx status codes, which imply temporary failure and demand retry.
After fixing the function, run the test again and ensure the event is processed only once, not duplicated. This confirms idempotency is maintained.

You’re now confident your integration is resilient and correctly receives status updates. Use this process before scaling to production lists to avoid silent failures in delivery pipelines.

Final thoughts: Automating email hygiene with Lambda and verified results

Processing email verification results via AWS Lambda with webhooks ensures your system acts on real-time data, eliminating outdated or invalid addresses before they impact delivery.

By automating this step, you reduce bounce rates, maintain a strong sender reputation, and improve inbox placement—critical factors in sustained deliverability.

With Email List Validation’s 98.9% accuracy, you can trust the verdicts driving your automation, turning verification from a one-time task into a continuous hygiene process.

Keep reading

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

Frequently asked questions

Can AWS Lambda handle high-volume email verification webhooks?

Yes. Lambda scales automatically to handle thousands of concurrent verification events, making it ideal for bulk list processing with predictable cost.

What happens if my Lambda function fails to respond to a webhook?

Email List Validation retries delivery up to three times with increasing delays. If all retries fail, the event is logged and may be re-sent later depending on system configuration.

How do I ensure my Lambda endpoint is secure?

Use AWS WAF and API Gateway with custom authorization (e.g., API keys or Lambda authorizers) to prevent unauthorized access to your webhook endpoint.

Can I use Email List Validation’s webhook with other tools besides Lambda?

Yes. Webhooks can be delivered to any HTTPS endpoint, including web apps, third-party data pipelines, or logging services, not just AWS Lambda.

What fields are included in the webhook payload?

Each payload includes email address, verification_status (valid, invalid, catch-all, risky), timestamp, and optional metadata like source or campaign ID.

Does Email List Validation support signed webhooks?

Currently, signed webhooks are not available. We recommend validating the source IP using API Gateway or using server-side authentication for secure endpoints.

How accurate is Email List Validation’s verification process?

Our system achieves 98.9% accuracy across all verdict types, using real-time SMTP checks, MX validation, and role account detection.

Can I verify large lists using webhooks?

Yes. Webhooks stream results in real time during bulk verification. The integration remains stable regardless of list size.

What happens to disposable or temporary emails?

Disposable domains are identified and marked as invalid or risky, depending on the domain’s behavior and reputation.

How do I avoid sending webhooks to the wrong endpoint?

Always test your webhook URL using Email List Validation’s built-in test button before enabling it for production verification jobs.

Do I need to pay extra for webhooks?

No. Webhook delivery is included with all Email List Validation plans at no additional cost.

Can I use this setup with Mailchimp or SendGrid integrations?

Yes. Webhook output can feed into CRM systems like HubSpot, or be used to sync cleaned lists to Mailchimp and SendGrid via their APIs.