Mailgun Integration Tutorial for Email Verification in Ruby on Rails

Why verify emails before sending with Mailgun in Rails?

You’ve hooked a lead with a great sign-up form. They enter their email. You fire off a welcome message via Mailgun. Then—silence. No open. No click. Just a hard bounce report buried in your logs.

That’s not a bad user. That’s a bad email. And Mailgun’s SMTP service won’t stop you from sending to it. It only tells you after the fact.

Without pre-send verification, you’re gambling on address validity. Invalid addresses cause hard bounces. Hard bounces hurt your sender reputation. And a damaged reputation means lower inbox placement—even for good emails.

That’s why every Rails app using Mailgun should verify emails before sending. It’s not an optional step. It’s the difference between consistent delivery and wasted sends.

A simple email verification step—before Mailgun ever sees the address—catches typos, disposable domains, and invalid formats early. You reduce bounce rates. You preserve your sender reputation. You improve deliverability over time.

Key takeaways

• Mailgun’s SMTP does not validate email addresses during transport—verification must happen upstream.
• Hard bounces from invalid emails degrade sender reputation and reduce inbox placement over time.
• Proactively filtering bad addresses in your Rails app significantly lowers bounce rates and improves long-term deliverability.

How does email verification work in a Rails app with Mailgun?

You verify email addresses before sending them through Mailgun by checking syntax, domain validity, mailbox responsiveness, and risk signals like disposable domains using a real-time API. This happens early in your Rails app’s flow—before any SMTP or API call—to prevent bounces, protect sender reputation, and improve inbox placement.

Pre-send validation with real-time checks

Before Mailgun ever sees an email address, your Rails app makes a real-time API call to verify it. This process isn’t just about catching typos; it checks whether the domain exists, if the mail server is reachable, and whether the mailbox accepts incoming messages. Services like RFC 5321 define the standard SMTP behavior that these checks are based on.

It also flags risk factors—like temporary or disposable email domains—that often lead to poor engagement or spam complaints. For example, domains ending in mailinator.com or 10minutemail.com are known to be high-risk for delivery and engagement.

Clear verdicts shape your sending strategy

The API returns a verdict for each address: valid, invalid, catch-all, or risky. A valid email means it’s syntactically correct, the domain exists, and mail delivery is likely. An invalid address is a hard fail—you should remove it from your list.

Catch-all domains accept all emails sent to them, even invalid addresses, so sending to them is unreliable. Risky emails come from disposable or temporary providers—often used for account signups but rarely engaged with. These can harm your sender reputation if you send to them at scale.

You’ll want to filter out invalid and risky addresses before hitting Mailgun. For bulk list validation, tools like EmailListChecker’s bulk verification handle thousands of emails efficiently. Or for real-time integration in your Rails app, the real-time verification API fits seamlessly into user registration, order forms, or email list imports.

What’s the best way to integrate email verification with Mailgun in Rails?

You should verify each email address in real time using Emaillistchecker.io’s API before sending it through Mailgun. This prevents bounces, protects your sender reputation, and improves inbox placement. Let’s walk through the best setup step by step.

Set up the verification middleware

1. Install the Emaillistchecker.io Ruby gem and configure your API key. This gives you direct access to a service designed for high-accuracy, real-time email validation. It checks syntax, domain existence, MX records, and catch-all responses.
2. Before queuing any email with Mailgun, send the address to Emaillistchecker.io’s API. This returns one of several verdicts: valid, invalid, catch-all, or risky. Only proceed with valid addresses.
3. Cache the result in Redis or your app’s local store. If the same email comes in again within a short window—say, 24 hours—you skip the API call. This reduces latency and API costs without sacrificing accuracy.
4. Filter invalid and risky addresses early. Rejecting bad emails before Mailgun processing means fewer failed deliveries, fewer bounces, and less risk of appearing on blocklists like Spamhaus.
5. Queue only valid addresses through Mailgun. This keeps your email volume clean and maintains a healthy sender score. High bounce rates are one of the top reasons for inbox placement failure.

Why this setup works

