Laravel Email Verification: Address Validation Rules Done Right in 2026

Search for Laravel email verification and you get two completely different topics wearing one name: Laravel's built-in MustVerifyEmail flow, which emails a confirmation link to prove a user controls a mailbox, and actual address verification, which checks whether the typed address is real and deliverable before your app accepts it. Most Laravel apps implement the first and skip the second, which is backwards for data quality: the confirmation email to a mistyped address simply vanishes, the registration stalls, and the dead address sits in your users table forever.

~23%
Industry estimate of web-form email submissions that are invalid, fake, or disposable. Laravel's email rule and even email:dns pass most of them, because format and DNS are not mailbox existence, and MustVerifyEmail only discovers the problem after the record is saved and the confirmation email has already vanished.
Quick Answer

How Do I Verify Email Addresses in Laravel?

Use both layers for what each is good at. Laravel's validation rules handle format cheaply: email catches malformed input and email:dns adds a DNS check, but neither confirms a mailbox exists, so real@ deadstartup2019.com and typo victims sail through. Real address verification happens in a custom validation Rule that calls a verification API during form validation: the API performs the live SMTP-level check plus disposable, gibberish, and typo detection in roughly 400ms, and your rule rejects dead or throwaway addresses with a helpful message (including the did-you-mean suggestion) before User::create ever runs. Keep MustVerifyEmail as well, because it does the one thing address verification cannot: prove this user controls that mailbox. The two compose cleanly: the custom rule guarantees the address is real so the confirmation email always arrives, and the confirmation click proves ownership. Cache verification results briefly keyed by address to avoid duplicate API calls on validation retries, fail open on API timeouts so verification hiccups never block signups, and apply the rule at registration, checkout, and newsletter endpoints but never at login. For existing user tables, verify in bulk via a queued job or CSV export instead of at request time.

The Two Things Laravel Devs Mean by Verification

MustVerifyEmail answers one question: does this user control this mailbox? It saves the record, emails a signed confirmation link, and gates routes on the verified middleware until the click. Address verification answers a different question: is this a real, deliverable, non-throwaway mailbox at all? It runs before the record exists and needs no cooperation from the user.

The failure mode of running only MustVerifyEmail is quiet and cumulative: every typo'd and fake submission becomes a saved user stuck permanently at the verify-email screen, your transactional stream bounces confirmation emails off dead addresses (which is reputation damage on the mail your password resets depend on), and support inherits the I-never-got-the-email tickets that were actually gmial.com's fault. Address verification upstream removes the whole class.

MustVerifyEmail proves ownership. It cannot prove existence, and it finds out about non-existence only after the bad row is already in your database.

What email and email:dns Actually Check

Laravel's email rule validates format, and the dns variant confirms the domain resolves mail records. Both are worth keeping as the free first gate, and both stop far short of the truth you need: a perfectly formatted address at a real domain with a dead mailbox passes everything Laravel ships. The gap between passes-DNS and actually-deliverable runs 8-15 percent on typical form traffic, and it contains exactly the addresses that later become bounces, stalled registrations, and fake accounts. Closing it requires the live SMTP conversation with the receiving server, which is what a real-time email verification API performs on your rule's behalf.

The Custom Rule: Real Verification in Validation

The integration is one artisan-generated Rule class. It caches by address so validation retries do not double-spend API calls, fails open on timeouts so a verification hiccup never blocks a signup, hard-rejects dead and disposable addresses, and surfaces the typo suggestion in the validation message where the user can act on it:

app/Rules/VerifiedEmail.php
<?php

namespace App\Rules;

use Closure;
use Illuminate\Contracts\Validation\ValidationRule;
use Illuminate\Support\Facades\Cache;
use Illuminate\Support\Facades\Http;

class VerifiedEmail implements ValidationRule
{
    public function validate(string $attribute, mixed $value, Closure $fail): void
    {
        // Cache briefly so validation retries do not re-bill the same address
        $result = Cache::remember('verify:' . md5($value), 3600, function () use ($value) {
            try {
                return Http::timeout(5)->get('https://api.bulkemailchecker.com/real-time/', [
                    'key' => config('services.bec.key'),
                    'email' => $value,
                ])->json();
            } catch (\Throwable $e) {
                return null; // Fail open: never block signups on API trouble
            }
        });

        if ($result === null) {
            return; // Timeout or error: allow, verify later in bulk
        }

        if (($result['status'] ?? '') === 'failed') {
            $msg = 'This email address does not appear to be deliverable.';
            if (!empty($result['emailSuggested'])) {
                $msg .= ' Did you mean ' . $result['emailSuggested'] . '?';
            }
            $fail($msg);
            return;
        }

        if (!empty($result['isDisposable'])) {
            $fail('Please use a permanent email address.');
        }
    }
}

