Webhook Bounce Processor for Amazon SES & MongoDB

Why Bounce Processing Is Still a Critical Part of List Hygiene

You send a campaign. Metrics look good. Open rates are solid. Then you check your inbox placement — and it’s dropping. Your sender reputation is down. You’ve started getting flagged by ISPs. Not because your content is bad, but because your list still contains dead addresses.

Email bounces — hard and soft — aren’t just errors. They’re signals. Each one harms deliverability. Ignoring them is like letting rust spread on a car’s chassis. It doesn’t stop until the whole thing fails.

Creating a webhook-based bounce processor for Amazon SES and MongoDB is how you turn those signals into action. It’s not optional. It’s the foundation of a clean, reliable list. You’ll see fewer bounces, better sender reputation, and consistent inbox placement — all from a simple, automated process that runs in the background.

Key takeaways

A webhook-based bounce processor automatically removes hard-bounced addresses from your list, reducing sender reputation risk.
Processing bounces from Amazon SES in real time prevents accumulation, which lowers blocklist exposure.
Storing bounce data in MongoDB allows for historical analysis and proactive list hygiene beyond just deletion.

Can You Rely on Amazon SES Bounce Notifications Alone?

You cannot rely solely on Amazon SES bounce notifications for effective email list hygiene. While SES delivers bounce data via SNS, it doesn’t classify failures as temporary or permanent by default. Without a custom processor, you risk retrying deliverable addresses or leaving invalid ones in your system. This leads to wasted sends, poor sender reputation, and potential inbox placement issues.

Why SES Bounces Alone Aren't Enough

Amazon SES sends bounce notifications through SNS, but the raw data often arrives without clear context. For example, a "user unknown" bounce might indicate a temporary issue on the recipient’s end, or it could mean the email is permanently invalid. Without parsing and classifying these reasons, you can’t decide whether to retry, pause, or remove the address.

Let’s be clear: a bounce is just one piece of the puzzle. The actual bounce reason — like "mailbox unavailable", "no such user", or "550 5.1.1 User unknown" — needs to be mapped to a specific action. A temporary failure (like a full inbox) might warrant a retry after a delay. A permanent one (like a typo-ridden address) should be removed immediately. Relying only on SES’s raw output means you're making guesses instead of decisions.

Processing Bounces at Scale Requires a Custom System

If you’re sending at scale, you need a webhook-based processor to consume SNS messages, analyze the bounce reason, and act on it. This could mean flagging addresses for soft bounce retry, siloing hard bounces for removal, or logging for auditing. Without this, you’re leaving your deliverability to chance — a recipe for poor inbox placement.

And here's the reality: most email providers, including AWS, only provide the raw signal. It’s up to you to interpret it. According to the IETF’s RFC 5321, bounce codes are meant to guide handling — but only if you read them.

You can build this system yourself, but it’s non-trivial. You’ll need to manage SNS subscriptions, parse raw MIME messages, store state in a database like MongoDB, and handle retry logic. If you’re already using tools like bulk verification or real-time API verification, you’re already ahead — a well-verified list reduces bounces before they happen.

The key takeaway: SES gives you data, but not intelligence. Your processor turns that data into action. Without it, your list degrades, your reputation suffers, and your emails don’t reach inboxes.

How a Webhook-Based Processor Works in Practice

When Amazon SES detects a bounce, it sends an SNS notification to a webhook endpoint you’ve configured. Your server receives the message, extracts the email address and bounce type, then logs that data into a database like MongoDB. From there, you can act immediately—removing invalid addresses, pausing campaigns for transient bounces, or flagging role or disposable emails, all without manual intervention. You’re not waiting for a daily report or a batch process. The moment a bounce hits, the system responds. This real-time handling prevents wasted sends, protects sender reputation, and keeps your inbox placement stable. It’s not just automation—it’s a proactive defense against deliverability risks.

