EMAIL VERIFICATION WITH PYTHON: BEST PRACTICES AND IMPLEMENTATION STRATEGIES

In today's digital world, effective email management is essential for any web application. Validating email addresses not only enhances user experience but also helps maintain clean and accurate databases. In this blog, we'll explore how to perform email validation using Python, a powerful and versatile tool.

Why is Email Validation Important?

Validating email addresses is crucial to ensure users provide accurate contact information and databases are not affected by incorrect entries. Additionally, it facilitates effective communication and helps prevent fraud and abuse.

As spam is such a serious issue, email providers are very careful to ensure that messages leaving their systems are not spam, but legitimate, and that email addresses have been collected legitimately.

One way to do this is by monitoring bounce rates. If you send out many emails that bounce (because the email address is invalid), you may get flagged in their system as spam. Therefore, if an email provider (e.g., Gmail) receives many messages from you directed to non-existent addresses, they may block you.

Tools and Libraries in Python

1. Regular Expressions (Regex)

Python provides the re module for working with regular expressions. You can create regex patterns to validate the basic structure of an email address.

import re
  
def validate_email(email):
    pattern = r'^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$'
    return re.match(pattern, email) is not None

This regex pattern checks:

• A local part consisting of alphanumeric characters, dots, underscores, plus signs, and hyphens.
• The presence of the '@' symbol.
• A domain containing alphanumeric characters, dots, and hyphens.

It DOES NOT check

• Whether the email address corresponds to a real domain (e.g., matthew@bigfakedomainthatisntreal.com) returns True.
• Whether the email address meets the syntax requirements of the specific email provider (e.g., the number of dots in yahoo addresses).

2. External Libraries

Using specialized libraries can simplify the process. For example, you can incorporate email-validator by:

pip install email-validator

from email_validator import validate_email

def validate_email(email):
    return validate_email(email, verify=True)

This is undoubtedly a step forward from basic Regex usage to validate an email. The only downsides to using this library are that it doesn't handle obsolete addresses.

3. Using an External Service

The most reliable and effective way to validate emails in Python is to use a specific third-party API. APIs like Valid Email offer a secure REST endpoint that accepts an email address and produces a JSON response with details about the address's validity.

The Valid Email endpoint is more reliable than a library, which is often outdated, because it is regularly updated. The API checks SMTP servers, examines MX records, domain syntax, and validity. Additionally, it can report whether the email is a temporary email or a free email.

Batch email checking can also be done via the API. To receive a report on the validity of each email in the list, simply upload a CSV file containing the email list, and the API will return a response per address. This is excellent for email list audits. Read more on how to do it here.

Get an API key

To start, you'll need to sign up to create an account and get an API key. With your free account, you get an API key that authenticates you to the API and allows you to make requests.

Once registered, you'll be able to see your API key on the Dashboard.

Use the API key to send a request to the API

Let's first install the requests module, as we'll use it to make a GET request to the Valid Email endpoint.

pip install requests

To send the request to the API and check the JSON response, we'll create a function called send_email_validation_request().

import requests
def send_email_validation_request(email):
    try:
        response = requests.get("https://validemail.io/v1/validate?api_key=YOUR_API_KEY&email={email}")
        print(response.content)
    except requests.exceptions.RequestException as api_error:
        print(f"An error occurred contacting the API: {api_error}")
        raise SystemExit(api_error)

The response should look like this:

{
  "email" : "jake@validemail.io",
  "is_valid" : "Valid",
  "message" : "Email is valid",
  "has_valid_format" : true,
  "is_free_provider" : true,
  "is_disposable" : false,
  "account" : "jake",
  "domain" : "validemail.io"
}

This way, you can assess if the email is valid, a temporary email, free, and other aspects.

Conclusion

In this tutorial, we've seen three methods to determine if an email address exists in Python: regex, a Python package, and a dedicated validation API. The method you choose for your Python application will depend on your needs and the scale of your application.

For a test application, an application that won't be used much, or an application where email parameters are known and controllable, using Regex may be a viable option. For anything else, however, we recommend choosing one of the Python packages or, better yet, using a dedicated API.