Phone Number Validation in Node.js — E.164 & Line Type Detection

1. The problem with phone number validation

Phone numbers are everywhere in modern applications. You need them for SMS verification, two-factor authentication (2FA), delivery notifications, customer support callbacks, and marketing campaigns. A bad phone number means an undeliverable OTP, a failed 2FA flow, or a wasted SMS that costs you money.

The problem is that phone number formats vary dramatically across more than 200 countries and territories. A valid mobile number in Poland looks nothing like one in Japan or Brazil. Users enter numbers with spaces, dashes, parentheses, leading zeroes, country codes, or none of the above. They paste from contacts, type from memory, or copy from a website with arbitrary formatting.

On top of format differences, there are line types to consider. A number might be a mobile line, a landline, a VOIP number, a toll-free line, or a premium-rate number. If you're sending SMS for 2FA, you need a mobile number — sending an OTP to a landline won't work. If you're running a call center, you want to detect premium-rate numbers before dialing them and incurring charges.

2. The naive approach: regex (and why it fails)

The first instinct is to reach for a regular expression. Something like this:

// A common (but broken) phone number regex
const phoneRegex = /^\+?1?\d{10}$/;

function isValidPhone(phone) {
  return phoneRegex.test(phone.replace(/[\s\-().]/g, ''));
}

// Works for US numbers:
isValidPhone('+1 (555) 123-4567');  // true ✓
isValidPhone('5551234567');          // true ✓

// Fails for valid numbers from other countries:
isValidPhone('+48 600 123 456');     // false ✗  (Polish mobile — 9 digits)
isValidPhone('+44 7911 123456');     // false ✗  (UK mobile — 10 digits)
isValidPhone('+91 98765 43210');     // false ✗  (Indian mobile — 10 digits)
isValidPhone('+81 90 1234 5678');    // false ✗  (Japanese mobile — 10 digits)
isValidPhone('+49 170 1234567');     // false ✗  (German mobile — 10-11 digits)
isValidPhone('+55 11 91234 5678');   // false ✗  (Brazilian mobile — 11 digits)

This regex assumes all phone numbers are 10 digits long with an optional US country code. It immediately rejects valid numbers from most of the world. You might try to fix it by allowing a wider digit range:

// "Fixed" regex — accepts 7 to 15 digits
const betterRegex = /^\+?\d{7,15}$/;

// Now it accepts too much:
betterRegex.test('1234567');          // true — but is this a real number?
betterRegex.test('999999999999999');  // true — 15 random digits
betterRegex.test('+00 000 000 000');  // true after stripping — no such country

// And still can't tell you:
// - Is it a mobile or landline?
// - What country does it belong to?
// - What's the E.164 normalized form?
// - Is the number length correct for its country?

The fundamental issue is that a regex can only check character patterns. It cannot verify that the country code exists, that the number length is correct for that specific country, or that the number plan allocation is valid. Regex also tells you nothing about the line type — you cannot distinguish a mobile number from a landline, VOIP, or toll-free number with pattern matching alone.

3. Why phone validation is genuinely hard

4. The right solution: one API call

The IsValid Phone API validates phone numbers from 200+ countries in a single GET request. It handles format normalization, country detection, length validation, and line type detection — and returns the number in E.164, national, and international formats.

Get your free API key at isvalid.dev. The free tier includes 100 calls per day — enough for development and low-volume production use.

Full parameter reference and response schema: Phone Validation API docs →

5. Node.js code example

Using the IsValid SDK or the native fetch API.

import { createClient } from '@isvalid-dev/sdk';

const iv = createClient({ apiKey: process.env.ISVALID_API_KEY });

// ── Validate with full international number ─────────────────────────────────

const result = await iv.phone('+48600123456');

if (!result.valid) {
  console.log('Invalid phone number');
} else {
  console.log(`Valid ${result.type} number from ${result.countryCode}`);
  console.log('E.164:', result.e164);
  console.log('National:', result.national);
  console.log('International:', result.international);
  console.log('Calling code:', result.callingCode);
}

// ── Validate with national format + country hint ────────────────────────────

const result2 = await iv.phone('600123456', { countryCode: 'PL' });

if (result2.valid) {
  console.log(`Normalized: ${result2.e164}`);
  // → Normalized: +48600123456
}

// routes/auth.js (Express)
app.post('/register', async (req, res) => {
  const { phone, countryCode, ...userData } = req.body;

  let phoneCheck;
  try {
    phoneCheck = await validatePhone(phone, { countryCode });
  } catch {
    return res.status(502).json({ error: 'Phone validation service unavailable' });
  }

  if (!phoneCheck.valid) {
    return res.status(400).json({ error: 'Invalid phone number' });
  }

  // Reject non-mobile numbers for SMS-based 2FA
  if (phoneCheck.type !== 'MOBILE' && phoneCheck.type !== 'FIXED_LINE_OR_MOBILE') {
    return res.status(400).json({
      error: 'Please provide a mobile number for SMS verification',
    });
  }

  // Store the E.164-normalized number
  const user = await createUser({
    ...userData,
    phone: phoneCheck.e164,         // +48600123456
    phoneCountry: phoneCheck.countryCode, // PL
  });

  // Send OTP via Twilio / AWS SNS using the E.164 number
  await sendOtp(phoneCheck.e164);

  res.json({ success: true, userId: user.id });
});

6. cURL example

Validate an international phone number:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.isvalid.dev/v0/phone?value=%2B48600123456"

With a country code hint (useful for national-format numbers):

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.isvalid.dev/v0/phone?value=600123456&countryCode=PL"

Validate a US number:

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.isvalid.dev/v0/phone?value=%2B12125551234"

7. Understanding the response

Valid Polish mobile number:

{
  "valid": true,
  "countryCode": "PL",
  "callingCode": "48",
  "nationalNumber": "600123456",
  "type": "MOBILE",
  "e164": "+48600123456",
  "national": "600 123 456",
  "international": "+48 600 123 456"
}

Invalid phone number:

{
  "valid": false
}

8. Edge cases to handle

// Detect country from Accept-Language header as a fallback
function getCountryHint(req) {
  // Prefer explicit user selection
  if (req.body.countryCode) return req.body.countryCode;

  // Fall back to Accept-Language
  const lang = req.headers['accept-language']?.split(',')[0]; // e.g. "pl-PL"
  const country = lang?.split('-')[1]?.toUpperCase();
  return country || undefined;
}

// All of these represent the same number — the API handles them all
'+48 600 123 456'     // international with spaces
'0048600123456'       // international dialing prefix (00)
'600-123-456'         // national with dashes (needs countryCode: 'PL')
'(600) 123 456'       // national with parentheses
'+48.600.123.456'     // dots as separators