Amazon SES sends bounce notifications via SNS in a structured JSON payload. The message includes the original recipient email, the bounce type (permanent, transient, or unknown), and details like the SMTP error code. Your server must be configured with an HTTPS endpoint that accepts these payloads, usually behind a reverse proxy or API gateway. You can use AWS Lambda, a Node.js server, or a lightweight Go service to handle the incoming request. The first step is validation: ensure the message is signed correctly and comes from Amazon SES. This is a critical security layer—without it, you risk accepting forged notifications. Once validated, parse the JSON. Focus on the `notificationType` field (which should be `Bounce`), then inspect `bounceType`, `bounceSubType`, and `bouncedRecipients`. These fields tell you whether the failure is permanent (e.g., "Undeliverable" or "No such user"), temporary (like "Message Too Large" or "Mailbox Full"), or unclear.

Logging and Triggering Workflows

With the data extracted, write to your MongoDB collection. Store the email, bounce type, sub-type, date, and the raw SNS message for audit and debugging. This log becomes your single source of truth for email health. Now, use those fields to trigger workflows. For permanent bounces (like "550 5.1.1"), remove the email from your list. For transient bounces (such as "421 4.2.1"), delay the retry logic for a time window—say, 24 hours—before retrying. You can also detect pattern-based risks. Role accounts (like admin@ or sales@) or disposable domains (like tempmail.com) should rarely be active in transactional workflows. Tools like bulk verification can help identify these before they’re even sent. The best setups use this data not just to clean lists, but to report on performance. Tracking bounce rates by campaign, region, or user segment is standard in deliverability best practices. According to RFC 6522, email delivery failures should be handled with precision—especially when they impact sender reputation. You’re not just reacting—you’re building a system that learns, adapts, and prevents future failures. This is how reliable email delivery becomes scaleable.

You need an SNS topic to receive bounce notifications from Amazon SES, a verified HTTPS endpoint (like AWS Lambda) to process them, and a MongoDB collection to store bounce metadata like email, timestamp, and bounce type. This setup ensures you react to bounces in real time, maintain list health, and avoid sender reputation issues. Let’s walk through it step by step.

Create an SNS topic in the AWS Console and name it something like ses-bounce-notifications. This topic acts as a central hub for all bounce and complaint messages from SES.
Subscribe your HTTPS endpoint to the topic—this can be a Lambda function, a server, or any publicly accessible HTTPS URL. AWS will send POST payloads to this endpoint whenever a bounce occurs. Ensure your endpoint validates the message signature using Amazon’s SNS verification process, as required by SNS message signing guidelines.
Enable delivery status notifications in your SES configuration set. Attach it to your sending workflow so every email sent via SES includes bounce and complaint feedback in the notifications.

Store Bounce Events in MongoDB

Set up a MongoDB collection named bounce_events with a schema that stores: email, timestamp, bounce_type (soft/hard), error_code, and message_id. Use indexes on email and timestamp for fast lookup and cleanup.
Parse the incoming SNS payload in your endpoint. Extract the Message field, which is a JSON string containing details like the original recipient and bounce reason. Validate the message using the SignatureVersion and SigningCertURL fields to prevent spoofing.
Log each bounce event to MongoDB with a unique message_id to avoid duplicates. Use upsert operations to update existing records if needed, and include the feedback_id from the bounce message for traceability.

With your infrastructure in place, every bounce is logged in minutes. Over time, this data helps you identify problematic domains, filter out invalid addresses, and maintain a healthy sender reputation. For example, repeatedly soft-bouncing an address likely indicates a temporary issue—consider delaying retries. Persistent hard bounces signal invalid or dead emails, which should be removed immediately.

Detecting and acting on bounces isn’t just about avoiding blocklists; it’s about protecting your deliverability. A high bounce rate can trigger AWS SES throttling or even suspension. Tools like bulk verification help you preemptively clean your list before sending, reducing bounce risk at the source.

