5 Ways to Implement Phone Number Validation in Python

Phone number validation is an important step for maintaining data integrity in Python applications. We will look at three ways to implement it with working code, discuss the pitfalls of these traditional methods, and show how Abstract API addresses them.

How to Implement Phone Number Validation in Python

Here are two common methods to validate phone numbers in Python. Each approach has a different implementation, from a dedicated library to the use of regular expressions for specific patterns.

Validation with the Phonenumbers Library

The phonenumbers library is a Python port of Google's comprehensive libphonenumber library. It contains numbering-plan metadata for every country, which makes the validation process mostly a metadata lookup. The library is available on PyPI and provides a robust way to check numbers from around the world.

The code first attempts to parse the raw phone number string with the parse function. It then uses is_valid_number to check if the number is possible and correct according to its country code and exchange. This process effectively filters out numbers with impossible lengths or incorrect formats.

If the number proves valid, the format_number function converts it to the standard E.164 format. The library also exposes helpers for additional checks related to the carrier, line type, and geocoding information, which allows for more detailed policy enforcement.

import phonenumbers
from phonenumbers import PhoneNumberFormat, NumberParseException

def validate_e164(raw: str, region: str | None = None) -> str | None:
    try:
        n = phonenumbers.parse(raw, region)
        if phonenumbers.is_valid_number(n):
            return phonenumbers.format_number(n, PhoneNumberFormat.E164)
    except NumberParseException:
        pass
    return None

Regular Expression Validation

For more limited scopes, such as numbers within the North American Numbering Plan, a well-crafted regular expression is often sufficient. This approach, sometimes seen in framework configurations, runs very fast because it executes at C-speed inside Python's native re engine. It also keeps external dependencies to zero.

The example code compiles a regex pattern for NANP numbers. The validation function first strips all non-digit characters from the input string. It then reformats the remaining digits to a standard +1 format and uses a match function to confirm the number adheres to the pattern.

import re

_NANP = re.compile(r'^(?:\+?1)?([2-9]\d{2})([2-9]\d{2})(\d{4})$')

def validate_nanp(raw: str) -> str | None:
    m = _NANP.sub(r'+1\1\2\3', re.sub(r'\D', '', raw))
    return m if _NANP.match(m) else None

Challenges of Phone Number Validation

While these methods offer a starting point, they fall short in several key areas. Static validation struggles to keep pace with the dynamic nature of global telecommunication networks and user behavior.

• International numbering rules change constantly. The data bundle in the phonenumbers library can become outdated, which means a number that passes validation in your code might not exist on the actual network.
• User input is often messy, with extra characters like dashes or spaces. Regular expressions struggle with this variability and require you to account for numerous edge cases instead of a single, clean pattern.
• Phone numbers have a lifecycle. Subscribers move between carriers, and old numbers get recycled. Static validation with the phonenumbers library or regex cannot confirm if a number is live or its current carrier.
• The rise of VoIP and virtual SIMs introduces disposable numbers. Pattern checks from regex or the phonenumbers library cannot detect these lines, which leaves compliance gaps and misses fraud signals.