Regex for Phone Numbers (E.164 Format)

Read it left to right. Each piece below matches one part of the input:

• ^ Start of the string.
• \+ A literal plus sign. E.164 numbers always carry it when written for machines.
• [1-9] The first digit of the country code. No country code starts with 0.
• \d{1,14} 1 to 14 more digits: the rest of the country code plus the national number. E.164 caps the total at 15 digits.
• $ End of the string: no extensions, spaces or punctuation.

The whole input must match, from the first character to the last. Every row below is checked against the pattern by our automated test suite before each release.

Because there are hundreds. Lengths, area codes and mobile prefixes differ by country and change over time: a UK mobile is 07… nationally but +447… internationally, Germany has variable-length numbers, and the North American plan forbids area codes that start with 0 or 1. A regex that tracks all of that is a maintenance project.

The robust approach has three steps:

1. Accept loose input. Let people type spaces, dashes, dots and brackets the way they are used to.
2. Parse and normalize with Google's libphonenumber (ports exist for JavaScript, Python, Go, C#, PHP and Dart). It knows each country's rules and returns the E.164 form.
3. Store and validate E.164 with the pattern on this page. Twilio and AWS SNS expect E.164, and most other messaging APIs accept it.

If you cannot use a library, a forgiving first pass accepts common punctuation and then counts digits:

^\+?[0-9 ()\-.]{7,20}$

Then remove everything except digits and the leading plus, and check the result against the E.164 pattern. Splitting the job like this keeps each regex simple and gives users clear error messages: "remove the letters" is easier to act on than "invalid phone number".

The E.164 recommendation itself is short and worth a read: it is the source of the 15-digit limit.

The pattern is translated for each engine rather than pasted as is: named groups, anchors, escapes, shorthand classes and flags are adjusted so each snippet behaves as closely to the JavaScript version as its engine allows. Differences that remain (Go's RE2 has no lookarounds or backreferences, for example) are called out under each one. The Code tab in the tester above also exports Dart, and updates as you edit the pattern.

JavaScript and TypeScript

const regex = /^\+[1-9]\d{1,14}$/;

function isValid(value) {
  return regex.test(value);
}

console.log(isValid("+14155552671"));

Python

import re

pattern = re.compile(r"^\+[1-9][0-9]{1,14}\Z")

def is_valid(value: str) -> bool:
    return pattern.search(value) is not None

print(is_valid("+14155552671"))

• \d and \w are written as [0-9] and [A-Za-z0-9_] because in Python they also match digits and letters from other scripts.
• JavaScript's $ only matches at the very end of the string. Python's $ also matches before a trailing newline, so the pattern uses \Z instead.

Go

package main

import (
	"fmt"
	"regexp"
)

func main() {
	re := regexp.MustCompile(`^\+[1-9]\d{1,14}$`)
	fmt.Println(re.MatchString("+14155552671"))
}

C#

using System;
using System.Text.RegularExpressions;

// The timeout stops a pathological input from hanging the thread (ReDoS).
var regex = new Regex(@"^\+[1-9][0-9]{1,14}\z", RegexOptions.None, TimeSpan.FromSeconds(1));
Console.WriteLine(regex.IsMatch("+14155552671"));

• \d and \w are written as [0-9] and [A-Za-z0-9_] because in .NET they also match digits and letters from other scripts.
• JavaScript's $ only matches at the very end of the string. .NET's $ also matches before a trailing newline, so the pattern uses \z instead.

PHP

<?php

$pattern = '/^\+[1-9]\d{1,14}$/D';

function isValid(string $value, string $pattern): bool
{
    return preg_match($pattern, $value) === 1;
}

var_dump(isValid('+14155552671', $pattern));

• The D modifier makes $ match only at the very end, like JavaScript (PCRE's $ also matches before a trailing newline).

• Regex for Email Validation: Practical email check: dotted local part, real domain labels and a letters-only top-level domain.
• Regex for Numbers Only: Digits only, plus variants for signs, decimals and thousands separators.
• Regex for US ZIP Codes: Five-digit ZIP codes with an optional ZIP+4 extension, like 90210-1234.
• Regex for Indian PIN Codes: Six-digit Indian postal codes that never start with 0, with an optional space.

Browse all 25 patterns in the regex pattern library, or build your own in the regex tester.