5 Ways to Implement Phone Number Validation in Python

Phone number validation is a key step for ensuring data quality and blocking spam. We'll walk through five different approaches to validation in Python, complete with working code. Then, we'll examine the common pitfalls of these methods and see how Abstract API offers a more reliable alternative.

How to Validate Phone Numbers in Python

Here are a few ways to perform phone number validation in Python. Each method approaches the problem differently, from metadata lookups to pattern matches with regular expressions.

The `phonenumbers` Library

The `phonenumbers` library is a Python port of Google's `libphonenumber`. It includes numbering plan metadata for all countries, which makes validation a simple metadata lookup process. This approach avoids complex custom logic.

The code first parses the raw string into a phone number object. It then checks if the number is valid against its data. If valid, it formats the number to the E.164 standard. The library's documentation details additional helpers.

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

Compiled Regular Expressions

For a narrow scope, like US and Canadian numbers, a regular expression offers a fast solution. A compiled regex pattern runs at C-speed inside Python's `re` engine. This method also keeps dependencies at zero.

This is useful for environments like AWS Lambda or IoT devices. The code first removes all non-digit characters from the input string. Then, it attempts to match the cleaned string against a pre-compiled pattern for the North American Numbering Plan.

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 Python methods seem straightforward, they have significant blind spots. Real-world phone data is messy and dynamic, which creates problems for static validation logic.

• International numbering plans constantly change. The `phonenumbers` library relies on a data bundle that can become outdated, so its definition of a "valid" number may not reflect the current network reality.
• User input contains stray characters, spaces, and inconsistent prefixes. Regular expressions often fail against this variability and require complex, case-by-case normalization logic instead of a single, reliable pattern.
• A number's data decays quickly. Subscribers move between carriers and old numbers get recycled. Static methods like regex or `phonenumbers` cannot confirm if a structurally correct number is actually live.
• VoIP and virtual numbers create a flood of disposable lines. Pattern-based checks in regex or the `phonenumbers` library cannot detect these potentially fraudulent numbers without live carrier intelligence and fraud scoring.