Mailgun enforces sender reputation via metrics like bounce rate and spam complaints. Sending to invalid addresses increases bounces, which can trigger throttling or blacklisting. By validating first, you avoid that risk. This is consistent with industry best practices—RFC 5321 defines how mail servers should respond to invalid recipients, and services like SendGrid and Amazon SES also recommend verification before delivery.

For teams using bulk list imports, Emaillistchecker.io also offers bulk verification, which checks thousands of emails in minutes. You can import a CSV, get results, and clean your list before any Mailgun send. Their real-time API integrates smoothly into Rails models via HTTP requests or background jobs.

This method is not just about eliminating bad data—it’s about building a sustainable outreach system. Over time, your deliverability improves because you’re not penalized for sending to non-existent or abusive addresses.

How to set up the Emaillistchecker.io API in a Rails application

You can integrate Emaillistchecker.io into your Ruby on Rails app by signing up for an API key, adding the httparty gem, creating a service class, and using Net::HTTP or Faraday to make POST requests to the verification endpoint. The API returns verdicts like valid, invalid, or catch-all, along with risk scores and error details — which helps you filter out dead or high-risk emails before sending.

Get your API key and prepare the environment

1. Go to emaillistchecker.io and sign up. Once registered, navigate to your dashboard to view your API key. This key authenticates every request to the verification service, so keep it secure and never expose it in client-side code.
2. Add the httparty gem to your Gemfile and run bundle install. While Net::HTTP is built-in, httparty simplifies JSON handling and request formatting — a common convenience in Rails apps. If you prefer raw HTTP, Faraday is a robust alternative.

Build the verification service

3. Create a service class, such as EmailValidatorService, in app/services/email_validator_service.rb. This isolates email verification logic from your controllers, keeping your app clean and testable.
4. Use Net::HTTP or Faraday to send a POST request to https://api.emaillistchecker.io/v1/verify with your email and API key in the body. The API expects a JSON payload with email and api_key fields. The response is JSON and includes verdict, risk_score, and error fields, which you can inspect to determine email validity.
5. Parse the response. If verdict is valid, the email is likely deliverable. A catch-all verdict means the domain accepts all emails — risky for outreach. A invalid verdict means it doesn’t exist. A risk_score above 0.5 suggests the inbox may be unreliable or temporary.

For bulk verification, you can upload lists via the bulk verification tool or use the verification API in a background job. The service scales seamlessly with large lists and integrates with tools like Mailchimp, HubSpot, and SendGrid through the integrations page.

Validating emails early reduces bounce rates and protects sender reputation, a practice recommended by industry standards like those from RFC 5321. High bounce rates signal poor list hygiene to mailbox providers, which can lead to throttling or blocklisting.

Start with 100 free verifications — credits never expire. See pricing and full docs at emaillistchecker.io/pricing.

Understanding Emaillistchecker.io's verification verdicts

You’ll see five key verdicts when verifying emails with Emaillistchecker.io: valid (safe to send), invalid (syntax or domain error), catch-all (domain accepts all mail, but inbox may not exist), risky (disposable, role-based, or spam trap), and unknown (server timed out or blocked verification). These verdicts help you act with confidence, avoid bounces, and protect your sender reputation.

Verdict meanings at a glance

Each verdict reflects a real technical condition. Let’s break down what they mean, based on how email systems behave in practice — including common patterns observed by deliverability experts and outlined in RFC 5321 (SMTP protocol).

Why verdicts matter in Rails and Mailgun

You can integrate these verdicts directly into your Rails app. For example, if an address returns catch-all or risky, skip it during Mailgun sends to avoid poor deliverability. Use the API to validate lists before hitting Mailgun’s transactional endpoints.

Let’s say you’re running a newsletter — sending to risky addresses can hurt your sender reputation. Mailgun uses reputation metrics, and even a few hard bounces from high-risk addresses can trigger filters. Emaillistchecker.io’s 98.9% accuracy helps you avoid that.

How to use Mailgun's webhooks to flag verification failures

You can use Mailgun’s webhooks to catch bounced emails in real time, filter hard bounces (like invalid or expired addresses) using the reason field, and cross-check those failures against prior verifications from Emaillistchecker.io to refine your list hygiene. This helps you stop sending to dead addresses and improves long-term deliverability.

Set up the webhook and filter bounce types

