A simpler and smaller rewrite of Google Android's libphonenumber library in javascript/TypeScript.
Parse and format personal phone numbers.
If you’re trying to build a React component with it, take a look at react-phone-number-input.
Google's libphonenumber is an ultimate phone number formatting and parsing library developed by Google for Android phones. It is written in C++ and Java, and, while it has an official autogenerated javascript port, that port is tightly coupled to Google's closure javascript framework, and, when compiled into a bundle, weighs about 550 kB (350 kB code + 200 kB metadata).
With many websites today asking for user's phone number, the internet could benefit from a simpler and smaller library that would just deal with parsing or formatting personal phone numbers, and that's what libphonenumber-js is.
-
Smaller footprint:
145 kB(65 kB code + 80 kB sufficient metadata) vs the original Google's550 kB(350 kB code + 200 kB full metadata). -
Can search for phone numbers in text. Google's autogenerated javascript port doesn't provide such feature for some reason.
-
Focuses on parsing and formatting personal phone numbers while skipping any other "special" cases like:
-
Emergency phone numbers like
911. -
"Short codes" — short SMS-only numbers like
12345. -
Numbers starting with an
*. For example,*555is used in New Zeland to report non-urgent traffic incidents. Or, in Israel, certain advertising numbers start with a*. -
Australian
13-smart numbers, which are a "catchy" "short" form of regular "landline" numbers and are mainly used in advertisement. -
Alphabetic phone numbers like
1-800-GOT-MILK. People don't input their phone numbers like that. It was only used in advertisement in the days of push-button telephones. -
"Two-in-one" phone numbers with "combined" extensions like
(530) 583-6985 x302/x2303. Phone numbers like that actually represent two separate phone numbers, so it's not clear which one to pick or how to return both at the same time. -
Local numbers with the "area code" omitted. For example, when dialing phone numbers within the same "area", people sometimes skip the "area code", and dial, say, just
456-789instead of proper(123) 456-789. This all is considered a relic of the past. In the modern world, there're no "local areas" and anyone could call everyone else around the world.
-
-
Doesn't provide "geolocation" feature when it can tell a city by a phone number.
-
Doesn't use hyphens or brackets when formatting phone numbers in international format. Instead, whitespace is used. The rationale is that brackets aren't relevant in international context because there're no "local areas", and hyphens aren't used because whitespace just looks cleaner.
-
Doesn't set
.countryto"001"when parsing "non-geographic" phone numbers, like mobile satellite communications services. Instead,.countryis set toundefinedin those cases, and instead a developer can call.isNonGeographic()method of thePhoneNumberinstance to find out whether the parsed phone number is a "non-geographic" one. -
Doesn't provide the equivalent of
libphonenumber'sformatNumberForMobileDialing()function that formats a number for dialing from a mobile phone within the same country. This feature may be required for dialing local numbers from a mobile phone in some countries like Brazil or Colombia where they require adding "carrier codes" when making such calls. Sincelibphonenumber-jsis not a dialing library (we're not Android phone operaing system), it doesn't prepend any "carrier codes" when formatting such phone numbers, though it does parse such "carrier codes" correctly. -
Fixed a small bug when Canadian numbers
+1310xxxxwheren't considered possible.
On March 9th, 2020, GitHub, Inc. silently banned my account — erasing all my repos, issues and comments, even in my employer's private repos — without any notice or explanation. Because of that, all source codes had to be promptly moved to GitLab. The GitHub repo is now only used as a backup (although you can still "star" it), and the primary repo is now the GitLab one. For users' convenience, issues can be reported in both places.
If you're about to report an issue, see bug reporting instructions.
via npm
$ npm install libphonenumber-js --savevia yarn
$ yarn add libphonenumber-jsAlternatively, one could include it on a web page directly via a <script/> tag.
Parses a complete phone number.
import parsePhoneNumber from 'libphonenumber-js'
const phoneNumber = parsePhoneNumber(' 8 (800) 555-35-35 ', 'RU')
if (phoneNumber) {
phoneNumber.country === 'RU'
phoneNumber.number === '+78005553535'
phoneNumber.isPossible() === true
phoneNumber.isValid() === true
// Note: `.getType()` requires `/max` metadata: see below for an explanation.
phoneNumber.getType() === 'TOLL_FREE'
}Formats a complete phone number.
import parsePhoneNumber from 'libphonenumber-js'
const phoneNumber = parsePhoneNumber('+12133734253')
if (phoneNumber) {
phoneNumber.formatInternational() === '+1 213 373 4253'
phoneNumber.formatNational() === '(213) 373-4253'
phoneNumber.getURI() === 'tel:+12133734253'
}Parses and formats an incomplete phone number.
import { AsYouType } from 'libphonenumber-js'
new AsYouType().input('+12133734')
// Returns: '+1 213 373 4'
new AsYouType('US').input('2133734')
// Returns: '(213) 373-4'Validates a complete phone number.
import {
isPossiblePhoneNumber,
isValidPhoneNumber,
validatePhoneNumberLength
} from 'libphonenumber-js'
isPossiblePhoneNumber('8 (800) 555-35-35', 'RU') === true
isValidPhoneNumber('8 (800) 555-35-35', 'RU') === true
validatePhoneNumberLength('8 (800) 555', 'RU') === 'TOO_SHORT'
validatePhoneNumberLength('8 (800) 555-35-35', 'RU') === undefined // Length is valid.isPossiblePhoneNumber() only validates phone number length, while isValidPhoneNumber() validates both phone number length and phone number digits.
validatePhoneNumberLength() is just a more detailed version of isPossiblePhoneNumber() — if the phone number length is invalid, instead of just returning false, it returns the actual reason why the phone number length is incorrect: TOO_SHORT, TOO_LONG, etc.
Finds complete phone numbers in text.
import { findPhoneNumbersInText } from 'libphonenumber-js'
findPhoneNumbersInText(`
For tech support call +7 (800) 555-35-35 internationally
or reach a local US branch at (213) 373-4253 ext. 1234.
`, 'US')
// Outputs:
//
// [{
// number: PhoneNumber {
// country: 'RU',
// countryCallingCode: '7',
// number: '+78005553535',
// nationalNumber: '8005553535'
// },
// startsAt : 22,
// endsAt : 40
// }, {
// number: PhoneNumber {
// country: 'US',
// countryCallingCode: '1',
// number: '+12133734253',
// nationalNumber: '2133734253',
// ext: '1234'
// },
// startsAt : 86,
// endsAt : 110
// }]This library provides different "metadata" sets, where a "metadata" set is a complete list of phone number parsing and formatting rules for all possible countries.
As one may guess, the complete list of those rules is huge, so this library provides a way to optimize bundle size by choosing between max, min, mobile or "custom" metadata:
-
min— (default) The smallest metadata set- Is about
80 kilobytesin size (libphonenumber-js/metadata.min.jsonfile) - Choose this when:
- You don't need to detect phone number type — "fixed line", "mobile", etc — via
.getType() - You're fine with just validating phone number length via
.isPossible()and you don't need to strictly validate phone number digits via.isValid()
- You don't need to detect phone number type — "fixed line", "mobile", etc — via
- Is about
-
max— The complete metadata set- Is about
145 kilobytesin size (libphonenumber-js/metadata.max.jsonfile) - Choose this when:
- The basic
.isPossible()phone number length check is not enough for you and you need the strict phone number digits validation via.isValid() - You need to detect phone number type — "fixed line", "mobile", etc — via
.getType()
- The basic
- Is about
-
mobile— The complete metadata set for dealing with mobile numbers only- Is about
95 kilobytesin size (libphonenumber-js/metadata.mobile.jsonfile) - Choose this when:
- You need
maxmetadata capabilities and you only accept mobile numbers- It will still be able to handle non-mobile numbers just fine, with the only difference that
.isValid()or.isPossible()might potentially returnfalsefor them, or.getType()might potentially returnundefined.
- It will still be able to handle non-mobile numbers just fine, with the only difference that
- You need
- Is about
Choose one from the above and then simply import the functions from the relevant sub-package:
min—libphonenumber-js/min, or justlibphonenumber-js, since it's the default.max—libphonenumber-js/maxmobile—libphonenumber-js/mobile
As for "custom" metadata, it could be used in those rare cases when not all countries are needed and a developer would really prefer to reduce the bundle size to a minimum. In that case, one could generate their own "custom" metadata set and then import the functions from libphonenumber-js/core sub-package which doesn't come pre-packaged with any metadata and instead accepts metadata as the last argument of each exported function.
A "country code" is a two-letter ISO country code (like "US").
This library supports all officially assigned ISO alpha-2 country codes, plus a few extra ones: AC (Ascension Island), TA (Tristan da Cunha), XK (Kosovo).
To check whether a country code is supported, use isSupportedCountry() function.
There're several calling codes that don't belong to any country:
+800— Universal International Toll Free Number+808— Universal International Shared Cost Number+870— Inmarsat Global Limited+878— Universal Personal Telecommunications+881— Global Mobile Satellite System+882and+883— International Networks+888— United Nations Office for the Coordination of Humanitarian Affairs+979— International Premium Rate Service
Such phone numbering plans are called "non-geographic", and their phone numbers' country is undefined.
"National (significant) number" is all national phone number digits, excluding the "national prefix". Examples:
- International number:
+1 213 373 4253. Country:"US". National number:(213) 373-4253. National (significant) number:213 373 4253 - Inetrnational number:
+33 1 45 45 32 45. Country:"FR". National number:01 45 45 32 45. Notice the0at the start of the national number — it's because in France they add0"national prefix" when writing phone numbers in national format. National (significant) number:1 45 45 32 45(doesn't include the "national prefix").
"Country calling code" is all digits between the + and the national (significant) number in a number that is written in international format. Examples:
- International number:
+1 213 373 4253. Country:"US". National (significant) number:213 373 4253. Country calling code:1 - Inetrnational number:
+33 1 45 45 32 45. Country:"FR". National (significant) number:1 45 45 32 45. Country calling code:33
Several countries could share the same "country calling code". For example, NANPA countries like USA and Canada share the same 1 country calling code.
Parses a complete phone number from string.
Can be imported either as a "default" export or as a "named" export called parsePhoneNumberFromString.
import parsePhoneNumber from 'libphonenumber-js'
// import { parsePhoneNumberFromString as parsePhoneNumber } from 'libphonenumber-js'
const phoneNumber = parsePhoneNumber('(213) 373-42-53 ext. 1234', 'US')
if (phoneNumber) {
console.log(phoneNumber.formatNational())
}Returns an instance of PhoneNumber class, or undefined if no phone number could be parsed from the input string. That could be for a number of reasons. For example, the phone number in the input string could be incomplete, or it could contain a phone number that has an invalid country calling code, etc.
Available options:
-
defaultCountry: string— Default country for parsing numbers written in non-international form (without a+sign). Will be ignored when parsing numbers written in international form (with a+sign). Instead of passing it asoptions.defaultCountry, one could also pass it as a standalonedefaultCountryargument (for convenience). -
defaultCallingCode: string— Default calling code for parsing numbers written in non-international form (without a+sign). Will be ignored when parsing numbers written in international form (with a+sign). It could be specified when parsing phone numbers belonging to "non-geographic numbering plans" which by nature don't have a country code, making thedefaultCountryoption unusable. -
extract: boolean— Defines the "strictness" of parsing a phone number. By default, theextractflag istruemeaning that it will attempt to extract the phone number from an input string like"My phone number is (213) 373-4253 and my hair is blue". This could be thought of as "less strict" parsing. To make it "more strict", one could passextract: falseflag, in which case the function will attempt to parse the input string as if the whole string was a phone number. Applied to the example above, it would returnundefinedbecause the entire string is not a phone number, but for an input string"(213) 373-4253"it would return a parsedPhoneNumber.
If a developer wants to know the exact reason why the phone number couldn't be parsed then they can use parsePhoneNumberWithError() function which throws an exact error:
import { parsePhoneNumberWithError, ParseError } from 'libphonenumber-js'
try {
const phoneNumber = parsePhoneNumberWithError('(213) 373-42-53 ext. 1234', {
defaultCountry: 'US'
})
} catch (error) {
if (error instanceof ParseError) {
// Not a phone number, non-existent country, etc.
console.log(error.message)
} else {
throw error
}
}Possible errors
-
NOT_A_NUMBER— When the supplied string is not a phone number. For example, when there are no digits:"abcde","+". -
INVALID_COUNTRY- When
defaultCountrydoesn't exist (or isn't supported by this library yet):parsePhoneNumber('(111) 222-3333', 'XX'). - When parsing a non-international number without a
defaultCountry:parsePhoneNumber('(111) 222-3333'). - When an international number's country calling code doesn't exist:
parsePhoneNumber('+9991112223333').
- When
-
TOO_SHORT— When the number is too short. For example, just 1 or 2 digits:"1","+12". -
TOO_LONG— When the national (significant) number is too long (17 digits max) or when the string being parsed is too long (250 characters max).
By default, the parsing function will attempt to extract a phone number from the input string even in cases like "Support: (213) 373-4253 (robot)", which mimicks the behavior of the original Google's libphonenumber library, and is the default behavior for legacy reasons. However, if "strict" input validation is required, one can pass extract: false flag to demand that the whole input string be a viable phone number.
// By default it parses without `extract: false` flag.
// It will "extract" the phone number from the input string.
parsePhoneNumber('Call: (213) 373-4253', 'US') === PhoneNumber
// When parsing the same input string with `extract: false` flag,
// it will return `undefined`, because a phone number can't
// contain letters or a colon.
parsePhoneNumber('Call: (213) 373-4253', {
defaultCountry: 'US',
extract: false
}) === undefined
// When the whole input string represents a phone number,
// parsing it with `extract: false` flag will return a `PhoneNumber`.
parsePhoneNumber('(213) 373-4253', {
defaultCountry: 'US',
extract: false
}) === PhoneNumberPhoneNumber class represents a complete phone number.
PhoneNumber class instance is returned from parsePhoneNumber() function, or it could also be constructed manually from a number in E.164 format:
const phoneNumber = new PhoneNumber('+12133734253')
// (optional) Add a phone number extension.
phoneNumber.setExt('1234')PhoneNumber class instance has the following properties:
number: string— The phone number inE.164format. Example:"+12133734253".countryCallingCode: string— The country calling code. Example:"1".nationalNumber: string— The national (significant) number. Example:"2133734253".country: string?— The country code. Example:"US". Will beundefinedwhen nocountrycould be derived from the phone number. For example, when several countries have the samecountryCallingCodeand thenationalNumberdoesn't look like it belongs to any particular one of them. Or when a number belongs to a non-geographic numbering plan.ext: string?— The phone number extension, if any. Example:"1234".carrierCode: string?— The "carrier code", if any. Example:"15". "Carrier codes" are only used in Colombia and Brazil and only when dialing within those countries from a mobile phone to a fixed line number.
PhoneNumber class instance provides the following methods:
Adds a phone number extension to a phone number.
const phone = "+12133734253"
const phoneExt = "1234"
const phoneNumber = parsePhoneNumber(phone)
if (phoneNumber) {
if (phoneExt) {
phoneNumber.setExt(phoneExt)
}
// Returns "(213) 373-4253 ext. 1234"
return phoneNumber.formatNational()
}Formats the phone number into a string according to a specified format.
Available formats:
NATIONAL— Example:"(213) 373-4253"INTERNATIONAL— Example:"+1 213 373 4253"E.164— Example:"+12133734253"RFC3966(the phone number URI) — Example:"tel:+12133734253;ext=123"IDD— "Out-of-country" dialing format. Example:"011 7 800 555 35 35"for+7 800 555 35 35being called out ofoptions.fromCountry === "US". If nooptions.fromCountrywas passed or if there's no default IDD prefix foroptions.fromCountrythen returnsundefined.
Available options:
-
formatExtension(number, extension)— Formatsnumberandextensioninto a string. By default returns${number} ext. ${extension}for almost all countries with rare exceptions of some special cases like${number} x${extension}for the United Kingdom. -
nationalPrefix: Boolean— Some phone numbers can be formatted both with national prefix and without it. In such cases the library defaults to "with national prefix" (for legacy reasons). PassnationalPrefix: falseoption to force formatting without a national prefix.
Examples:
import parsePhoneNumber from 'libphonenumber-js'
const phoneNumber = parsePhoneNumber('+12133734253')
phoneNumber.format("NATIONAL") === '(213) 373-4253'
phoneNumber.format("INTERNATIONAL") === '+1 213 373 4253'
phoneNumber.format("RFC3966") === 'tel:+12133734253'
// The following are just convenience aliases for the `.format()` function.
phoneNumber.formatNational() === phoneNumber.format("NATIONAL")
phoneNumber.formatInternational() === phoneNumber.format("INTERNATIONAL")
phoneNumber.getURI() === phoneNumber.format("RFC3966")Checks if the phone number is "possible". Only checks the phone number length. Doesn't check the actual phone number digits.
Checks if the phone number is "valid". First checks the phone number length and then checks the phone number digits against all available regular expressions.
By default, this library uses min ("minimal") metadata which is only 80 kB in size but also doesn't include the precise validation regular expressions resulting in less strict validation rules (some very basic validation like number length check is still included for each country). If you don't mind the extra 65 kB of metadata then use max metadata instead of the default (min) one. Google's library always uses "full" metadata so it will yield different isValidNumber() results compared to the "minimal" metadata used by default in this library.
See an example illustrating different results when using /min vs /max vs /mobile metadata
import parseMin from 'libphonenumber-js/min'
import parseMax from 'libphonenumber-js/max'
import parseMobile from 'libphonenumber-js/mobile'
// In Singapore (+65), when a mobile number starts with `8`,
// it can only have the second digit in the range of `0..8`.
// In a number "+6589555555", the second digit is `9`
// which makes it an invalid mobile number.
// This is a "strict" validation rule and it is
// not included in the (default) `min` metadata.
// When using the (default) `min` metadata,
// basic number length check passes (from `8` to `11`)
// and the "loose" national number validation regexp check passes too:
// `(?:1\d{3}|[369]|7000|8(?:\d{2})?)\d{7}`.
parseMin('+6589555555').isValid() === true
// When using `max` or `mobile` metadata,
// the validation regexp for mobile numbers is more precise —
// `(?:8[1-8]|9[0-8])\\d{6}` — as well as the possible lengths (only `8`).
parseMax('+6589555555').isValid() === false
parseMobile('+6589555555').isValid() === falseSee "Using phone number validation feature" for choosing between isPossible() and isValid().
Returns a list of countries that this phone number could possibly belong to.
Can be used when parsing a complete international phone number which contains a "country calling code" that is shared between several countries. If parsing such a phone number returns country: undefined then getPossibleCountries() function could be used to somehow speculate about what country could this phone number possibly belong to.
Returns phone number type — fixed line, mobile, toll free, etc — or undefined if the number is invalid or if there are no phone number type regular expressions for this country in metadata.
By default, this library uses min ("minimal") metadata which is only 80 kB in size but also doesn't include the regular expressions for determining a phone number type — fixed line, mobile, toll free, etc — which could result in getType() returning undefined for most countries. If you don't mind the extra 65 kB of metadata then use max metadata instead of the default (min) one. Google's library always uses "full" metadata so it will yield different getNumberType() results compared to the "minimal" metadata used by default in this library.
The list of possible return values
MOBILE— Cellphones.FIXED_LINE— Stationary phones.FIXED_LINE_OR_MOBILE— Could beMOBILEorFIXED_LINE.PREMIUM_RATE— Callers are charged by call or per minute. SMS text messages are also subject to charge.TOLL_FREE— Free to call from anywhere.SHARED_COST— "An intermediate level of telephone call billing where the charge for calling a particular international or long-distance phone number is partially, but not entirely, paid for by the recipient".VOIP— "IP telephony". Calls are made over the Internet rather than via the conventional telephone-only lines.PERSONAL_NUMBER— Phones connected by satellites.PAGER— "Pagers" are wireless telecommunications devices that were widely used in the 80-es and could receive (and, optionally, send) text or voice messages.UAN— "UAN is a number resource that allows a service or business with several terminating lines to be reached through a unique universal number. A UAN number shall be dialable from the entire Pakistan, based on the applicant’s proposed coverage without dialing the area code. UAN cannot be assigned to two separate business or mutually exclusive public services. Each service provider who allows UAN through its network shall offer a tariff, which is not more expensive than the normal tariff available for a similar non-UAN public service".VOICEMAIL— "A voicemail access number is a telephone number provided by a voicemail service to allow subscribers to dial into their voicemail accounts and manage any currently saved messages. Typically, the number is used when a subscriber is away from home and wishes to check any voice messages currently stored on the service. Originally envisioned as part of the features associated with voicemail accounts offered with land line accounts, many mobile service providers today also supply their customers with a voicemail access number to use when checking messages from any phone other than the mobile or cellular unit associated with the account".
See an example illustrating different results when using /min vs /max vs /mobile metadata
import parseMin from 'libphonenumber-js/min'
import parseMax from 'libphonenumber-js/max'
import parseMobile from 'libphonenumber-js/mobile'
// Singapore (+65) mobile number "+6584655555".
// The (default) `min` bundle doesn't contain any regexps for
// getting phone number type from phone number digits for Singapore.
parseMin('+6584655555').getType() === undefined
// The `max` does contain all the regexps for getting
// phone number type from phone number digits for any country.
parseMax('+6584655555').getType() === 'MOBILE'
// The `max` does contain all the regexps for getting
// mobile phone number type from mobile phone number digits for any country.
parseMobile('+6584655555').getType() === 'MOBILE'Returns true if the number belongs to a "non-geographic numbering plan".
Compares two PhoneNumbers: returns true if they're equal, false otherwise.
Checks if input can be parsed as a "possible" phone number. A phone number is "possible" when it has valid length. The actual phone number digits aren't validated.
isPossiblePhoneNumber('8 (888) 888-88-88', 'RU') === true
isPossiblePhoneNumber('+12223333333') === trueFor the description of the defaultCountry?: string | options?: object argument, see parsePhoneNumber() function description.
This function is just a shortcut for a two-step process of "strictly" parsing a phone number and then calling .isPossible().
Checks if input can be parsed as a "valid" phone number. A phone number is "valid" when it has valid length, and the actual phone number digits match the regular expressions for its country.
isValidPhoneNumber('8 (888) 888-88-88', 'RU') === false
isValidPhoneNumber('8 (800) 555-35-35', 'RU') === true
isValidPhoneNumber('+12223333333') === false
isValidPhoneNumber('+12133734253') === trueFor the description of the defaultCountry?: string | options?: object argument, see parsePhoneNumber() function description.
This function is just a shortcut for a two-step process of "strictly" parsing a phone number and then calling .isValid().
See "Using phone number validation feature" for choosing between isPossible() and isValid().
Same as isValidPhoneNumber() but with the "default country" argument being replaced with an "exact country", which is more strict.
This function is not currently exported from this library. The reason is that its result would be too vague when it returns false — it could mean any of:
- The input is not a valid phone number.
- The input is a valid phone number but it belongs to another country.
- The input is a phone number that belongs to the correct country but is not valid.
At least the second case should be handled separately from a "User Experience" point of view: if the user has input a valid phone number but for another country, they should be notified that "perhaps you meant another country" rather than just throwing "the phone number is incorrect" error in their face.
But for those who'd still like to have such function, here's a possible implementation for it:
export default function isValidPhoneNumberForCountry(phoneNumberString, country) {
const phoneNumber = parsePhoneNumber(phoneNumberString, {
defaultCountry: country,
// Demand that the entire input string must be a phone number.
// Otherwise, it would "extract" a phone number from an input string.
extract: false
})
if (!phoneNumber) {
return false
}
if (phoneNumber.country !== country) {
return false
}
return phoneNumber.isValid()
}The same approach could be used to implement an isPossiblePhoneNumberForCountry() function.
Checks if input phone number length is valid. If it is, then nothing is returned. Otherwise, a rejection reason is returned.
Possible rejection reasons
-
NOT_A_NUMBER— When the supplied string is not a phone number. For example, when there are no digits:"abcde","+". -
INVALID_COUNTRY- When
defaultCountrydoesn't exist (or isn't supported by this library yet):parsePhoneNumber('(111) 222-3333', 'XX'). - When parsing a non-international number without a
defaultCountry:parsePhoneNumber('(111) 222-3333'). - When an international number's country calling code doesn't exist:
parsePhoneNumber('+9991112223333').
- When
-
TOO_SHORT— When the number is too short. For example, just 1 or 2 digits:"1","+12". -
TOO_LONG— When the national (significant) number is too long (17 digits max) or when the string being parsed is too long (250 characters max). -
INVALID_LENGTH— When the national (significant) number is neither too short, nor too long, but somewhere in between and its length is still invalid.
validatePhoneNumberLength('abcde') === 'NOT_A_NUMBER'
validatePhoneNumberLength('444 1 44') === 'INVALID_COUNTRY'
validatePhoneNumberLength('444 1 44', 'TR') === 'TOO_SHORT'
validatePhoneNumberLength('444 1 444', 'TR') === undefined // Length is valid.
validatePhoneNumberLength('444 1 4444', 'TR') === 'INVALID_LENGTH'
validatePhoneNumberLength('444 1 44444', 'TR') === 'INVALID_LENGTH'
validatePhoneNumberLength('444 1 444444', 'TR') === undefined // Length is valid.
validatePhoneNumberLength('444 1 4444444444', 'TR') === 'TOO_LONG'For the description of the defaultCountry?: string | options?: object argument, see parsePhoneNumber() function description.
This function is just a more detailed version of isPossiblePhoneNumber() for those who asked for a more specific rejection reason.
The phone number is parsed "strictly" from the input string.
Creates a formatter for a partially-entered phone number.
For the description of the defaultCountry?: string | options?: object argument, see parsePhoneNumber() function description.
The formatter instance has the following methods:
-
input(text: string)— Appends text to the input. Returns the formatted phone number. -
reset()— Resets the input.
new AsYouType().input('+12133734') === '+1 213 373 4'
new AsYouType('US').input('2133734') === '(213) 373-4'The formatter instance also provides the following getters:
-
getNumber(): PhoneNumber?— Returns thePhoneNumber. Will returnundefinedif no national (significant) number digits have been entered so far, or if nodefaultCountry/defaultCallingCodehas been specified and the user enters a phone number in national format (without a+). -
getNumberValue(): string?— Returns the phone number inE.164format. For example, for default country"US"and input"(222) 333-4444"it will return"+12223334444". Will returnundefinedif no digits have been input, or when the user inputs a phone number in national format (without a+) and no default country or default "country calling code" have been specified. -
getChars(): string— Returns the phone number characters:+sign (if present) and the digits. Returns an empty string if no phone number characters have been input. -
getTemplate(): string— Returns the template that is used to format the phone number characters —+sign (if present) and the digits — which are designated byx-es. Returns an empty string if no phone number characters have been input.
// National phone number input example.
const asYouType = new AsYouType('US')
asYouType.input('2') === '2'
asYouType.getNumber().number === '+12'
asYouType.getChars() === '2'
asYouType.getTemplate() === 'x'
asYouType.input('1') === '21'
asYouType.getNumber().number === '+121'
asYouType.getChars() === '21'
asYouType.getTemplate() === 'xx'
asYouType.input('3') === '(213)'
asYouType.getNumber().number === '+1213'
asYouType.getChars() === '213'
asYouType.getTemplate() === '(xxx)'
asYouType.input('3734253') === '(213) 373-4253'
asYouType.getNumber().number === '+12133734253'
asYouType.getChars() === '2133734253'
asYouType.getTemplate() === '(xxx) xxx-xxxx'
// International phone number input example.
const asYouType = new AsYouType()
asYouType.input('+1-213-373-4253') === '+1 213 373 4253'
asYouType.getNumber().country === 'US'
asYouType.getNumber().number === '+12133734253'
asYouType.getChars() === '+12133734253'
asYouType.getTemplate() === 'xx xxx xxx xxxx'-
isInternational(): boolean— Returnstrueif the phone number is being input in international format. In other words, returnstrueif and only if the parsed phone number starts with a"+". -
getCallingCode(): string?— Returns the "country calling code" part of the phone number. Returnsundefinedif the number is not being input in international format, or if no valid "country calling code" has been entered. Supports "non-geographic" phone numbering plans: even though those aren't technically "countries", they have their own "country calling codes" too. -
getCountry(): string?— Returns a two-letter country code of the phone number. Returnsundefinedfor "non-geographic" phone numbering plans. Returnsundefinedif no phone number has been input yet, or if it couldn't tell what country the phone number belongs to — that could happen when several countries have the same "country calling code" and the phone number doesn't look like it belongs to any particular one of them. -
isPossible(): boolean— Returnstrueif the phone number is "possible". Is just a shortcut forgetNumber()?.isPossible(). -
isValid(): boolean— Returnstrueif the phone number is "valid". Is just a shortcut forgetNumber()?.isValid().
Legacy API (before version 1.6.0)
For legacy API (before version 1.6.0) the formatter instance provides the following getters:
-
country: string?— Phone number country. Will returnundefinedif the country couldn't be derived from the number. -
getNationalNumber(): string— Returns the national (significant) number part of the phone number. -
getTemplate(): string?— Same as the current version ofgetTemplate()with the only difference that it returnsundefinedif no suitable format was found for the number being entered (or if no national (significant) number has been entered so far).
// National phone number input example.
const asYouType = new AsYouType('US')
asYouType.input('2') === '2'
asYouType.getNationalNumber() === '2'
asYouType.input('1') === '21'
asYouType.getNationalNumber() === '21'
asYouType.input('3') === '(213)'
asYouType.getNationalNumber() === '213'
asYouType.input('3734253') === '(213) 373-4253'
asYouType.getNationalNumber() === '2133734253'
// International phone number input example.
const asYouType = new AsYouType()
asYouType.input('+1-213-373-4253') === '+1 213 373 4253'
asYouType.country === 'US'
asYouType.getNationalNumber() === '2133734253'"As You Type" formatter was created by Google as part of their Android OS and therefore only works for numerical keyboard input, i.e. it can only accept digits (and a + sign at the start of an international number). When used on desktops where a user can input all kinds of punctuation (spaces, dashes, parens, etc) it simply ignores everything except digits (and a + sign at the start of an international number).
Google's "As You Type" formatter does not support entering phone number extensions. If your project requires inputting phone number extensions then use a separate input field for that.
Searches for complete phone numbers in text.
Available options:
defaultCountry: stringdefaultCallingCode: string
For the description of defaultCountry or defaultCallingCode, see parsePhoneNumber() function description.
import { findPhoneNumbersInText } from 'libphonenumber-js'
findPhoneNumbersInText(`
For tech support call +7 (800) 555-35-35 internationally
or reach a local US branch at (213) 373-4253 ext. 1234.
`, 'US')
// Outputs:
//
// [{
// number: PhoneNumber {
// country: 'RU',
// countryCallingCode: '7',
// number: '+78005553535',
// nationalNumber: '8005553535'
// },
// startsAt : 22,
// endsAt : 40
// }, {
// number: PhoneNumber {
// country: 'US',
// countryCallingCode: '1',
// number: '+12133734253',
// nationalNumber: '2133734253',
// ext: '1234'
// },
// startsAt : 86,
// endsAt : 110
// }](in previous versions, it was called findNumbers())
Legacy API (before version 1.6.0) example
import { findNumbers } from 'libphonenumber-js'
findNumbers(`
For tech support call +7 (800) 555-35-35 internationally
or reach a local US branch at (213) 373-4253 ext. 1234.
`, 'US')
// Outputs:
//
// [{
// phone : '8005553535',
// country : 'RU',
// startsAt : 22,
// endsAt : 40
// },
// {
// phone : '2133734253',
// country : 'US',
// ext : '1234',
// startsAt : 86,
// endsAt : 110
// }]By default it processes the whole text and then outputs the phone numbers found. If the text is very big (say, a hundred thousand characters) then it might freeze the user interface for a couple of seconds. To avoid such lags one could employ "iterator" approach using searchPhoneNumbersInText() to perform the search asynchronously (e.g. using requestIdleCallback or requestAnimationFrame).
(in previous versions, it was called searchNumbers())
Asynchronous search example using searchPhoneNumbersInText()
ES6 iterator:
import { searchPhoneNumbersInText } from 'libphonenumber-js'
const text = `
For tech support call +7 (800) 555-35-35 internationally
or reach a local US branch at (213) 373-4253 ext. 1234.
`
async function() {
for (const number of searchPhoneNumbersInText(text, 'US')) {
console.log(number)
await new Promise(resolve => setTimeout(resolve, 0))
}
console.log('Finished')
}Java-style iterator (for those still not using ES6):
import { PhoneNumberMatcher } from 'libphonenumber-js'
const matcher = new PhoneNumberMatcher(`
For tech support call +7 (800) 555-35-35 internationally
or reach a local US branch at (213) 373-4253 ext. 1234.
`, {
defaultCountry: 'US',
v2: true
})
// Search cycle iteration.
const iteration = () => {
if (matcher.hasNext()) {
console.log(matcher.next())
setTimeout(iteration, 0)
} else {
console.log('Finished')
}
}
// Run the search.
iteration()Although Google's javascript port doesn't provide the findPhoneNumbersInText() function, the Java and C++ ports do. I guess that's because Google just doesn't need to crawl phone numbers on Node.js because they do it in Java or C++. Still, javascript nowadays is the most popular programming language given its simplicity and user-friendliness. The findPhoneNumbersInText() function provided by this library is a port of Google's PhoneNumberMatcher.java into javascript.
Returns an example phone number for a country. Returns an instance of PhoneNumber class. Will return undefined if country doesn't exist or isn't supported by this library.
import examples from 'libphonenumber-js/mobile/examples'
import { getExampleNumber } from 'libphonenumber-js'
const phoneNumber = getExampleNumber('RU', examples)
phoneNumber.formatNational() === '8 (912) 345-67-89'Checks if a country is supported by this library.
isSupportedCountry('RU') === true
isSupportedCountry('XX') === falseReturns a list of supported countries.
getCountries() === ["AC", "AD", ...]Returns country calling code for a country. Will throw an error if country doesn't exist or isn't supported by this library.
getCountryCallingCode('RU') === '7'
getCountryCallingCode('IL') === '972'Returns phone number extension prefix for a given country. If no custom ext prefix is defined for a country then the default " ext. " prefix is returned.
getExtPrefix('US') === ' ext. '
getExtPrefix('GB') === ' x'Parses digits from string. Can be used for building a phone number extension input component (e.g. react-phone-number-input).
parseDigits('x123') === '123'
parseDigits('٤٤٢٣') === '4423'Parses phone number characters (+ and digits). Can be used for building a phone number input component (e.g. react-phone-number-input).
parseIncompletePhoneNumber('8 (800) 555') === '8800555'
parseIncompletePhoneNumber('+7 800 555') === '+7800555'
parseIncompletePhoneNumber('+٤٤٢٣٢٣٢٣٤') === '+442323234'Parses next character of an input string while parsing phone number digits (including a +) from that string. Basically, it discards everything except + and digits, and + is only allowed at the start of a phone number.
This function is a low-level one that is currently only used in react-phone-number-input with input-format. Frankly speaking, that's the only reason why this function is exported. Other developers, perhaps, should just ignore it and use parseIncompletePhoneNumber() instead because it's much simpler.
// Suppose a user inputs a "+1 (213) 373-42-53" string
// and it starts parsing that string character-by-character.
parsePhoneNumberCharacter('+', undefined) === '+'
parsePhoneNumberCharacter('1', '+') === '1'
parsePhoneNumberCharacter(' ', '+1') === undefined
parsePhoneNumberCharacter('(', '+1') === undefined
parsePhoneNumberCharacter('2', '+1') === '2'
parsePhoneNumberCharacter('1', '+12') === '1'
parsePhoneNumberCharacter('3', '+121') === '3'
parsePhoneNumberCharacter(')', '+1213') === undefined
parsePhoneNumberCharacter(' ', '+1213') === undefined
parsePhoneNumberCharacter('3', '+1213') === '3'
parsePhoneNumberCharacter('7', '+12133') === '7'
parsePhoneNumberCharacter('3', '+121337') === '3'
parsePhoneNumberCharacter('-', '+121337') === undefined
parsePhoneNumberCharacter('4', '+1213373') === '4'
parsePhoneNumberCharacter('2', '+12133734') === '2'
parsePhoneNumberCharacter('-', '+12133734') === undefined
parsePhoneNumberCharacter('5', '+121337342') === '5'
parsePhoneNumberCharacter('3', '+1213373425') === '3'So basically, it's the same as parseIncompletePhoneNumber() with the only difference that it operates at a character-by-character level rather than at a string-as-a-whole level.
The optional eventListener argument is a function of eventName: string argument. It will be called with an "end" argument in a situation when the application should stop parsing the input string. Currently, the only situation when that could happen is when it encounters an "out-of-place" + character. For example, when parsing a "+1 (234) + 56-78" string, it would emit an "end" event at the second + character so that the application could return "+1234" rather than "+12345678".
Formats a possibly incomplete phone number.
While the usual parsePhoneNumber(string).format() function could only be used to format a complete phone number, this function could be used to format a possibly incomplete phone number.
The value argument should be a (possibly incomplete) phone number in E.164 format.
For the description of the defaultCountry?: string | options?: object argument, see parsePhoneNumber() function description.
This function is just an alias for new AsYouType(defaultCountry, metadata).input(value). It can be used for building a phone number input component (e.g. react-phone-number-input).
// National numbers, with second argument.
formatIncompletePhoneNumber('8800555', 'RU') === '8 (800) 555'
formatIncompletePhoneNumber('8800555', { defaultCountry: 'RU' }) === '8 (800) 555'
formatIncompletePhoneNumber('8800555', { defaultCallingCode: '7' }) === '8 (800) 555'
// International numbers, without second argument.
formatIncompletePhoneNumber('+7800555') === '+7 800 555'Legacy API (before version 1.6.0): parse(), parseNumber(), format(), formatNumber(), isValidNumber(), getNumberType().
(previously called parse())
(legacy API)
Attempts to parse a phone number from text.
If defaultCountry is passed then it's gonna be the default country for parsing non-international phone numbers.
Returns { country, phone, ext } object where
countryis a country code.phoneis a national (significant) number.extis a phone number extension.
If the phone number supplied isn't valid then an empty object {} is returned.
Examples
// Parses international numbers.
parseNumber('+1 213 373 4253') === { country: 'US', phone: '2133734253' }
parseNumber('Phone: +1-213-373-4253.') === { country: 'US', phone: '2133734253' }
parseNumber('+12133734253') === { country: 'US', phone: '2133734253' }
// Parses national numbers provided a default country.
parseNumber('Phone: (213) 373-4253.', 'US') === { country: 'US', phone: '2133734253' }
// Parses phone number extensions.
parseNumber('(213) 373-4253 ext. 123', 'US') === { country: 'US', phone: '2133734253', ext: '123' }
// Parses RFC 3966 phone number URIs.
parseNumber('tel:+78005553535;ext=123') === { country: 'RU', phone: '8005553535', ext: '123' }If the phone number supplied isn't valid then an empty object {} is returned.
parseNumber('+1 111 111 1111') === {}
parseNumber('(111) 111-1111', 'US') === {}
parseNumber('abcdefg') === {}Available options:
-
defaultCountry : string— Same as thedefaultCountryargument. -
extended : boolean— If set totruethenparseNumber()will attempt to parse even a remotely hypothetical phone number even if it is considered "invalid".
{ extended: true } documentation and examples
The result of "extended" parsing is an object where
countryis a country code.phoneis a national (significant) number.extis a phone number extension.countryCallingCodeis a country calling code.carrierCodes are only used in Colombia and Brazil and only when dialing within those countries from a mobile phone to a fixed line number.valid: boolean— whether it's a "valid" (real) phone number.possible: boolean— a phone number is considered "possible" when it fits the phone number length rules for a given country. E.g. for US national (significant) number regexp is[2-9]\d{9}and possible national (significant) number length is10so a phone number(111) 111-1111is not a "valid" number because it doesn't match the US national (significant) number regexp but it is a "possible" number because it's10digits long.- Some or all of these properties may be absent from the result object.
// If the number is valid.
parseNumber('Phone: (213) 373-4253.', 'US', { extended: true }) ===
{
country: 'US',
phone: '2133734253',
ext: undefined,
countryCallingCode: 1,
carrierCode: undefined,
valid: true,
possible: true
}
// If the number is not "valid" but "possible".
parseNumber('(111) 111-1111', 'US', { extended: true }) ===
{
country: 'US',
phone: '1111111111',
ext: undefined,
countryCallingCode: 1,
carrierCode: undefined,
valid: false,
possible: true
}
// If the number is not "valid" but "possible"
// and country can't be derived from it.
// (e.g. can't tell if it's a US number or a Canadian number)
parseNumber('+1 111 111 1111', { extended: true }) ===
{
country: undefined,
phone: '1111111111',
ext: undefined,
countryCallingCode: 1,
carrierCode: undefined,
valid: false,
possible: true
}
// If the number is not "possible" (invalid length).
parseNumber('(213) 373', 'US', { extended: true }) ===
{
country: 'US',
phone: '213373',
ext: undefined,
countryCallingCode: 1,
carrierCode: undefined,
valid: false,
possible: false
}
// In some cases if the number is extremely not "possible"
// then an empty object `{}` is returned.
//
// Too short (or too long) for any country's phone number.
parseNumber('1', 'US', { extended: true }) === {}
// Non-existent country calling code.
parseNumber('+210', { extended: true }) === {}
// No phone number found.
parseNumber('abcdefg', 'US', { extended: true }) === {}The "extended" parsing mode is the default behaviour of the original Google's libphonenumber: it still returns parsed data even if the phone number being parsed is not considered valid (but is kinda "possible"). I guess this kind of behaviour is better for crawling websites for phone numbers because when mining "big data" it is better to extract all possible info rather than discard some pieces of it prematurely, e.g. when national (significant) number regexp for some country gets outdated which might very well happen because phone numbering plans are changing constantly around the world. Maybe after all it would make sense to make the "extended" parsing mode the default one in the next major version. I guess it would.
Also parses IDD-prefixed phone numbers
Sometimes users icorrectly input phone numbers in "out-of-country" dialing (IDD-prefixed) format instead of the proper international phone number format (the "+" notation). In such cases parseNumber() will attempt to parse such IDD-prefixed numbers if "default country" is provided:
// International format.
parseNumber('+61 2 3456 7890') === { country: 'AU', phone: '234567890' }
// IDD-prefixed format.
parseNumber('011 61 2 3456 7890', 'US') === { country: 'AU', phone: '234567890' }(previously called format())
(legacy API)
Formats a number into a string according to a format.
Available formats and options are the same as for PhoneNumber.format(format).
The number argument must be either a result of parseNumber() function call (to strip national prefix) or an E.164 phone number string (e.g. +12133734253).
Examples
// Formats E.164 phone numbers.
formatNumber('+12133734253', 'NATIONAL') === '(213) 373-4253'
formatNumber('+12133734253', 'INTERNATIONAL') === '+1 213 373 4253'
// Formats E.164 phone numbers when
// they're not "valid" but still "possible".
formatNumber('+11111111111', 'NATIONAL') === '(111) 111-1111'
formatNumber('+11111111111', 'INTERNATIONAL') === '+1 111 111 1111'
// Formats E.164 phone numbers when
// they're not "valid" and not "possible" (invalid length).
formatNumber('+11111', 'NATIONAL') === '1111'
formatNumber('+11111', 'INTERNATIONAL') === '+1 1111'
// Formats a result of `parseNumber()` function call.
const parsedNumber = parseNumber('2133734253', 'US')
formatNumber(parsedNumber, 'NATIONAL') === '(213) 373-4253'
formatNumber(parsedNumber, 'INTERNATIONAL') === '+1 213 373 4253'
// Formats a result of `parseNumber()` function call in "extended" mode
// when it's not a "valid" number but is still a "possible" one.
const possibleNumber = parseNumber('+11111111111', { extended: true })
formatNumber(possibleNumber, 'NATIONAL') === '(111) 111-1111'
formatNumber(possibleNumber, 'INTERNATIONAL') === '+1 111 111 1111'
// Formats a result of `parseNumber()` function call in "extended" mode
// when it's neither a "valid" number nor a "possible" one (invalid length).
const possibleNumber = parseNumber('+11111', { extended: true })
formatNumber(possibleNumber, 'NATIONAL') === '1111'
formatNumber(possibleNumber, 'INTERNATIONAL') === '+1 1111'
// Formats phone number extensions.
formatNumber({ country: 'US', phone: '2133734253', ext: '123' }, 'NATIONAL') === '(213) 373-4253 ext. 123'
// When given an object not having `phone` property
// (e.g. a empty object `{}`) it will throw.
formatNumber({}) throws Error(legacy API)
See the description for PhoneNumber.getType().
The number argument can be either a result of the parseNumber() function call — { country, phone } — or a string (phone number digits only) possibly accompanied with the second defaultCountry argument.
Examples
getNumberType('+79160151539') === 'MOBILE'
getNumberType('9160151539', 'RU') === 'MOBILE'
getNumberType({ phone: '9160151539', country: 'RU' }) === 'MOBILE'(legacy API)
Checks if a phone number is valid, the validation is more strict than parseNumber().
The number argument can be either a result of the parseNumber() function call — { country, phone } — or a string (phone number digits only) possibly accompanied with the second defaultCountry argument.
Examples
isValidNumber('+12133734253') === true
isValidNumber('+1213373') === false
isValidNumber('2133734253', 'US') === true
isValidNumber('21337', 'US') === false
isValidNumber({ phone: '2133734253', country: 'US' }) === trueThe difference between using parseNumber() and isValidNumber()
The difference between using parseNumber() and isValidNumber() for phone number validation is that isValidNumber() also checks the precise regular expressions of possible phone numbers for a country. For example, for Germany parseNumber('123456', 'DE') would return { country: 'DE', phone: '123456' } because this phone number matches the general phone number rules for Germany (basic length check, etc). But, if the metadata is compiled with --extended (or relevant --types) flag (see Customizing metadata section of this document) then isValidNumber() is gonna use those precise regular expressions for extensive validation and isValid('123456', 'DE') will return false because the phone number 123456 doesn't actually exist in Germany.
This is how it is implemented in the original Google's libphonenumber: parseNumber() parses phone numbers and loosely validates them while isValidNumber() validates phone numbers precisely (provided the precise regular expressions are included in metadata).
The precise regular expressions aren't included in the default metadata because that would cause the default metadata to grow twice in its size: the complete ("full") metadata size is about 145 kilobytes while the reduced ("default") metadata size is about 77 kilobytes. Hence in the default configuration isValidNumber() performs absolutely the same "lite" validation as parseNumber(). For enabling extensive phone number validation the simplest way is to import functions from libphonenumber-js/custom module and supply them with libphonenumber-js/metadata.max.json. For generating custom metadata see the instructions provided in the Customizing metadata section of this document.
isValidNumberForRegion()
The optional defaultCountry argument is the default country, i.e. it does not restrict to just that country, e.g. in those cases where several countries share the same phone numbering rules (NANPA, Britain, etc). For example, even though the number 07624 369230 belongs to the Isle of Man ("IM" country code) calling isValidNumber('07624369230', 'GB') still returns true because the country is not restricted to GB, it's just that GB is the default one for the phone numbering rules. For restricting the country, see isValidNumberForRegion(), though restricting a country might not be a good idea.
// Even though '07624 369230' number belongs to the Isle of Man ("IM")
// the `defaultCountry` argument "GB" still works here because
// "GB" and "IM" both share the same phone numbering rules ("+44").
isValidNumber('07624369230', 'GB') === true
isValidNumber('07624369230', 'IM') === true
// Imposing country restrictions.
isValidNumberForRegion('07624369230', 'GB') === false
isValidNumberForRegion('07624369230', 'IM') === trueI personally don't use strict phone number validation feature. The rationale is that telephone numbering plans can and sometimes do change, meaning that PhoneNumber.isValid() function may one day become outdated on a website that isn't actively maintained anymore. Imagine a "promo-site" or a "personal website" being deployed once and then running for years without any maintenance, where a client may be unable to submit a simple "Contact Us" form just because this newly-allocated pool of mobile phone numbers wasn't present in that old version of libphonenumber-js that was used when building the website.
Whenever there's a "business requirement" to validate phone number input, I prefer using PhoneNumber.isPossible() instead of PhoneNumber.isValid(), so that it just validates the phone number length and doesn't validate the actual phone number digits. But it doesn't mean that you shouldn't use PhoneNumber.isValid() — maybe in your case it would make sense.
If you’re trying to build a React component with this library, take a look at react-phone-number-input.
This library is a simpler rewrite of Google's libphonenumber library. Basically, it mimicks Google's library behavior. Hence, as long as this library's demo page and Google's library demo page exhibit the same behavior, it's not considered a bug, regardless of whether that behavior contradicts any new changes in telephone numbering plans, etc. In that case, your only option would be to report the issue to Google directly.
That being said, if the two demo pages exhibit different behavior and it's not caused by the intentional differences, then it would be considered a valid case for reporting an issue.
When reporting issues related to:
- Parsing numbers
- Validating numbers
- Formatting numbers
- "As You Type" formatter
one must provide two links:
- A link to the demo page illustrating the supposedly incorrect behavior.
- A link to Google's
libphonenumberdemo page illustrating the expected behavior.
Google's demo page output is divided into four sections:
- "Parsing Result"
- "Validation Results"
- "Formatting Results"
- "AsYouTypeFormatter Results"
Depending the type of bug you're reporting, mention the relevant section of the demo page output in your ticket.
When writing a bug report:
- First, describe the observed
libphonenumber-jsdemo result (and provide a link to it). - Second, describe the observed Google's demo result (and provide a link to it).
- The described observed result of Google's demo must be different from the described observed result of
libphonenumber-jsdemo, otherwise it's not considered a bug. If you don't agree with Google's demo result then report it to Google directly instead. If they fix it in their library, I'll port the fix to this library.
To include this library directly via a <script/> tag on a page, one can use any npm CDN service, e.g. unpkg.com or jsdelivr.com
<script src="https://unpkg.com/libphonenumber-js@[version]/bundle/libphonenumber-[type].js"></script>
<script>
alert(new libphonenumber.AsYouType('US').input('213-373-4253'))
</script>where [version] is an npm package version range (for example, 1.x or ^1.7.6) and [type] is the bundle type: min, max or mobile.
Metadata is generated from Google's PhoneNumberMetadata.xml by transforming XML into JSON and removing unnecessary fields. See metadata fields description.
Metadata can be accessed programmatically by using the exported Metadata class.
First, create a Metadata class instance:
import { Metadata } from 'libphonenumber-js'
const metadata = new Metadata()Then, select a "numbering plan" (a country):
metadata.selectNumberingPlan('US')After that, the following methods of metadata.numberingPlan can be called:
-
leadingDigits(): string?— Returns "leading digits" pattern. -
possibleLengths(): number[]— Returns a list of possible lengths of a national (significant) number. -
IDDPrefix(): string— Returns an International Direct Dialing prefix. -
defaultIDDPrefix(): string?— Returns a default International Direct Dialing prefix when there're multiple ones available.
Example:
import { Metadata } from 'libphonenumber-js'
const metadata = new Metadata()
metadata.selectNumberingPlan('US')
metadata.numberingPlan.leadingDigits() === undefined
metadata.numberingPlan.possibleLengths() === [10]
metadata.numberingPlan.IDDPrefix() === '011'
metadata.numberingPlan.defaultIDDPrefix() === undefinedUsing with custom metadata:
import { Metadata } from 'libphonenumber-js/core'
import min from 'libphonenumber-js/min/metadata'
// import max from 'libphonenumber-js/max/metadata'
// import mobile from 'libphonenumber-js/mobile/metadata'
const metadata = new Metadata(min)As one can see, the Metadata class is not documented much. Partially, that's because its usage is not necessarily encouraged, but it's still used, for example, in react-phone-number-input to get the "leading digits" for a country, or to get the maximum phone number length for a country. Stick to the methods documented above and don't call any other methods. If you think there's a need to call any other methods not mentioned above, create an issue with a discussion.
This library comes prepackaged with three types of metadata.
Sometimes, if only a specific set of countries is needed in a project, and a developer really wants to reduce the resulting bundle size, say, by 50 kilobytes, while still including all regular expressions for validating phone number digits and detecting phone number type, then they can generate such custom metadata and pass it as the last argument to this library's "core" functions.
See generate custom metadata instructions.
How to use the generated metadata.custom.json file with the "core" functions.
Pass the metadata argument as the last one to the "core" functions.
In ES6 that would be:
import _parsePhoneNumber, {
findPhoneNumbersInText as _findPhoneNumbersInText,
AsYouType as _AsYouType
} from 'libphonenumber-js/core'
import metadata from 'libphonenumber-js/max/metadata'
function call(func, _arguments) {
var args = Array.prototype.slice.call(_arguments)
args.push(metadata)
return func.apply(this, args)
}
export default function parsePhoneNumber() {
return call(_parsePhoneNumber, arguments)
}
export function findPhoneNumbersInText() {
return call(_findPhoneNumbersInText, arguments)
}
export function AsYouType(country) {
return _AsYouType.call(this, country, metadata)
}
AsYouType.prototype = Object.create(_AsYouType.prototype, {})
AsYouType.prototype.constructor = AsYouTypeAnd for Common.js environment that would be:
var core = require('libphonenumber-js/core')
var metadata = require('libphonenumber-js/max/metadata')
function call(func, _arguments) {
var args = Array.prototype.slice.call(_arguments)
args.push(metadata)
return func.apply(this, args)
}
function parsePhoneNumber() {
return call(core.default, arguments)
}
exports = module.exports = parsePhoneNumber
exports['default'] = parsePhoneNumber
exports.findPhoneNumbersInText = function findPhoneNumbersInText() {
return call(core.findPhoneNumbersInText, arguments)
}
exports.AsYouType = function AsYouType(country) {
return core.AsYouType.call(this, country, metadata)
}
exports.AsYouType.prototype = Object.create(core.AsYouType.prototype, {})
exports.AsYouType.prototype.constructor = exports.AsYouTypeLegacy: How to use the generated metadata.custom.json file with the legacy "custom" functions.
Pass the metadata argument as the last one to the "custom" functions.
In ES6 that would be:
import {
parseNumber,
formatNumber,
isValidNumber,
getNumberType,
AsYouType
} from 'libphonenumber-js/custom'
import metadata from 'libphonenumber-js/max/metadata'
parseNumber('+78005553535', metadata)
formatNumber({ phone: '8005553535', country: 'RU' }, metadata)
isValidNumber('+78005553535', metadata)
getNumberType('+78005553535', metadata)
new AsYouType('RU', metadata).input('+78005553535')And for Common.js environment that would be:
var custom = require('libphonenumber-js/custom')
var metadata = require('libphonenumber-js/max/metadata')
exports.parseNumber = function parseNumber() {
var parameters = Array.prototype.slice.call(arguments)
parameters.push(metadata)
return custom.parseNumber.apply(this, parameters)
}
exports.formatNumber = function formatNumber() {
var parameters = Array.prototype.slice.call(arguments)
parameters.push(metadata)
return custom.formatNumber.apply(this, parameters)
}
exports.isValidNumber = function isValidNumber() {
var parameters = Array.prototype.slice.call(arguments)
parameters.push(metadata)
return custom.isValidNumber.apply(this, parameters)
}
exports.getNumberType = function isValidNumber() {
var parameters = Array.prototype.slice.call(arguments)
parameters.push(metadata)
return custom.getNumberType.apply(this, parameters)
}
exports.AsYouType = function AsYouType(country) {
custom.AsYouType.call(this, country, metadata)
}
exports.AsYouType.prototype = Object.create(custom.AsYouType.prototype, {})
exports.AsYouType.prototype.constructor = exports.AsYouTypeNote that if you'll be using your own "custom" metadata then you're responsible for keeping it up-to-date because Google regularly updates their metadata.
Google periodically releases new metadata with the changes described in their release notes. Most of the times, those are minor non-breaking updates. Rarely, those could be major-version breaking changes.
After Google does that, this library pulls the updated metadata from Google's repository and publishes a new version of itself on npm.
The metadata pulling process is automated through an "autoupdate" script: see autoupdate.cmd (Windows) or autoupdate.sh (Linux/macOS). The script detects changes to PhoneNumberMetadata.xml file in Google libphonenumber's repo and, if there are any changes, it pulls the latest metadata, transforms it, commits the changes to the repository, builds a new version of the package and releases it to npm.
I did attempt to set up the autoupdate script to run dialy on my Windows machine in an automatic fashion through "Task Scheduler", and even overcame the issue of ssh-agent asking for a password input every time when running git command, but then npm started requiring "two-factor authentication" in order to publish a package, which requires human intervention, so the autoupdate process can't really be 100% autonomous and automatic and has to be run by a human's hand every now-and-then.
So I just run the "autoupdate" script manually from time to time. With this workflow, one can see how the metadata could potentially get a bit stale, in which case just ping me to re-run the autoupdate script, assuming I'm still alive and well.
Also Google sometimes (extremely rarely) updates their code:
phonenumberutil.js— is mirrored as functions:parseNumber(),formatNumber(),isValidNumber(),getNumberType()AsYouTypeFormatter.java— is mirrored asAsYouTypeclassPhoneNumberMatcher.java— is mirrored asfindPhoneNumbersInText()function
The latest sync-up with Google's code was on Sep 19th, 2025.
After cloning this repo, install the dependencies:
npm installThis library is written in ES6 and uses Babel for ES5 transpilation during the "build" step:
npm run buildAfter making any code changes, run the tests:
npm testAside from all tests passing, it should also remain at 100% of code coverage. At some point, the coverage analysis tools got buggy and stopped reporting the coverage correctly. Anyway, a code coverage report could be generated by running the following command:
npm run test-coverageTo test the updated code on a real project before publishing a new release, one could use "pack-and-install" trick to simulate publishing a new release.
npm packIt will build, test and then create a .tgz archive that can be installed from a project folder just like a normal npm package.
npm install [module name with version].tar.gzThis component comes with a 100% code coverage.
To run tests:
npm test
To generate a code coverage report:
npm run test-coverage
The code coverage report can be viewed by opening ./coverage/lcov-report/index.html.
At some point, the coverage analysis tools got buggy and stopped reporting the coverage correctly.
If you like this library then you might also like:
react-phone-number-input— AReactcomponent for phone number input.javascript-time-ago— An international human-readable past or future date formatter. Example:"2 days ago".react-time-ago— AReactcomponent for international human-readable past or future date formatter. Example:"2 days ago".read-excel-file— A simple and easy-to-use*.xlsxfile reader (client-side or server-side).write-excel-file— A simple and easy-to-use*.xlsxfile writer (client-side or server-side).flexible-json-schema— A simple and easy-to-use*.jsonschema data validator / parser.navigation-stack— Navigation in a Single-Page Application.virtual-scroller— A universal implementation of a "virtual scroller" infinite list scrolling component: only renders the rows that fit the screen bounds.
Google's libphonenumber is licensed under Apache 2.
Apache 2 does not require a derivative work of the software, or modifications to the original, to be distributed using the same license. Hence, this library is licensed under MIT, which is compatible with Apache 2.
The Apache license is terminated if the user sues anyone over patent infringement related to the software covered by the license. This condition is added in order to prevent patent litigations.
