Why Regex Is No Longer the Right Tool for Python Email Validation
For years, a Regex pattern was the first tool developers reached for. The problem is that regex email validation in Python only checks whether a string looks like a valid address, not whether that address actually works.
A pattern like this passes validation without issue:
python
import re
pattern = r'^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
email = "user@tempmail.com"
print(bool(re.match(pattern, email))) # True
The result is True. But tempmail.com is a disposable email provider. The user registering with that address is likely a bot, a tester, or someone with no intention of receiving your emails. Regex catches none of that.
New TLDs like .photography, .io, or .ai can also slip past patterns that are too restrictive, which means legitimate addresses get blocked. Keeping a precise Regex in sync with evolving RFC standards is a maintenance burden with no real payoff.
Method 1: The Modern Standard with Pydantic v2
Python validate email with Pydantic v2 is how most developers handle syntax validation in 2026, especially in FastAPI and Django projects. Pydantic includes the EmailStr type, which runs RFC-compliant validation without any additional logic on your end.
Install the dependency:
bash
pip install pydantic[email]
Then define your model:
python
from pydantic import BaseModel, EmailStr, ValidationError
# 2026 Best Practice: Use Pydantic types
class UserSignup(BaseModel):
email: EmailStr
try:
user = UserSignup(email="test@example.com")
print("Syntax is valid!")
except ValidationError:
print("Invalid email format.")
Internally, Pydantic uses the email-validator library for parsing. It validates the local part, the domain, and modern TLDs without any extra configuration. This is the right solution for the vast majority of syntax validation use cases.
What Pydantic doesn't do is verify whether the mailbox exists or whether the domain is disposable. That requires the next layer.
Method 2: The email-validator Library
If you're not using Pydantic, you can use email-validator directly. It's the reference library for email validation in Python in projects that don't rely on a framework with built-in types.
bash
pip install email-validator
python
from email_validator import validate_email, EmailNotValidError
try:
emailinfo = validate_email("user@example.com", check_deliverability=False)
print(f"Valid email: {emailinfo.normalized}")
except EmailNotValidError as e:
print(f"Invalid: {e}")
With check_deliverability=True, the library also queries the domain's MX records to confirm a mail server is configured. It's a useful addition to syntax-only checks, but it still can't tell you whether a specific mailbox exists.
For a comparison of open-source validation libraries across languages and use cases, see our guide to open-source email validation libraries.
Method 3: Deep Verification with Our Email Validation API
Pydantic and email-validator cover syntax well. But if your product needs to stop fake signups, reduce bounce rates, or protect your domain reputation, you need to check if an email is valid at the deliverability level. That's something no local library can handle.
Our Email Validation API runs real-time SMTP verification, disposable email detection, MX record lookup, and a quality score per address, all in a single call. For a deeper look at how disposable addresses work and how to block them at scale, see our guide on how to detect and block disposable email addresses.
Install requests if you haven't already:
bash
pip install requests
Then integrate the API:
python
import requests
api_key = "YOUR_ABSTRACT_API_KEY"
email = "risky_user@tempmail.com"
# Check if the email is real and not disposable
response = requests.get(
f"https://emailvalidation.abstractapi.com/v1/?api_key={api_key}&email={email}"
)
data = response.json()
if data['is_valid_format']['value'] and not data['is_disposable_email']['value']:
if data['deliverability'] == "DELIVERABLE":
print("Safe to register user.")
else:
print("Email format is okay, but mailbox does not exist.")
else:
print("Blocked: Invalid or Disposable email.")
The response includes fields like is_disposable_email, is_mx_found, is_smtp_valid, and deliverability. An address can pass every syntax check and still come back UNDELIVERABLE because the mailbox was deleted or never existed.
Adding our API to your Python backend means every address that reaches your database has been checked for format, deliverability, and disposable domain patterns, with no custom logic, no static blocklists to maintain, and no false positives from legitimate new TLDs. Get your free API key and start verifying in minutes.
Syntax vs. Deliverability: What Each Method Covers
| Method | RFC Syntax | MX Record | Mailbox Exists | Disposable Detection |
|---|---|---|---|---|
| Regex | Partial | No | No | No |
| Pydantic v2 / email-validator | Yes | Optional | No | No |
| Our Email Validation API | Yes | Yes | Yes | Yes |
For most registration flows, the right combination is Pydantic for format validation at the framework layer and our API for verification before the user is persisted to the database.
Frequently Asked Questions
What is the best way to validate an email address in Python?
The most reliable approach combines multiple layers: use Pydantic v2's EmailStr type or the email-validator library for RFC-compliant syntax checking at the input layer, then call a real-time API like Abstract's Email Validation API before saving to your database. Syntax-only checks cannot tell you whether a mailbox actually exists or whether the address belongs to a disposable provider.
Why isn't regex enough for Python email validation?
Regex only checks whether an address looks correctly formatted; it cannot verify that the domain has mail servers configured, that the mailbox exists, or that the address isn't from a disposable provider. Regex patterns also need manual updates as new top-level domains like .io or .photography emerge, making them brittle in production.
How does the Python email-validator library work, and when should I use it?
The email-validator package validates addresses against RFC 5321/5322 standards, catching malformed usernames, invalid domain formats, and (when you set check_deliverability=True) missing MX records. Use it when you need fast, local syntax validation without an external request, but keep in mind it still cannot confirm whether a specific mailbox exists on the mail server.
How do I validate email addresses in a FastAPI or Pydantic v2 project?
Add EmailStr from Pydantic as the type annotation for your email field in any BaseModel subclass. Pydantic will automatically run RFC-compliant validation and raise a ValidationError if the format is wrong, with no extra configuration needed. For async workflows in FastAPI, you can pair this with httpx to call an external validation API without blocking the event loop.
What is the difference between syntax validation and deliverability validation for email addresses?
Syntax validation confirms that an address follows the correct format rules (valid characters, an @ symbol, a proper domain structure). Deliverability validation goes further: it checks that the domain has MX records pointing to active mail servers, performs an SMTP handshake to confirm the mailbox exists, and flags addresses from known disposable email providers. For sign-up forms or transactional email, deliverability validation is the standard that prevents bounces and fake registrations.
How can I detect disposable or temporary email addresses in Python?
Local libraries like email-validator do not include disposable domain detection. The most straightforward method is to call a validation API that maintains an up-to-date list of disposable providers: Abstract's Email Validation API returns a is_disposable_email flag in its JSON response, letting you reject or flag those addresses before they reach your database.