1. Log into your Mailgun control panel and navigate to Webhooks. Create a new webhook for the bounce event type. This ensures your app receives notifications any time an email fails to deliver.
2. Configure the webhook to fire only on hard bounces (e.g., 550 5.1.1 from RFC 5321) and, if needed, also soft bounces. Hard bounces indicate permanent delivery failure and should be flagged immediately in your system.
3. Mailgun includes a reason field in the webhook payload. Values like unknown-user, mailbox-does-not-exist, or expired directly signal an invalid or expired address. You can use this to determine whether the address was already invalid before sending.

Cross-reference with prior verification data

4. When a bounce occurs, retrieve the email address from the webhook and look it up in your historical verification log. If you previously verified it via Emaillistchecker.io’s real-time API or bulk verification service and it was marked valid, you now have a signal that something changed — possibly a DNS record update or account closure.
5. If the prior verdict was invalid or catch-all, but the address was still sent to, you’ve caught a logic gap in your list filtering. This helps you audit whether your verification thresholds were too permissive.
6. Store all bounce events, including the original verification status, the reason, and the timestamp. Use this data to review list hygiene trends over time and adjust your verification thresholds.

Over time, you’ll identify patterns — like a spike in expired bounces after three months — which suggests your list retention policy needs tightening. This real-time feedback loop is a powerful way to maintain sender reputation, especially since email providers like Google and Microsoft use bounce rates to assess sender trust. RFC 5321 defines standard bounce codes, so using them in logic ensures interoperability.

For teams running large campaigns, this process becomes part of a broader inbox placement strategy. You can use the inbox placement testing feature to validate whether your cleaned lists actually reach inboxes after implementing this webhook logic.

Real-world example: email verification pipeline in a Rails app

You’re building a Rails app where users sign up with an email. When they submit, you verify the email in real time using an API like Emaillistchecker.io’s verification API. If valid, create the user and send confirmation. If invalid, reject with a clear message. If risky or catch-all, apply business logic: defer to admin or allow send under rules. This pipeline stops fake signups, improves deliverability, and reduces bounce rates — all without slowing the user experience.

How the verification pipeline works in practice

1. User submits an email on the frontend. The form sends the input to a Rails controller via a POST request. No validation is done yet — this is only the first step in a trusted verification flow.
2. The controller calls the verification service. It forwards the email to EmailValidatorService.verify(email), which uses a verified API key to query a real-time email validation engine. This step happens synchronously during signup, but you can queue it for scalability.
3. Service returns a verdict: valid, invalid, risky, or catch-all. Each response has a specific meaning: valid means syntax, domain, and mailbox existence checks passed. invalid indicates format errors or known disposable domains. risky flags possible temporary or role-based addresses. catch-all means the domain accepts all emails — often spam traps or outdated systems.
4. Valid → create user, send confirmation. The email is trusted enough to proceed. You create the user in the database and send the confirmation email. This reduces bounce rates linked to invalid addresses.
5. Invalid → reject with clear message. Return a user-friendly message: “Please check the email address and try again.” This stops fake or typographical emails from entering the system, which improves sender reputation.
6. Risky → defer to admin review or suppress immediate send. You can store these emails in a pending queue for manual review. This prevents role accounts (like [email protected]) from becoming inactive or being flagged as low engagement.
7. Catch-all → flag, but allow send if business rules allow. These domains accept any email — a red flag for spam. But in some cases, such as newsletters or support forms, you may still allow send, especially if the user is verified via another method. Monitor these closely.

Why timing and business logic matter

Verifying in real time during signup is effective, but if latency becomes an issue, you can shift to background jobs. A real-time API call is faster than waiting for the user to confirm via link, which reduces drop-off — especially on conversion-critical forms.

Using a service like Emaillistchecker.io’s verification API ensures consistent accuracy across global domains. Their system checks SMTP servers, MX records, and common disposable domain lists. You're not relying on heuristics alone, but on a chain of validated network interactions.

How to handle bulk list verification in Rails using Emaillistchecker.io

You can verify up to 1,000 email addresses at a time using Emaillistchecker.io’s bulk API endpoint. Upload a CSV with one email per row, get back a fully formatted result CSV with verdicts for each address, and store that data in a Rails model for auditing. Regularly clean outdated records to maintain list hygiene, which improves deliverability and sender reputation over time.

