Guides
Last updated
April 28, 2025

JavaScript Phone Number Validation

Nicolas Rios

Table of Contents:

Get your free
Phone Validation
API key now
stars rating
4.8 from 1,863 votes
See why the best developers build on Abstract
START FOR FREE
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
No credit card required

How to Validate Phone Numbers in JS (Regex, Libraries, & API)

Phone number validation ensures that a number entered into a form or application is correctly formatted and potentially valid before you use it. This is a crucial step for improving data accuracy, enabling effective communication, and delivering a smooth user experience.

Without validation, typos and incorrect formats can sneak into your database, making it hard to reach users or causing issues when sending messages. Whether you're building a sign-up form, contact tool, or customer database, verifying phone numbers helps you:

  • Prevent user errors
  • Save time and resources
  • Ensure you're storing usable, standardized contact information

In this article, we’ll walk you through how to validate phone numbers in JavaScript, using regex, popular libraries, and validation APIs. This guide is for both beginners and experienced developers, and we’ll explore different ways to validate phone numbers using JavaScript, from simple regex patterns to powerful validation libraries and APIs like Abstract’s Phone Validation API.

Enter a phone number to start
Need inspiration? Try
+1 (415) 200-7986
VALIDATE
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
Checking
5
Results for
phone-number
Is Valid:
TEST
Country:
TEST
City:
TEST
Carrier:
TEST
Line type:
TEST
Get free credits, more data, and faster results

Why Phone Number Validation Matters

Phone number validation is the process of checking whether a phone number:

  • Follows the correct format
  • Contains the expected number of digits
  • May actually exist or be in service (with advanced checks)

Validation can be as basic as using a pattern match (like a regex) or as advanced as using a phone validation API that confirms the number is real and reachable.

Here’s why validating phone numbers is a smart idea:

✅ Ensures accurate contact information

✅ Catches user typos before they’re submitted

✅ Improves data quality and reduces errors

✅ Saves SMS or call costs by avoiding invalid numbers

✅ Handles global formats—different countries use different number lengths and formats

Even a small app benefits from validating phone numbers, especially if it’s collecting sign-ups, sending alerts, or managing user accounts.

Overview of Phone Number Validation Methods in JavaScript

JavaScript offers several ways to validate phone numbers:

Phone Number Validation Methods in JavaScript

✅ Regex (Regular Expressions)

  • A pattern-matching method that quickly checks if the phone number looks right (e.g., contains 10 digits, dashes, or parentheses).

✅ Libraries (e.g., libphonenumber-js)

  • These tools can parse and validate numbers using rules for international formats, making them far more reliable than regex alone.

✅ APIs (e.g., AbstractAPI’s Phone Validation API)

  • Online services that can tell you whether a number is real, active, and provide info like location, carrier, and type (mobile or landline).

Each approach has pros and cons, and we’ll go through examples of all three below.

Validating Phone Numbers with Regular Expressions (Regex)

What is Regex?

Regex (short for “regular expression”) is a tool that helps you define a pattern in text. In JavaScript, you can use it to check if a phone number follows a specific structure—like being exactly 10 digits long, or allowing certain characters.

Basic Regex Example

Here’s a common regex pattern for US phone numbers:

  • const phonePattern = /^\(?(\d{3})\)?[- ]?(\d{3})[- ]?(\d{4})$/;

This supports formats like:

  • 123-456-7890
  • (123) 456-7890
  • 1234567890

What the pattern means:

  • ^\(?\d{3}\)?: Starts with an optional (, followed by 3 digits, and optional )
  • [- ]?: Allows a dash or space
  • \d{3} and \d{4}: 3 digits + 4 digits at the end

Simple Validation Function

function validatePhone(number) {

  const phonePattern = /^\(?(\d{3})\)?[- ]?(\d{3})[- ]?(\d{4})$/;

  return phonePattern.test(number);

}