How to Classify Bounce Reasons Using Simple Logic

You can classify bounce reasons by parsing the SMTP response codes and messages from Amazon SES. Hard bounces (5xx codes) mean the email address is invalid and should be removed. Soft bounces (4xx codes) indicate temporary issues like full mailboxes or rate limiting—you can retry once, then escalate if it persists. Network-related bounces should trigger a delay-based retry queue. This logic prevents wasted sends, improves deliverability, and keeps your list clean.

Hard Bounces: Immediately Remove

Any bounce with a 5xx response code (e.g., 550 5.1.1 User unknown) indicates a permanent failure.
These addresses are invalid—never retry them. Mark them as invalid in your database.
Removing these prevents reputation damage and keeps your sender score healthy.
For reference, RFC 5321 defines 5xx codes as permanent failures. See RFC 5321, Section 4.2.1 for SMTP status code semantics.

Soft Bounces: Retry or Escalate

Soft bounces (4xx codes) like 450 4.2.2 Mailbox full signal temporary issues.
Let’s say you retry once after 24 hours. If the same error persists, escalate to permanent removal.
Rate-limiting bounces (e.g., 421 4.7.0 Service unavailable) should be queued with exponential backoff.
Don’t retry the same address during a high-volume sending window—delay and track retries carefully.
Amazon SES itself provides delivery metrics that help detect repeated soft bounces. Use the AWS SES documentation to understand how SES reports delivery outcomes.

If you’re managing a large list, preprocessing it before sending reduces the number of bounces at scale. For high-accuracy, automated list cleaning, consider bulk verification tools like EmailListChecker’s bulk verification, which identifies invalid or risky addresses before they cause bounces. You can also use our real-time verification API to validate addresses at point of entry. This reduces the load on your bounce processor and improves overall deliverability.

Integrating Email Verification to Prevent Future Bounces

Before you send emails via Amazon SES, run a bulk verification on your list using a tool like Emaillistchecker.io. This checks each email in real time for validity, catch-all status, or risk factors, returning clear verdicts so you can remove invalid and risky addresses before sending. Doing this cuts hard bounces at the source and protects your sender reputation.

How Real-Time Verification Works

When you send a list to Emaillistchecker.io’s bulk verification API, it checks each email against SMTP servers, domain records, and known disposable patterns. You get back verdicts: valid (ready to send), invalid (undeliverable), catch-all (may accept any address, but not a real person), risky (likely spam trap or temporary), or disposable (short-lived inbox).

These signals are not guesses. They come from active connection attempts and pattern matching—just like how email providers validate addresses before accepting delivery. The SMTP spec defines how servers react to invalid addresses; verification services mimic that process at scale, so you see the same result without sending.

What to Do With the Results

After verification, filter out invalid and risky emails. These are the ones that will bounce when sent through Amazon SES. Catch-all domains can still be used, but they often correlate with low engagement and higher spam complaints. Disposable emails are a red flag—most users with them aren’t serious prospects.

Let’s say your list has 10,000 emails. A third of them might fail verification. Removing those before sending cuts your bounce rate by 30–40% overnight. That matters: high bounce rates can trigger Amazon SES throttling or even suspension.

Use the API to automate this step in your workflow. Integrate it with your app or CRM. Every time you add a new contact, validate it before it gets into your send queue.

Even better: run a full list clean before every campaign. Keep your database lean. It’s not about perfection—it’s about reducing noise. That’s how you keep your domain’s reputation clean. A good sender reputation means better inbox placement, higher deliverability, and longer-term reliability with services like Amazon SES.

Using Emaillistchecker.io to Improve Bounce Data Quality

You can cut bounce rates by up to 70% by verifying your email list before sending through Amazon SES. Tools like Emaillistchecker.io catch disposable domains, role accounts, and malformed addresses before they hit your sending infrastructure, reducing invalid sends and protecting sender reputation. This proactive step ensures your bounce processor only handles truly undeliverable addresses, not preventable failures.