Set up the verification workflow

1. Prepare your email list as a CSV file with one email address per row. Ensure the file contains no headers or extra columns—only valid emails.
2. Use the Emaillistchecker.io API to send a POST request to the bulk verification endpoint with your list. The service accepts up to 1,000 emails per request, making it efficient for large-scale cleanups.
3. Receive a structured response containing each email’s verdict: valid, invalid, catch-all, risky, or disposable. This data is returned as a downloadable CSV, ready for import or further processing.
4. Store the results in a dedicated database table, like `email_verification_histories`, with fields for email, verdict, timestamp, and request ID. This enables audit trails and helps track trends in your list quality.
5. Automate regular cleanups using a background job (e.g., via Active Job or Sidekiq) that runs weekly, removing entries marked as invalid or risky. This keeps your list lean and reduces bounce rates.

Optimize performance and compliance

Batching large lists into 1,000-email chunks prevents timeouts and keeps your API usage stable. The system accounts for common delivery issues like greylisting and temporary failures by retrying verification attempts where appropriate, aligning with SMTP best practices defined in RFC 5321.

Consistently maintaining a clean list not only reduces hard bounces but also protects your sender reputation. Industry standards indicate that sending to invalid addresses—even at low volume—can harm deliverability over time. Tools like Spamhaus monitor sender behavior and can flag repeat offenders.

Integrate this flow into your Rails app using a service object or a custom rake task. You can also use the built-in integrations with platforms like Mailchimp or SendGrid to sync verified lists automatically.

For a quick start, try bulk verification with your first 100 emails at no cost. Credits never expire—verify more as your list grows.

Best practices for integrating email verification with Mailgun

You should verify every email before sending to ensure deliverability, especially in high-stakes workflows. Confirm addresses at sign-up, store results, cache them with Redis, and audit accuracy over time. This prevents bounces, protects sender reputation, and reduces latency. The goal isn’t just to filter bad emails—it’s to build a reliable, scalable email system.

Verify early, verify often

• Never send to an email address without prior verification if inbox placement matters—bounced messages hurt sender reputation over time.
• Run verification at point of entry, like during user signup or form submission, to catch invalid or risky addresses before they enter your database.
• Use Mailgun’s API or an external service with real-time validation to check syntax, domain existence, and mailbox responsiveness.
• Store the result (valid, invalid, catch-all, risky) on the user record so you don’t reverify the same address repeatedly.

Optimize performance and reliability

• Set cache headers and use Redis to store verification results for short-term reuse—this cuts API calls and latency, especially during high-traffic events.
• Use background jobs (e.g., Sidekiq or Active Job) to process verifications asynchronously, avoiding response delays in user flows.
• Monitor verification outcomes via audit logs—track false positives, false negatives, and changes in result patterns over time to refine your system.
• Compare your results against known industry benchmarks: according to SMTP.com's 2023 deliverability report, lists with over 2% invalid addresses see significant inbox placement drops.
• For bulk processing, use a tool like Emaillistchecker.io’s bulk verification to preprocess entire lists before integration.

Verification is not optional for maintainable sender reputation. Every undelivered message costs you trust.

When integrating with Mailgun, let the verification flow be part of your application logic—not an afterthought. You’re not just preventing errors; you’re protecting your ability to reach inboxes over time. Use the EmailListChecker API to automate checks with 98.9% accuracy, and pair it with your Mailgun setup for robust, real-time validation.

How does Emaillistchecker.io compare to other verification tools?

Unlike many tools that return only pass/fail results, Emaillistchecker.io gives you detailed risk scores and real-time verdicts—valid, invalid, catch-all, or risky—so you can act on data, not guess. It requires no pre-approval to access its API, unlike some enterprise-grade systems, and works seamlessly with SendGrid and Mailgun through public APIs, making integration faster. With 98.9% accuracy—consistently above basic syntax and DNS check benchmarks—it outperforms tools limited to surface-level validation. You get 100 free verifications with no expiry, perfect for testing in Rails apps or building prototypes.

More Insight, Less Guesswork

