Phone Number Validator — validate phone numbers in bulk with line type, country & carrier

Validate phone numbers in bulk before you call, text, or import them into your CRM. Paste a list of numbers in any format — international, local, messy copy-paste — and get back a clean dataset: valid or not, normalized E.164 / national / international formats, country, line type (mobile, fixed line, VoIP, toll-free…), and best-effort carrier. Every check runs fully offline against Google's libphonenumber metadata: no API key, no network calls, no proxies, and pay-per-result pricing so you're only charged for numbers actually processed.

What it does

• Validates each number with Google's libphonenumber — the same library that powers Android's dialer — returning both a strict valid flag and a looser possible flag.
• Normalizes every valid number into three formats: E.164 (+14155550132), international (+1 415-555-0132), and national ((415) 555-0132), so your dialer, SMS gateway, and CRM all get the format they expect.
• Classifies the line type — mobile, fixed_line, fixed_line_or_mobile, voip, toll_free, premium_rate, shared_cost, pager, and more — so you can skip landlines in an SMS campaign or flag premium-rate traps.
• Identifies the country and location: the country name (United States, Morocco), a human-readable locality/region description (San Francisco, CA) where available, the ISO region code (US, MA, GB), and the country calling code.
• Looks up the carrier (best-effort, from libphonenumber's carrier metadata) where available.
• Parses local numbers without a + prefix using a defaultRegion you choose, so 020 7946 0958 parses correctly as a UK number.
• Deduplicates input before validating (on by default) and can optionally drop invalid numbers from the output so the dataset is import-ready.
• Handles input as a string list or a single string separated by newlines, commas, or semicolons.

Because everything runs locally against bundled metadata, runs are fast and deterministic — no rate limits, no third-party phone-validation API bills, no data sent to external services.

Use cases

• Sales prospecting — clean the phone column of a scraped lead list before handing it to SDRs, so nobody wastes dials on numbers that were never valid.
• SMS campaign prep — filter to number_type = mobile and drop landlines, VoIP, and toll-free numbers that can't receive texts, protecting your sender reputation and per-message spend.
• CRM hygiene — normalize every contact to E.164 so HubSpot, Salesforce, or your dialer stops choking on (0)6-12 34 56 78-style formatting, and dedupe contacts that are the same number written two ways.
• Agency deliverables — if you sell lead lists on Fiverr or Upwork, run every list through the validator and ship a valid column plus proper formatting as part of your quality guarantee.
• Call-center routing & compliance — split lists by country and region code to route to the right team, and flag premium_rate numbers before your auto-dialer ever touches them.

Input

Field	Type	Default	Description
phones	array	(required)	Phone numbers to validate, one per line. International (+1...) or local numbers (set the default region for local ones).
defaultRegion	string	"US"	Two-letter country code used to parse local numbers without a + prefix (e.g. US, MA, FR, GB).
onlyValid	boolean	false	Keep only numbers that pass full validation.
dedupe	boolean	true	Drop duplicate inputs before validating.

Example input:

{
  "phones": ["+1 415 555 0132", "+212 661-234567", "020 7946 0958", "not a phone"],
  "defaultRegion": "US",
  "onlyValid": false,
  "dedupe": true
}

Only phones is required. phones also accepts a single string separated by newlines, commas, or semicolons.

Output

Each dataset row is one validated number:

Field	Description
input	The raw number exactly as you provided it
valid	true if the number is fully valid for its region
possible	true if the number has a plausible length/structure (looser check)
e164	Normalized E.164 format (+14155550132)
international / national	International and national display formats
country	Country name derived from the region code (United States, Morocco, United Kingdom)
location	Human-readable locality / region description (San Francisco, CA) where libphonenumber has geo metadata
region_code	ISO region code (US, GB, MA)
country_code	Numeric calling code (1, 44, 212)
number_type	mobile, fixed_line, fixed_line_or_mobile, voip, toll_free, premium_rate, …
carrier	Carrier name where metadata exists (best-effort)
status	valid, possible_but_invalid, invalid, or parse_error:<reason>

Example row:

{
  "input": "+212 661-234567",
  "valid": true,
  "possible": true,
  "e164": "+212661234567",
  "international": "+212 661-234567",
  "national": "0661-234567",
  "country": "Morocco",
  "location": "Morocco",
  "region_code": "MA",
  "country_code": 212,
  "number_type": "mobile",
  "carrier": "IAM",
  "status": "valid"
}

Export the dataset to CSV, Excel, or JSON straight from the Apify Console, or pull it via the API.

Example output

A real sample from a live run:

input	valid	country	location	number_type	carrier
+1 415 555 0132	true	United States	San Francisco, CA	fixed_line_or_mobile
+212 661-234567	true	Morocco		mobile	Maroc Telecom
+44 20 7946 0958	true	United Kingdom	London	fixed_line
not a phone	false

Pricing

This actor uses pay-per-result pricing: you're charged only per number that actually lands in your dataset — a fraction of a cent per validated row. No subscription, no minimum, no charge for failed runs. A free Apify plan includes enough platform credit to validate thousands of numbers, so you can clean a real list before spending anything.

Tips / FAQ

Does "valid" mean the number is currently in service?

No. Validation is structural: the number matches the official numbering plan for its country (right length, real prefix, assigned range). It cannot tell whether a specific line is currently active or answered — that would require a live carrier (HLR) lookup, which this actor deliberately doesn't do. It reliably catches typos, fake numbers, wrong lengths, and impossible prefixes.

How accurate is the carrier field?

Best-effort. Carrier names come from libphonenumber's metadata and reflect the carrier the number range was originally assigned to. Ported numbers may show the old carrier, and many ranges (especially US fixed lines) have no carrier metadata at all — you'll get null there.

What happens to numbers that can't be parsed?

They still get a row (unless onlyValid is on) with valid: false and a status like parse_error:1 explaining why parsing failed, so you can audit exactly which inputs were rejected and fix them upstream.

Is there a limit on list size?

No hard limit in the actor. Validation is offline and fast, so even lists with tens of thousands of numbers run quickly. dedupe (on by default) keeps you from paying twice for the same number pasted twice.

Do I need proxies or an API key?

No. The actor makes zero network requests — every check runs locally against bundled metadata, so there's nothing to block, rate-limit, or subscribe to.

How do I automate this?

Call the actor from the Apify API with your list in the phones field, or put it on an Apify Schedule to re-validate your CRM export weekly. The dataset is available as CSV/JSON/Excel the moment the run finishes, and you can wire it to Zapier/Make via Apify integrations.

Related actors

• Bulk Email Verifier — the email counterpart: verify and score email addresses before you hit send.
• Email Pattern Finder — guess likely work emails from a name + company domain.
• Company & Domain Enricher — turn a domain list into full company records with emails, socials, and tech stack.

---

Found a bug or missing a feature? Open an issue on this actor's Issues tab — typical response within 1 business day.