console.log(validatePhone("123-456-7890")); // true

console.log(validatePhone("1234567890"));   // true

console.log(validatePhone("456-7890"));     // false

Supporting Multiple Formats

You can customize regex to match international formats or include country codes. 

A few examples:

// With country code

/^\+1 \d{3}-\d{3}-\d{4}$/

// Plain 10 digits

/^\d{10}$/

// More general pattern (7 to 15 digits, optional +)

/^\+?\d{7,15}$/

These patterns cover a range of common use cases.

Limitations of Regex

Regex can’t do everything. Here are the limitations:

❌ Regex doesn’t check if a number is real (just the format)

❌ Doesn’t scale well globally — phone formats vary a lot by country

❌ Hard to maintain if you need to update or expand validation rules

For example, regex might accept +123456 as valid, even though it’s not a real number.

Best Use: Quick checks on the client side before more thorough validation.

Using JavaScript Libraries for Phone Number Validation

This is a lightweight version of Google’s powerful libphonenumber library. It supports parsing and validating phone numbers for hundreds of regions.

It understands real-world formatting rules like:

  • Country-specific length and codes
  • Standardized output (E.164 format)
  • National vs international numbers

Example Code

Install the package first:

  • npm install libphonenumber-js

Then use it in your JavaScript:

const { parsePhoneNumberFromString } = require('libphonenumber-js');

const phone = parsePhoneNumberFromString("+1 415 555 2671");

if (phone && phone.isValid()) {

  console.log("Valid number:", phone.formatInternational());

} else {

  console.log("Invalid phone number");

}

Bonus: UI Libraries

You can also use tools like intl-tel-input to add a country picker with formatting support—it wraps around this library to provide a friendly interface.

Pros & Cons of Libraries

Pros:

✅ International support

✅ Accurate format validation

✅ Works offline

Cons:

❌ Adds dependencies (may increase bundle size)

❌ Doesn’t check if the number is actually active

Use this approach when format accuracy is important and you support global users.

Using a Phone Validation API (Server or Client)

It’s an online service that accepts a phone number and responds with info like:

  • Whether the number is valid and active
  • Carrier and line type (mobile, landline, VoIP)
  • Location and country

AbstractAPI Phone Validation Example

const apiKey = "YOUR_ABSTRACTAPI_KEY";

const phone = "+14155552671";

fetch(`https://phonevalidation.abstractapi.com/v1/?api_key=${apiKey}&phone=${encodeURIComponent(phone)}`)

  .then(response => response.json())

  .then(data => {

    if (data.valid) {

      console.log("✅ Valid number:", data.international_format);

      console.log("Carrier:", data.carrier);

    } else {

      console.log("❌ Invalid number");

    }

  });

API Benefits

Pros:

✅ Checks if number exists and is active

✅ Offers extra metadata (carrier, location, line type)

✅ Handles global formats for you

Cons:

❌ Requires an internet connection

❌ API key + setup needed

❌ Free plans may have request limits

Use an API when accuracy is critical — like for verifying phone numbers on sign-up.

Example: Simple Phone Number Validation Form

HTML

<form id="phoneForm">

  <label for="phoneInput">Enter phone number:</label>

  <input type="tel" id="phoneInput" name="phoneInput" placeholder="e.g. +1 415 555 2671" />

  <button type="submit">Check Number</button>

  <p id="resultMessage"></p>

</form>

JavaScript

const form = document.getElementById('phoneForm');

const resultMsg = document.getElementById('resultMessage');

