5 Ways to Validate Phone Numbers in Zod

Validating phone numbers in Zod is a common step for maintaining data quality in applications. We'll explore five ways to implement this with code snippets, look at the drawbacks of traditional approaches, and see how Abstract API helps overcome them without the usual trade-offs.

How to Implement Phone Number Validation in Zod

Here are four common methods to validate phone numbers in Zod. Each approach uses a different tool or technique, from simple regular expressions to specialized libraries for comprehensive checks.

Direct Regex Match

When you only need a basic syntactic check, you can use Zod’s built-in `regex` method. This approach uses a regular expression to validate the phone number's format. It requires no external dependencies and executes quickly in any JavaScript environment, as shown in this example.

const phone = z.string().regex(/^([+]?[\s0-9]+)?(\d{3}|[(]?[0-9]+[)])?([-]?[\s]?[0-9])+$/, 'invalid');

.refine() with validator.js

For more specific validation, you can combine Zod's `refine` method with the `validator.js` library. The library's `isMobilePhone` function encapsulates a maintained catalog of country-specific rules, which helps keep the main Zod schema clean and readable. This method checks against numerous regional formats.

import validator from 'validator';
const phone = z.string().refine(v => validator.isMobilePhone(v, 'any'), { message: 'invalid' });

transform / superRefine with libphonenumber-js

A more powerful option involves the `libphonenumber-js` library, often used with Zod's `transform` method. This combination can parse, validate, and normalize phone numbers into the standard E.164 format. The code attempts to parse the input, and if it is a valid number, it returns the normalized version, as detailed in this Zod issue.

import { parsePhoneNumberFromString } from 'libphonenumber-js';
const phone = z
  .string()
  .transform((v, ctx) => {
    const p = parsePhoneNumberFromString(v, { defaultCountry: 'US', extract: false });
    if (!p?.isValid()) {
      ctx.addIssue({ code: z.ZodIssueCode.custom, message: 'invalid' });
      return z.NEVER;
    }
    return p.number;
  });

z.e164() in Zod 4

Zod 4 introduced a dedicated `e164` helper for validating numbers against the strict E.164 profile. This built-in function is a simple regex that confirms the number starts with a '+' and is followed by one to fifteen digits. It offers a clean API surface without extra code.

const phone = z.e164();

Challenges of Phone Number Validation in Zod

These methods offer quick solutions but introduce significant issues with maintenance and accuracy. The validation often fails to confirm if a number is actually usable in a production environment.

• Zod lacks a native phone schema. This forces developers to use large, static regex patterns that break as global numbering rules change. This approach creates brittle code and high maintenance overhead.
• Libraries like libphonenumber-js accept non-dialable numbers. Zod's refine method simply forwards the library's result, which allows invalid numbers to pass validation unless you add extra logic to catch these edge cases.
• The metadata in libraries like libphonenumber-js often lags behind official numbering plan updates. A validator built on this library can reject valid new numbers or approve old, deprecated ones until the data updates.
• Zod only validates a number's format, not its real-world status. A syntactically correct number from z.e164() might be unreachable or unassigned. The validation provides no guarantee the number is actually usable.