How to check for valid email address?

The Fine Art of Email Validation

More than a simple regex check, email validation must cover syntax, existence of domain, MX records, and SMTP server checks too. A more comprehensive validation ensures the format is accurate and delivery possible.

Parsing and Deploying Regex Patterns

Utilizing email.utils.parseaddr() to ensure the email address aligns with the RFC-822 standards, you can extract the real email address out of a string. To dig deeper, apply a wide-ranging regex pattern that considers different characters and formats. Behold:

import re
from email.utils import parseaddr

# Not your grandma's regex pattern
email_regex = re.compile((r"(^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$)"))

# Verify the email, and watch those brackets!
address = "[email protected]"
is_valid = email_regex.fullmatch(address)  # Pattern, meet string.
parsed_email = parseaddr(address)[1]  # Breaking down the address to shake hands with parseaddr
print(is_valid is not None and parsed_email == address)  # True if it's a match made in heaven


This checks for syntax correctness and parsing based on standards while leveraging re.fullmatch() to ensure the complete string fits snugly into the email pattern algorithm.

Domain Checks and MX Record Validation

To bring your validation into the real world, it’s key to corroborate the existence of the email's domain and its linked mail servers. Bring in dnspython and use validate_email to efficiently resolve MX records:

from validate_email import validate_email
import dns.resolver

# Check mate for the domain and existence of MX records
email = "[email protected]"
has_mx_record = validate_email(email, check_mx=True) # Says OK if MX record found 
is_resolvable = dns.resolver.resolve(email.split('@')[1], 'MX') is not None  # Checks if the domain can be resolved

print(has_mx_record and is_resolvable)  # Says "Woohoo!" if the email has MX records and domain is resolvable. Else "Bummer!"


Checking MX records is akin to ensuring that deliverability is no problemo, as it verifies the domain's capacity to handle emails.

Next Stop, Deliverability Avenue

The most surefire way of confirming validity is SMTP server checks. The validate_email package provides a helping hand with the verify=True flag which verifies if the mailbox is an actual, existing destination.

# Knock, knock. Who's there? SMTP!
is_deliverable = validate_email(email, verify=True)
print(is_deliverable)  # "All aboard!" if the address is confirmed to be deliverable


Practical techniques and considerations

Fine-tuning your email validation process involves considering typos and variations of domains, and other edge cases to enhance the efficacy of validation.

Spotting typos

Integrating a check for typos allows your code to suggest corrections and help avoid bounce backs due to pesky misspelled email domains. Below, you'll find a simple implementation:

known_domains = ["gmail.com", "yahoo.com", "hotmail.com"]   # Maxi, not Mini domains
suggestions = {}

email_parts = email.split("@")
for domain in known_domains:
    if email_parts[1].closely_matches(domain):
        suggestions[email] = domain  # Suggests alternate realities


Tackling subdomains

Businesses often employ subdomains in their email addresses. Making your regex pattern flexible enough to accommodate these nested subdomains is essential to keep the validation check efficient:

# Regex pattern for the subdomain savvy
subdomain_email_regex = re.compile(r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)*\.\w+$")

is_valid_with_subdomain = subdomain_email_regex.fullmatch("[email protected]")
print(is_valid_with_subdomain is not None)  # Says "Yay!" if regex accommodates subdomains


Riding the email validation library wave

Libraries such as py3-validate-email align with RFC 2822, providing high level abstraction for validation keeping up with the ebb and flow of email standards.