form.addEventListener('submit', function(event) {

  event.preventDefault();

  const phone = document.getElementById('phoneInput').value;

  const basicPattern = /^\+?\d{7,15}$/;

  if (!basicPattern.test(phone)) {

    resultMsg.textContent = "❌ Please enter a valid phone number format.";

    resultMsg.style.color = "red";

    return;

  }

  resultMsg.textContent = "Checking number...";

  fetch(`https://phonevalidation.abstractapi.com/v1/?api_key=YOUR_ABSTRACTAPI_KEY&phone=${encodeURIComponent(phone)}`)

    .then(res => res.json())

    .then(data => {

      if (data.valid) {

        resultMsg.textContent = "✅ Phone number is valid!";

        resultMsg.style.color = "green";

      } else {

        resultMsg.textContent = "❌ Phone number is invalid.";

        resultMsg.style.color = "red";

      }

    })

    .catch(() => {

      resultMsg.textContent = "⚠️ Error checking number.";

      resultMsg.style.color = "red";

    });

});

Best Practices for Phone Input UX and Validation

Creating a seamless user experience for phone number input and validation goes beyond just checking the format. It’s about reducing user friction, ensuring accessibility, and making sure the data you collect is clean, consistent, and actionable.

Here are the top best practices—expanded with clear examples and technical tips:

✅ Use the Right Input Type

Always use the HTML5 <input type="tel"> for phone number fields:

  • <input type="tel" name="phone" id="phone" placeholder="+1 415 555 2671" />

Why?

  • Shows a numeric keypad on mobile devices
  • Helps with accessibility and form autofill
  • Makes input easier and faster

✅ Let Users Format Naturally (and Clean Behind the Scenes)

Don’t force users to enter a number in one strict format. People often type what they’re used to: +1 415 555 2671, 415-555-2671, (415)555-2671.

Instead, sanitize the input before validation:

  • function normalizePhone(input) {

  return input.replace(/[^\d+]/g, '');

}

This removes dashes, parentheses, and spaces—keeping the number clean and usable.

✅ Provide Real-Time Feedback

Validate as the user types or after they leave the input (on blur):

  • input.addEventListener('blur', () => {

  const number = normalizePhone(input.value);

 if (!isValidNumber(number)) {

   showError("Invalid phone number format.");

  } else {

    showSuccess("Looks good!");

  }

});

Benefits:

  • Users know immediately if they made a mistake
  • Reduces form errors on submission
  • Increases form completion rates

✅ Add a Country Picker (if you support international users)

Use a country selector to auto-format the number based on the selected region. Libraries like intl-tel-input provide a great UI:

  • const input = document.querySelector("#phone");

intlTelInput(input, {

  initialCountry: "auto",

geoIpLookup: callback => {

fetch("https://ipinfo.io/json?token=YOUR_TOKEN")

.then(res => res.json())

 .then(data => callback(data.country));

  }

});

This approach:

  • Reduces user errors by setting the default country code
  • Helps format numbers correctly
  • Improves the global user experience

✅ Always Store Numbers in a Standardized Format

Use the E.164 format for storing phone numbers:

  • +14155552671

This ensures:

  • Consistent formatting
  • Compatibility with APIs and messaging services
  • Easier number comparisons or lookups in your database

If you're using libphonenumber-js, format numbers like this:

const phone = parsePhoneNumberFromString("+1 415 555 2671");

const standardized = phone.format("E.164"); // +14155552671

✅ Provide Clear Instructions and Examples

Sometimes users aren’t sure how to enter their number. A placeholder can help:

  • <input type="tel" placeholder="e.g. +44 7700 900123" />

You can also add helper text below the field:

  • <small>Include your country code (e.g., +1 for the US)</small>

✅ Ensure Accessibility and Mobile Responsiveness

Make your phone number input accessible to screen readers and keyboard users:

  • Use <label for="phone">Phone number</label>
  • Provide aria-describedby for error/help messages
  • Ensure color contrast for error text (e.g., red on white background)

Also, test the input on various screen sizes—especially mobile!

✅ Validate Both Client-Side and Server-Side

While client-side validation improves UX, never rely on it alone. Always validate phone numbers on the server before storing or using them.

Client-side:

  • if (!regex.test(number)) {

  return showError("Invalid number");

}

  • Server-side (e.g., with Node or Python):