Usage is ordinary Laravel: 'email' => ['required', 'email:dns', new VerifiedEmail] in your FormRequest, with the cheap built-in rules running first so the API only sees input worth checking. The response fields the rule branches on (status, event, isDisposable, emailSuggested, and the rest) are specified in the email verification API documentation, and unknown results deliberately pass through: catch-all corporate domains are unconfirmable rather than bad, and rejecting them would turn away real B2B users.

⚠
Warning: Put the API key in config/services.php backed by an env variable, never inline, and keep the timeout tight with fail-open behavior exactly as shown. A verification API is there to improve signups; a rule that can block registration when a third-party call is slow has its priorities inverted.

Where the Rule Belongs (and Where It Does Not)

Apply it wherever a new address enters the system: registration, checkout guest email, newsletter subscribe endpoints, and team-invite forms, which are the front doors your data quality lives or dies by. Skip it at login (the address is already yours; verifying it again spends money to learn nothing) and skip it on password-reset request forms, where behavior should never differ for existing versus non-existing accounts. For high-traffic apps where per-check pricing would make anyone hesitate to add the rule to another form, the unlimited email verification API plan flattens the cost question so coverage decisions stay architectural rather than budgetary.

Verifying an Existing Users Table

The rule protects new data; the users table you already have carries whatever accumulated before it existed. Two clean paths: a queued artisan command that walks users in chunks, calls the same API per address, and stores status plus verified_at columns for querying; or the zero-code route, exporting addresses to CSV and running them through the bulk email verifier, then importing results back. Either way, act on the output the same way the rule would have: suppress the failed from mailings, flag disposables, and leave unknowns sendable with monitoring. From then on the rule keeps the table clean and the bulk pass becomes an occasional decay sweep rather than a rescue.

💡
Pro Tip: Store the full verification response as a JSON column, not just the status. The flags (isFreeService, isRoleAccount, mxEnrichment) are segmentation and fraud-scoring data your product team will want later, and re-fetching them costs another check per address while keeping them costs one column.

Frequently Asked Questions

What is the difference between Laravel's MustVerifyEmail and email verification?
MustVerifyEmail proves a user controls a mailbox via a confirmation click, after the record is saved. Address verification proves the mailbox exists and is deliverable, before the record is saved. They answer different questions and the strongest setup runs both, in that order reversed: verify the address first, then confirm ownership.
Isn't Laravel's email:dns validation rule enough?
It confirms format and that the domain resolves, which any dead mailbox at a live domain passes. Industry data puts the gap between passing DNS-level validation and actually being deliverable at 8-15 percent of form submissions, and closing it requires the SMTP-level mailbox check an API performs.
Will the API call slow down my registration form?
The check runs around 400ms, comparable to a payment tokenization call, and the pattern shown (tight timeout, fail open, cached results) guarantees the worst case is a signup that proceeds unverified rather than one that blocks. Users notice invalid-address errors, not the check itself.
Should the rule reject unknown results?
No. Unknown usually means a catch-all corporate domain or a strict gateway, which is unconfirmable rather than invalid, and B2B signups concentrate there. Let unknowns pass, store the status, and let MustVerifyEmail's confirmation click provide the certainty for those accounts.
How do I handle the typo suggestion in the UI?
The rule's validation message already carries the did-you-mean text, which Blade renders like any other error. For a smoother flow, expose a small verification endpoint and check on field blur via JavaScript so the suggestion appears before submit; the server-side rule then remains the enforcement layer for anything that bypasses the front end.
How should I verify the users I already have?
In bulk, off the request path: a chunked queued command calling the same API, or a CSV export through a bulk verification tool with results imported back. Suppress failures from mailings, flag disposables, keep unknowns with monitoring, and let the new rule prevent recurrence.

The Bottom Line

Laravel email verification done right is a composition, not a choice: built-in rules for free format checking, one custom Rule class for mailbox truth at every front door, MustVerifyEmail for ownership proof that now reliably arrives, and a bulk pass to bring the existing table up to the same standard. The whole pattern is an afternoon of work, and it retires typo'd registrations, vanishing confirmation emails, and fake accounts as a category.

Generate the rule, wire the config, and your users table starts telling the truth from the next deploy.

✅
Test the Response Before You Write the Rule: Paste a known-bad address into the free email verification tool and look at the JSON your rule will branch on: status, event, isDisposable, emailSuggested. Seeing the real payload first makes the Rule class above read like documentation.
99.7% Accuracy Guarantee

Stop Bouncing. Start Converting.

Millions of emails verified daily. Industry-leading SMTP validation engine.