Validate an Email Address in Python

Step 1: validate the format with email-validator

The email-validator package is the most common choice. It checks the format against the email standards, normalizes the address, and can check the domain. Install it with pip:

pip install email-validator

from email_validator import validate_email, EmailNotValidError

def check(address: str, deliverability: bool = True):
    try:
        info = validate_email(address, check_deliverability=deliverability)
        return True, info.normalized
    except EmailNotValidError as err:
        return False, str(err)

Results from our test run:

Use info.normalized, not the raw input, when you save the address. It lowercases the domain and applies the standard Unicode form, so the same person is not stored twice. Older code and tutorials often read .email instead. That still works, but .normalized is the name current versions document.

The deliverability check makes a DNS query, so it adds a short delay. For bulk imports or offline tests, pass check_deliverability=False to check only the format.

Why jane@gmial.com passes

gmial.com has no MX records, so it has no mail servers. But it does have an A record, the address of a website. The email standard (RFC 5321) says a sending server may fall back to the A record when there are no MX records, and email-validator follows that rule. So the typo passes.

That is correct by the standard, but it is not what you want on a signup form. Almost every real mailbox domain publishes MX records, and a typo of a big provider almost never belongs to a real customer.

Step 2: require MX records with dnspython

To catch typo domains, check for MX records yourself. dnspython is installed with email-validator, or on its own with pip install dnspython.

import dns.resolver

def domain_accepts_mail(domain: str) -> bool:
    try:
        answers = dns.resolver.resolve(domain, "MX")
    except (dns.resolver.NXDOMAIN, dns.resolver.NoAnswer):
        return False
    hosts = [str(r.exchange) for r in answers]
    # A null MX (RFC 7505) points to "." and means the domain takes no mail.
    return any(h not in (".", "") for h in hosts)

Timeouts raise a different error, dns.resolver.LifetimeTimeout. Treat that as "unknown" and try again later, rather than rejecting the address.

Step 3: confirm the mailbox with an email verification API

The first two steps prove the address is well formed and the domain can receive mail. They cannot tell you whether jane has a mailbox at that domain. That needs an SMTP check against the mail server. Most cloud hosts block outbound port 25, so in practice this check runs through an email verification API.

import os
import requests

def verify_mailbox(address: str) -> str:
    response = requests.post(
        "https://api.giggal.ai/v1/verify",
        json={"email": address},
        headers={"Authorization": f"Bearer {os.environ['GIGGAL_API_KEY']}"},
        timeout=30,
    )
    result = response.json()
    if not result.get("success"):
        raise RuntimeError(result.get("error"))
    return result["data"]["status"]  # deliverable, undeliverable or unknown

The API also handles catch-all domains, where the mail server accepts every address. It returns a valid or invalid result for them in the catch_all_verdict field. New accounts get 1,000 free credits. The Developer Hub lists every endpoint, including the bulk email verification endpoint for lists of up to 50,000 addresses.

Putting it together

Run the cheap checks first and call the API only for addresses that pass them. This saves credits and keeps your form fast.

def validate(address: str) -> str:
    ok, value = check(address, deliverability=False)   # format only, no network
    if not ok:
        return "invalid: " + value
    domain = value.split("@")[1]
    if not domain_accepts_mail(domain):
        return "invalid: domain has no mail servers"
    return verify_mailbox(value)                       # mailbox check via the API

What about a regex?

A regex is fine for a quick hint in a script, but it is a poor final check. Our JavaScript email validation tests show how common patterns accept addresses like .jane@example.com and jane..smith@example.com, which mail servers reject. The same patterns behave the same way in Python's re module. email-validator already handles these cases, so prefer it over writing your own pattern.

If you only need to check one address by hand, paste it into the free email verifier instead.

Frequently asked questions