// Use libphonenumber-js or an API again on the server

✅ Prevent Typos with Autofill and Input Masks (Optional)

You can use input masks to guide users while typing:

  • <input type="tel" id="phone" pattern="\d{3}[\-]\d{3}[\-]\d{4}" placeholder="123-456-7890">

Or use a JavaScript masking library like cleave.js.

But use masks carefully—they can frustrate users if done wrong or if international input is required.

✅ Handle Edge Cases Gracefully

Sometimes users will:

  • Enter duplicate country codes (+1 +1 415...)
  • Include extension numbers (+1 555 1234 ext. 99)
  • Mistype (+1--415....)

Make your validation and error messaging resilient and forgiving. Don’t just say “Invalid number”—guide the user toward fixing it.

✅ Combine Format + Existence Validation

Use regex or a library to validate the format and an API (like AbstractAPI) to check if the number actually exists and is reachable.

This layered approach gives you both speed and accuracy:

  • if (!regex.test(userInput)) {

  return showError("Check your number format");

}

const isActive = await validateWithAPI(userInput);

if (!isActive) {

  return showError("This number doesn’t appear to be real");

}

✅ Consider Rate Limits and Security with API Use

When using a phone validation API:

  • Avoid checking on every keystroke
  • Debounce requests (e.g., only validate after 500ms of no typing)
  • Protect your API keys using environment variables or proxying

FAQs: Common Questions on JavaScript Phone Validation

How do I check if a phone number is valid in JavaScript?

Use a regex pattern for format, or a library like libphonenumber-js for accurate format validation. For real-time checking, use an API like AbstractAPI.

What regex should I use for phone number validation in JS?

A common one is /^\(?\d{3}\)?[- ]?\d{3}[- ]?\d{4}$/ for US numbers. For international formats, try /^\+?\d{7,15}$/.

Is regex enough for validating phone numbers?

No. It only checks format—not if the number is real. Use libraries or APIs for robust validation.

Comparing Phone Number Validation Methods in JavaScript

JavaScript offers several effective methods to validate phone numbers, each with unique strengths and trade-offs. Whether you're working on a simple form or a global platform, choosing the right approach depends on your specific use case, accuracy needs, and implementation complexity. Below, we compare the three main methods:

Method Strengths Limitations Use Case
Regex - Fast, lightweight
- No dependencies
- Great for quick client-side format checks
- Doesn't check if the number is real
- Hard to handle global formats
- Can be error-prone if not carefully written
Simple validation on websites or apps with known input formats (e.g., US-only numbers)
Libraries (e.g., libphonenumber-js) - Reliable format validation
- Supports international phone validation in JS
- No internet connection required
- Helps normalize phone numbers (e.g., into E.164 format)
- Adds extra file size (up to ~200 KB)
- Requires setup and import
- Still doesn’t verify if the number is active
Apps needing accurate, offline validation for a variety of country formats
APIs (e.g., AbstractAPI) - Most accurate and reliable
- Validates if a number is real and active
- Returns metadata (carrier, location, line type)
- Supports international numbers and frequent updates
- Requires API key and HTTP request
- Internet required
- Usage limits depending on the plan
Critical use cases like user registration, SMS delivery, fraud detection, or analytics

Which Should You Use?

For quick format checks: A regular expression is the fastest and easiest. For validating international formats: Use a library like libphonenumber-js.

For the most accurate results and enriched data: An API like AbstractAPI's Phone Validation is the best choice.

Tip: For optimal UX and reliability, combine these methods—start with regex for format, then confirm validity with an API.

Nicolas Rios

Head of Product at Abstract API

Get your free
Phone Validation
key now
See why the best developers build on Abstract
get started for free

Related Articles

Get your free
Phone Validation
key now
stars rating
4.8 from 1,863 votes
See why the best developers build on Abstract
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.
No credit card required