While tools like ZeroBounce or NeverBounce focus on binary outcomes, Emaillistchecker.io surfaces nuances. A “risky” verdict tells you a mailbox might be temporary or prone to rejection, not just invalid. This helps reduce spam complaints and improves sender reputation. For developers, knowing why an email failed—whether due to a greylist delay, role account, or disposable domain—lets you build smarter validation flows in Rails.

The difference matters when scaling. One study by Return Path noted that even a 1% improvement in sender reputation can increase inbox placement by 2–5 points. Emaillistchecker.io’s risk layer supports such precision, especially when layered into automated workflows after sending via Mailgun or SendGrid.

Frictionless access and real integration

Other services may require account approval, lengthy onboarding, or custom contracts—common in tools designed for large enterprises. Emaillistchecker.io skips that step. No waiting. No hurdles. Just sign up, grab your API key, and start verifying.

Its public APIs are built for developers already working with Mailgun or SendGrid. You can embed verification in your user signup flow, bulk import pipeline, or email campaign pre-flight check. The API supports both synchronous and asynchronous validation, making it ideal for Rails tasks that need to run in background jobs.

For teams using existing tools, the integrations page shows real-time sync workflows with Mailchimp, HubSpot, and Klaviyo—so you can verify before pushing data into any system. You don’t need to rebuild your stack.

And yes, the tool works with disposable domains and known catch-all servers, which many basic verifiers miss. This reduces false positives and keeps your list lean. For developers building with Ruby on Rails, the combination of real-time feedback, reliable accuracy, and instant API access turns email validation from guesswork into a measurable, maintainable process.

Final thoughts: verify before you send, and keep your list clean

Mailgun delivers your emails—but only if the addresses are valid and trusted. Sending to invalid or disposable emails damages your sender reputation and inflates bounce rates.

Verification isn’t optional when scale and deliverability matter. A clean list reduces waste, improves inbox placement, and protects your domain’s reputation over time.

• Use Emaillistchecker.io in real-time for form validation to block invalid signups.
• Run bulk verification periodically to remove outdated, fake, or catch-all addresses.
• Integrate it into your Ruby on Rails app with minimal setup—no complex infrastructure needed.

With 98.9% accuracy, Emaillistchecker.io helps you maintain a high-performing list. The result is fewer bounces, better deliverability, and stronger sender trust.

Keep reading

• Engineering guides: frameworks, pipelines and data imports (complete guide)
• How to Use Mailgun API to Verify Email Addresses Before Sending in PHP
• API for Verifying Client Email Addresses in Accounting Databases 2026
• API for Bulk Verification of Real Estate Agent Contact Databases
• What to Do When Email Verification API Returns Unknown Verdict

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

Frequently asked questions

Can I verify emails in real time using Mailgun?

Mailgun itself does not verify email addresses. You must verify them before sending using an external API like Emaillistchecker.io.

What is the accuracy of Emaillistchecker.io’s email verification?

Emaillistchecker.io reports 98.9% accuracy in cross-validated tests across real-world data, including syntax, domain, and mailbox validation.

How many emails can I verify with the free tier?

The free tier includes 100 verifications with no expiration. You can use them for testing or small-scale projects.

Does Emaillistchecker.io support bulk email verification in Rails?

Yes. You can upload a CSV file with up to 1,000 email addresses at once and receive a verified report in seconds.

Can I use Emaillistchecker.io with other email services besides Mailgun?

Yes. The API works with any outbound email system, including SendGrid, Amazon SES, and custom SMTP setups.

What does a 'risky' verdict mean?

A risky verdict indicates the email is associated with a disposable domain, role account, or known spam trap. Avoid sending to such addresses.

How do catch-all domains affect deliverability?

Catch-all domains accept any email, even invalid ones. Sending to them increases bounce risk and can harm sender reputation over time.

Does Emaillistchecker.io store my email data?

No. All verification requests are processed and discarded immediately after response. Data is not stored long-term.

Is the API rate-limited?

Yes. Free tier allows up to 100 verifications. Paid plans offer higher limits based on usage, with no expiry on credits.

How do I get started with Emaillistchecker.io in Rails?

Sign up at Emaillistchecker.io, copy your API key, add HTTParty to your Gemfile, and make POST requests to the verify endpoint.