Pre-Send Verification Reduces Bounce Load

Let’s be honest—sending to a bad list is like sending mail to a ghost town. Amazon SES will reject invalid addresses, but you still pay for the attempt. With Emaillistchecker.io, you catch those issues before they ever reach SES. You can use the real-time API for individual checks or bulk upload your entire list using the bulk verification tool. Either way, the system validates syntax, checks domain presence, and flags risky patterns.

The process isn’t just about catching typos. It identifies email addresses from disposable domains (like temp-mail.org), role-based accounts (admin@, sales@), and domains that block mail altogether. These are high-risk sends that don’t just bounce—they hurt deliverability over time. According to industry data from Return Path, emails from role accounts have a significantly lower inbox placement rate than personal addresses.

Accuracy That Actually Matters

Emaillistchecker.io delivers 98.9% accuracy in identifying invalid or risky emails. That means for every 1,000 addresses you verify, only about 11 are misclassified. This level of precision translates directly into lower bounce rates and better sender reputation scores. When your bounce processor runs on clean data—only real, undeliverable addresses—it becomes a reliable signal of actual delivery issues, not list quality problems.

Using this verified data, your webhook-based bounce processor can distinguish between temporary failures (like rate limits) and permanent failures (like non-existent domains). This allows you to refine your suppression logic, avoiding unnecessary hard bounces and reducing the risk of being flagged by blacklists like Spamhaus.

With tools like Emaillistchecker's real-time API integrated into your workflow, you can verify list entries on the fly—during sign-up, during segmentation, or before campaign send. This continuous hygiene is how top-tier senders maintain high inbox placement and low bounce rates.

How to Automate List Cleansing with MongoDB

You can automate email list cleansing by setting up a scheduled job that pulls hard bounce records from Amazon SES over the past 30 days, checks them against your MongoDB subscriber database, and removes any matching entries. This keeps your list accurate, improves deliverability, and reduces the risk of being flagged by ISPs. The process works because hard bounces indicate permanently invalid addresses—leaving them in your list hurts sender reputation and increases the chance of being blacklisted.

Set up the daily or hourly check

Use AWS CloudWatch Events or a cron job on your server to trigger a script every hour or day.
Query Amazon SES’s Bounce and Complaint APIs for messages marked as "Hard Bounce" in the last 30 days.
Store the list of bounced email addresses in memory, filtered by domain and timestamp, to avoid duplicate processing.
For reliability, ensure the script handles intermittent AWS failures with retry logic and logging.

Sync with your MongoDB subscriber list

Connect to your MongoDB database and query all active subscribers from the past 30 days.
Use an efficient EMAIL field index (or compound index on email + status) to speed up the lookup.
Compare each bounced address against your subscriber list to find matches—this is typically a set intersection operation.
Remove any matched records from your database with a DELETE operation that preserves audit trails.
Update the status field on the remaining records to reflect that the list has been cleansed, or use a separate field like is_bounced to flag the user’s status.

Many email service providers, including Amazon SES, define a hard bounce as a message rejected by the recipient server due to an invalid address—this is a known signal of poor deliverability. According to industry best practices, removing hard-bounced addresses within 30 days helps maintain a healthy sender reputation. You can read more about AWS’s bounce management at the Amazon SES documentation.

The 4 steps described in “Set up the daily or hourly check”, in order.

For teams aiming to prevent bounces before they happen, consider integrating real-time verification. Emaillistchecker.io’s bulk verification tool can check large lists ahead of sending and identify risky or invalid addresses before they hit your campaign, reducing bounce rates at the source.

Keeping your email list clean isn’t optional—it’s a core part of maintaining a good sender reputation.

For developers building automated systems, the EmailListChecker API can be used to integrate verification into your workflow, validating new signups or batch lists programmatically. This complements your webhook-based bounce processor by reducing the number of invalid addresses entering the system in the first place.

