Phone Number Regex Tester

Phone Number Regex Tester

Test and validate phone patterns with this specialized regex tester. Includes tested patterns and real-time matching.

Recommended Phone Pattern

``regex ^\+?1?[-.\s]?\(?\d{3}\)?[-.\s]?\d{3}[-.\s]?\d{4}$ `

Test Examples

Valid matches:

• (555) 123-4567
• 555-123-4567
• +1 555 123 4567
• 5551234567

• 555-123
• 123-456-78901
• abc-def-ghij

1. ^\d{10}$ 2. ^\(\d{3}\) \d{3}-\d{4}$

How to Use

1. The pattern above is preloaded—or enter your own 2. Add test strings to validate 3. See real-time match highlights 4. Copy the pattern for your code

Regex Quick Reference

The Pattern

`regex ^\+?1?[-. (]*(\d{3})[-. )]*(\d{3})[-. ]*(\d{4})$ `

Flags: gm — m makes ^ and $ match at each line break, so the pattern can be tested against a list.

Broken Down

Tested Against Real Input

The Important Caveat

This matches North American numbers. International formats vary far too much for one pattern — use libphonenumber if you need to accept the world.

Using It

`javascript const pattern = /^\+?1?[-. (]*(\d{3})[-. )]*(\d{3})[-. ]*(\d{4})$/gm;

// Test a single value — reset lastIndex first if the pattern is global pattern.lastIndex = 0; const isValid = pattern.test(value);

// Or find every match in a block of text const matches = [...text.matchAll(pattern)]; `

A global regex carries lastIndex between calls, so reusing one across test() calls returns alternating results. Either drop the g flag for validation or reset it each time.

Anchors, Greediness and Backtracking

Three behaviours account for most regex surprises, and this pattern shows all three.

Anchors. ^ and $ pin the match to the start and end of the input. Without them, \d{3} matches the 123 inside abc123def. With m in the flags — as here — they pin to each *line* instead, which is what lets one pattern be tested against a list.

Greediness. .* takes as much as it can and gives back only when forced; .*? takes as little as possible. On , the pattern <.*> matches the whole string and <.*?> matches just .

Backtracking. When a match fails, the engine reverses and tries other splits. Nested quantifiers like (a+)+ make that exponential, and a 30-character input can hang a server — a class of denial of service known as ReDoS. Avoid nesting quantifiers, and prefer explicit character classes over . wherever you can.

Testing It Properly

`javascript const pattern = /^\+?1?[-. (]*(\d{3})[-. )]*(\d{3})[-. ]*(\d{4})$/gm;

// A global regex keeps lastIndex between calls, so reusing one across // test() calls returns alternating true/false on the same input. pattern.lastIndex = 0;

// Named groups make the result readable const named = /(?\d{4})-(?\d{2})/; const { groups } = '2026-08'.match(named); `

Write the failing cases first. A pattern that accepts everything valid is easy; one that also rejects everything invalid is the hard half, and it is where the bugs are.

When Not to Use a Regex

Structured formats have parsers, and the parser is always more correct: new URL() for URLs, DOMParser for HTML, JSON.parse` for JSON, a date library for dates. Reach for a regex to *find* things in unstructured text, not to validate something a parser understands.