Monitoring Health: Real-Time Dashboards and Alerts

You can track bounce trends in real time by aggregating Amazon SES bounces in MongoDB, then visualizing daily volume, hard/soft ratios, and domain-level behavior. Simple dashboards show anomalies fast—like a sudden spike in hard bounces from a specific domain—so you fix problems before they hurt deliverability. For immediate insights, build alerts that trigger when any list exceeds a 0.5% bounce rate. These signals help catch list decay or misconfigured campaigns early.

Aggregating Bounce Data with MongoDB

Use MongoDB aggregation pipelines to group bounce events by domain, sender email, or campaign ID. This reveals patterns like consistent failures from one domain or recurring soft bounces from a specific sending list.
Apply $group and $match stages to calculate daily bounce volume and split it into hard vs soft categories using the bounce type field from Amazon SES notifications.
Store the results in a dedicated monitoring collection, indexed by domain and date. This makes queries fast and supports real-time dashboard rendering.
Use the $facet stage to run multiple, parallel aggregations—e.g., total bounces, hard bounce rate, and domain-level spikes—with one query.
For scalability, consider sharding the monitoring collection across multiple nodes if you're processing more than 100K daily events.

Setting Up Early Warning Systems

Define a rule: if the hard bounce rate exceeds 0.5% for any sender, campaign, or domain within a 24-hour window, trigger an alert. This threshold is commonly used in email deliverability best practices to detect list quality issues early.
Integrate with tools like AWS CloudWatch or third-party alerting systems (e.g., PagerDuty, Slack) using webhooks from your alert processor.
Use MongoDB’s change streams to monitor the verification collection in real time. When a new bounce record arrives, validate it against known filters—such as disposable domains or role accounts—before raising an alert.
Let’s say a domain suddenly shows 120 hard bounces in one hour. The system should flag it and auto-reject future sends to that domain unless validated. This stops wasted sends and protects sender reputation.
Review and refine thresholds based on industry benchmarks—high-volume senders may find 0.5% too aggressive; smaller lists may use 1% if they have lower volume.

Preventing bounces before they happen is better than reacting to them. Use list hygiene tools like bulk email verification to catch invalid addresses before sending. Combine that with real-time bounce monitoring and you’re not just reacting—you’re maintaining list health proactively.

How Webhook Processing Fits Into a Broader List Hygiene Strategy

You don’t replace list hygiene with a webhook processor—you layer it on top. Pre-verification cleans your list before sending, reducing bounces from invalid or disposable addresses. Then, real-time webhook processing catches what escapes: inactive accounts, role-based emails, or domains that changed. Together, they keep your sender reputation strong, inbox placement high, and your list trustworthy over time.

Verifying Before You Send Is the Foundation

Let’s be clear: no webhook can fix a list full of fake or mistyped emails. That’s why you start with bulk verification. Tools like EmailListChecker’s bulk verification scan your entire list against SMTP, MX, and domain rules to flag invalid, catch-all, or disposable emails before you send. This step alone can cut bounce rates by 70% or more in email marketing campaigns.

It’s not about perfection—it’s about probability. Even the cleanest list will include a few outdated or closed accounts. That’s where the webhook step takes over. After sending via Amazon SES, you receive event notifications for hard bounces, soft bounces, or unsubscribes. You process these events in real time, updating MongoDB to remove or archive those records.

Why Combining Both Works Better Than Either Alone

Think of pre-verification as a sieve. It stops most bad data from entering the pipeline. The webhook is your error detection system—catching only the slips that slip through. Without verification, your webhook process is reactive and inefficient. You're cleaning up after bad sends. With verification, you reduce the cleanup load and focus on long-term list health.

For example, a subscriber may have an address that passes initial validation but later gets deactivated. If they’re on a role account like [email protected], even if the domain is valid, the address isn’t used. Verification tools can flag those as risky, while webhooks later confirm whether messages are being rejected or deferred. RFC 6409 outlines best practices for email delivery, emphasizing that reputation is built on consistency and low bounce rates—both of which you maintain with this dual-layered approach.

And yes, this works across platforms. Whether you're using Amazon SES with a MongoDB backend or another combo, the principle stays the same. You verify early, process bounces real-time, and keep your sender ID respected. It’s not about speed—it’s about precision, sustainability, and trust. Use your webhook to monitor, not to rescue. Let your pre-send checks do the heavy lifting.

Conclusion: Turn Bounce Data Into a Systematic Advantage

Bounces are not just errors—they are signals. Each one reveals something about deliverability, list health, or sender reputation. Ignoring them means missing opportunities to improve engagement and reduce costs.

A webhook-based bounce processor using Amazon SES and MongoDB turns raw failure data into structured insights. You can flag invalid addresses, detect pattern shifts, and trigger cleanup workflows—automatically and at scale.

When combined with pre-send verification tools like Emaillistchecker.io, you gain both prevention and remediation. Clean data at the gate, real-time feedback in motion. Together, they form a system that reduces bounces, improves inbox placement, and strengthens sender reputation.

Sources

The average email bounce rate across all industries is 2.48%, based on combined Mailchimp and Campaign Monitor data covering more than 30 billion emails. — WebFX (Mailchimp & Campaign Monitor data) (2026)
Mailchimp's platform-wide data puts the average hard bounce rate at just 0.21% and the soft bounce rate at 0.70%, meaning well-maintained lists bounce under 1% in total. — Verified.email (Mailchimp data via Mailerio) (2025)

Keep reading

Ready to put this into practice? Emaillistchecker.io verifies emails with 98.9% accuracy — start with 100 free verifications.

Frequently asked questions

What is a webhook-based bounce processor?

It’s a server-side system that listens to Amazon SES bounce notifications via SNS, analyzes the bounce type, and updates your database to remove or manage invalid email addresses.

Why use MongoDB with Amazon SES bounce processing?

MongoDB stores the structured bounce data efficiently and enables flexible querying, making it easy to track trends, generate reports, and automate cleanup.

Can I use Emaillistchecker.io with Amazon SES?

Yes—use Emaillistchecker.io to verify your list before sending with Amazon SES. This reduces bounces at source and improves overall deliverability.

What’s the difference between hard and soft bounces?

Hard bounces (e.g., invalid address) mean the email is permanently undeliverable. Soft bounces (e.g., full mailbox) are temporary and may resolve with retry.

How often should I process bounce data?

Daily processing is sufficient for most use cases. For high-volume senders, process in real time or every few hours to keep list quality high.

Does Emaillistchecker.io support bulk verification?

Yes—its bulk verification feature allows you to upload large lists and process them in batches with 98.9% accuracy.

What types of email addresses does Emaillistchecker.io detect?

It identifies invalid, catch-all, disposable, role-based, and risky emails. It also flags domains known for high bounce rates.

Can I integrate Emaillistchecker.io with Mailchimp or SendGrid?

Yes—the service offers native integrations with Mailchimp, SendGrid, HubSpot, and Klaviyo, allowing seamless list verification before campaign send.

Do purchased credits on Emaillistchecker.io expire?

No—your purchased credits never expire, so you can use them at your own pace without time pressure.

How accurate is Emaillistchecker.io’s real-time API?

The platform achieves 98.9% accuracy in verifying email addresses in real time, based on continuous validation across SMTP, DNS, and domain checks.

What happens if an email is marked as 'catch-all'?

Catch-all addresses accept all incoming mail, making them high-risk—messages may be delivered but are often ignored. Remove them from campaigns.

How does a webhook processor improve sender reputation?

By removing invalid addresses and reducing bounce rates, you signal to ISPs that your sends are intentional and legitimate, helping maintain a strong sender reputation.