# Bulk Phone Number Validator — E.164, Carrier & Line Type (`haketa/bulk-phone-validator`) Actor Validate and format thousands of phone numbers at once: validity, E.164 / international / national format, line type (mobile, landline, VoIP, toll-free), country, carrier, timezone and area. Fast, offline, keyless phone-list cleaning for CRM, SMS and leads. - **URL**: https://apify.com/haketa/bulk-phone-validator.md - **Developed by:** [Haketa](https://apify.com/haketa) (community) - **Categories:** Lead generation, Developer tools - **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks - **User rating**: No ratings yet ## Pricing from $0.60 / 1,000 results This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events. Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have. Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event ## What's an Apify Actor? Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases. In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours, and optionally produces a well-defined JSON output, datasets with results, or files in key-value store. In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server. Actors are written with capital "A". ## How to integrate an Actor? If asked about integration, you help developers integrate Actors into their projects. You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready. The best way to integrate Actors is as follows. In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md): ```bash npm install apify-client ``` In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md): ```bash pip install apify-client ``` In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md): ````bash # MacOS / Linux curl -fsSL https://apify.com/install-cli.sh | bash # Windows irm https://apify.com/install-cli.ps1 | iex ```bash In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md). If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md). For usage examples, see the [API](#api) section below. For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt). # README ## Bulk Phone Number Validator — E.164, Line Type, Carrier & Country Validate and clean **thousands of phone numbers at once.** Paste a list and get, for every number: **is it valid, its E.164 / international / national format, the line type (mobile, landline, VoIP, toll-free…), the country, the carrier, the timezone and the geographic area.** Fast, **offline and keyless** — no API, no credits, no rate limits. The phone‑data layer you need for **CRM hygiene, SMS/WhatsApp deliverability, lead validation and analytics.** --- ### Why this Actor? A raw list of phone numbers is messy: mixed formats, missing country codes, typos, landlines mixed with mobiles, and invalid entries that waste your SMS budget. Before you dial, text or import them, you need to know which numbers are real, what type they are and where they belong. This Actor does exactly that, in bulk: - **Validates** each number against the official numbering rules of its country. - **Normalises** it to clean **E.164** (`+491701234567`) plus international and national formats. - **Classifies** the line type — mobile, landline, VoIP, toll‑free and more. - **Enriches** valid numbers with **country, carrier, timezone and geographic area.** Because it runs on embedded numbering metadata, it's **completely offline**: no third‑party API, no key, no per‑lookup fee, and no rate limit. That makes it ideal for very large lists. --- ### What you get — output fields One record per phone number: | Field | Description | | --- | --- | | `input` | The number exactly as you supplied it | | `isValid` | Whether the number is valid for its country | | `isPossible` | Whether the number is possible (right length/prefix) | | `e164` | E.164 format, e.g. `+491701234567` | | `international` | International format, e.g. `+49 170 1234567` | | `national` | National format, e.g. `0170 1234567` | | `uri` | `tel:` URI, e.g. `tel:+491701234567` | | `countryCode` | Country calling code, e.g. `49` | | `country` | ISO country, e.g. `DE` | | `countryName` | Country name, e.g. `Germany` | | `numberType` | Line type: `MOBILE`, `FIXED_LINE`, `VOIP`, `TOLL_FREE`, `PREMIUM_RATE`, `FIXED_LINE_OR_MOBILE`, … | | `isMobile` | `true` if the line can typically receive SMS | | `location` | Geographic area, e.g. `San Francisco, CA` | | `carrier` | Carrier / network, e.g. `T‑Mobile` | | `timezone` | Timezone(s), e.g. `Europe/Berlin` | | `error` | Populated for unparseable or invalid numbers | | `scrapedAt` | ISO timestamp | A few notes on coverage: `carrier` is available mainly for **mobile** numbers (landlines don't map to a single carrier), and `location` is available mainly for **geographic** numbers (mobiles in many countries aren't tied to a city). This mirrors how the underlying numbering plans work. --- ### Example output ```json { "input": "0170 1234567", "isValid": "true", "isPossible": "true", "e164": "+491701234567", "international": "+49 170 1234567", "national": "0170 1234567", "uri": "tel:+491701234567", "countryCode": "49", "country": "DE", "countryName": "Germany", "numberType": "MOBILE", "isMobile": "true", "location": "", "carrier": "T-Mobile", "timezone": "Europe/Berlin", "scrapedAt": "2026-07-09T12:00:00.000Z" } ```` ```json { "input": "+1 415-555-2671", "isValid": "true", "e164": "+14155552671", "international": "+1 415 555 2671", "national": "(415) 555-2671", "countryCode": "1", "country": "US", "countryName": "United States", "numberType": "FIXED_LINE_OR_MOBILE", "isMobile": "true", "location": "San Francisco, CA", "carrier": "", "timezone": "America/Los_Angeles", "scrapedAt": "2026-07-09T12:00:00.000Z" } ``` *** ### Input | Field | Type | Default | Description | | --- | --- | --- | --- | | `phoneNumbers` | array | — | **Required.** Numbers to validate. Any format is accepted. | | `defaultCountry` | string | — | ISO code (US, GB, DE…) for numbers written without a country code. | | `includeCarrierData` | boolean | `true` | Look up carrier, timezone and area for valid numbers. Turn off for a faster, validation‑only run. | | `maxConcurrency` | integer | `50` | How many numbers to process in parallel. | #### Numbers already in international format ```json { "phoneNumbers": ["+14155552671", "+442071838750", "+491701234567"] } ``` #### National‑format numbers (set a default country) ```json { "phoneNumbers": ["0170 1234567", "030 12345678", "0151 22334455"], "defaultCountry": "DE" } ``` #### Fast, validation‑only run on a huge list ```json { "phoneNumbers": ["+14155552671", "..."], "includeCarrierData": false } ``` *** ### Use cases in detail #### 1. CRM & database hygiene Run your entire contact database through the Actor and flag every invalid number, normalise the rest to E.164, and tag each one as mobile or landline. Clean data means fewer failed calls and texts. #### 2. SMS / WhatsApp deliverability SMS and WhatsApp only work on mobile numbers. Filter `isMobile = true` (and drop `isValid = false`) before a campaign so you never pay to text a landline or an invalid number. #### 3. Lead validation Validate phone numbers captured from forms, ads or other scrapers in bulk. Reject fakes and typos at the source and keep only reachable leads. #### 4. Routing, timezone & compliance Use `timezone` to call or message people at a sensible local hour, and `country` / `numberType` to apply the right rules (many regions restrict calls to certain line types or hours). #### 5. Analytics & segmentation Segment your audience by `country`, `carrier` or line type for reporting, geo‑analysis and targeting. #### 6. Deduplication Normalising every number to E.164 lets you dedupe a list reliably, since the same number written five different ways collapses to one canonical value. *** ### How to use it 1. Click **Try for free**. 2. Paste your phone numbers into the **Phone numbers** field. 3. (Optional) Set a **Default country** if some numbers have no country code. 4. Click **Start**. 5. Export the results as **JSON, CSV, Excel** or **HTML table**, or pull them from the Apify API. Validation is instant; enrichment (carrier/timezone/area) adds a small lookup per valid number, so turning it off makes huge lists even faster. *** ### Calling from the API Start a run: ```bash curl -X POST "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs?token=YOUR_APIFY_TOKEN" \ -H "Content-Type: application/json" \ -d '{ "phoneNumbers": ["+14155552671", "0170 1234567"], "defaultCountry": "US" }' ``` Fetch the results (JSON or CSV): ```bash curl "https://api.apify.com/v2/acts/YOUR_ACTOR_ID/runs/last/dataset/items?token=YOUR_APIFY_TOKEN&format=csv" ``` *** ### Line types explained | `numberType` | Meaning | | --- | --- | | `MOBILE` | Mobile / cell number | | `FIXED_LINE` | Landline | | `FIXED_LINE_OR_MOBILE` | Could be either (common in the US/Canada) | | `VOIP` | Internet / VoIP number | | `TOLL_FREE` | Toll‑free (e.g. 800 numbers) | | `PREMIUM_RATE` | Premium‑rate number | | `SHARED_COST` | Shared‑cost number | | `PERSONAL_NUMBER` | Personal number | | `PAGER` | Pager | | `UAN` | Universal access number | | `VOICEMAIL` | Voicemail access | When the type can't be determined for a valid number, `numberType` is empty. *** ### Tips for the best results - **Include the country code** (`+…`) whenever you can — it's the most reliable input. Otherwise set `defaultCountry`. - **Filter `isValid = true`** first, then `isMobile = true` for SMS campaigns. - **Turn off `includeCarrierData`** for the fastest possible run on millions of numbers when you only need validation and formatting. - **Use `e164`** as the canonical key when you dedupe or import into a CRM. - **Mixed‑country lists** work best in international format, since a single `defaultCountry` applies to all national‑format numbers. *** ### Frequently asked questions **Does it call or text the numbers?** No. It never contacts the numbers. It checks them against official numbering rules and metadata — nothing is dialled or messaged, so there's no risk to the number's owner and no cost. **Is it accurate?** Validation and formatting use the same industry‑standard numbering metadata that powers phone validation in major apps. Carrier data reflects the **original** carrier for a number's prefix; because of number portability, a person may have since switched networks, so treat `carrier` as a strong hint rather than a guarantee. **Why is `carrier` or `location` empty?** Carrier is generally only available for mobile numbers; geographic area is generally only available for landline/geographic numbers. Empty simply means that field doesn't apply to that number. **Do I need an API key?** No. It's fully offline — no key, no external service, no rate limit. **How many numbers can it handle?** From a handful to millions. Validation is extremely fast; enrichment adds a tiny per‑number lookup. **What formats are accepted?** Any — E.164 (`+14155552671`), international (`+1 415‑555‑2671`), or national (`(415) 555‑2671` with `defaultCountry: US`). **In which format can I export?** JSON, CSV, Excel, HTML table, or via the Apify API. *** ### Responsible use Phone numbers are personal data. You are responsible for using the results lawfully: - Comply with telemarketing, SMS and anti‑spam laws in the relevant jurisdictions (for example TCPA in the US, GDPR and ePrivacy in the EU) and honour do‑not‑call registries and opt‑outs. - Only process numbers you have a lawful basis and a legitimate reason to handle. - Treat `carrier` as an original‑network hint, not a definitive current‑network lookup. This Actor is provided for lawful data‑quality, deliverability and analytics purposes. It does not provide legal advice. *** ### Support Need extra fields (e.g. number portability lookups, additional formats) or higher throughput? Open an issue from the Actor's page and describe what you need. # Actor input Schema ## `phoneNumbers` (type: `array`): The phone numbers to validate. Any format is accepted (E.164, international, or national). Paste a list — handles thousands to millions. For numbers without a country code, set a Default country below. ## `defaultCountry` (type: `string`): Two-letter country code (e.g. US, GB, DE) used to interpret numbers written in national format without a country code. Leave empty if all numbers include a country code (start with +). ## `includeCarrierData` (type: `boolean`): Look up carrier, timezone and geographic area for valid numbers. Turn off for the fastest, validation-only run on huge lists. ## `maxConcurrency` (type: `integer`): How many numbers to process in parallel. ## Actor input object example ```json { "phoneNumbers": [ "+14155552671", "+442071838750", "+491701234567", "+33612345678", "+8613800138000", "+551123456789" ], "includeCarrierData": true, "maxConcurrency": 50 } ``` # Actor output Schema ## `input` (type: `string`): The number as supplied ## `isValid` (type: `string`): Whether the number is valid ## `isPossible` (type: `string`): Whether the number is possible (length/prefix) ## `e164` (type: `string`): E.164 format ## `international` (type: `string`): International format ## `national` (type: `string`): National format ## `uri` (type: `string`): tel: URI ## `countryCode` (type: `string`): Country calling code ## `country` (type: `string`): ISO country code ## `countryName` (type: `string`): Country name ## `numberType` (type: `string`): Mobile, landline, VoIP, toll-free… ## `isMobile` (type: `string`): Whether the line can receive SMS ## `location` (type: `string`): Geographic area ## `carrier` (type: `string`): Carrier / network ## `timezone` (type: `string`): Timezone(s) ## `error` (type: `string`): Error, if any ## `scrapedAt` (type: `string`): Timestamp # API You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup. ## JavaScript example ```javascript import { ApifyClient } from 'apify-client'; // Initialize the ApifyClient with your Apify API token // Replace the '' with your token const client = new ApifyClient({ token: '', }); // Prepare Actor input const input = { "phoneNumbers": [ "+14155552671", "+442071838750", "+491701234567", "+33612345678", "+8613800138000", "+551123456789" ], "maxConcurrency": 50 }; // Run the Actor and wait for it to finish const run = await client.actor("haketa/bulk-phone-validator").call(input); // Fetch and print Actor results from the run's dataset (if any) console.log('Results from dataset'); console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`); const { items } = await client.dataset(run.defaultDatasetId).listItems(); items.forEach((item) => { console.dir(item); }); // 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs ``` ## Python example ```python from apify_client import ApifyClient # Initialize the ApifyClient with your Apify API token # Replace '' with your token. client = ApifyClient("") # Prepare the Actor input run_input = { "phoneNumbers": [ "+14155552671", "+442071838750", "+491701234567", "+33612345678", "+8613800138000", "+551123456789", ], "maxConcurrency": 50, } # Run the Actor and wait for it to finish run = client.actor("haketa/bulk-phone-validator").call(run_input=run_input) # Fetch and print Actor results from the run's dataset (if there are any) print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"]) for item in client.dataset(run["defaultDatasetId"]).iterate_items(): print(item) # 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start ``` ## CLI example ```bash echo '{ "phoneNumbers": [ "+14155552671", "+442071838750", "+491701234567", "+33612345678", "+8613800138000", "+551123456789" ], "maxConcurrency": 50 }' | apify call haketa/bulk-phone-validator --silent --output-dataset ``` ## MCP server setup ```json { "mcpServers": { "apify": { "command": "npx", "args": [ "mcp-remote", "https://mcp.apify.com/?tools=haketa/bulk-phone-validator", "--header", "Authorization: Bearer " ] } } } ``` ## OpenAPI specification ```json { "openapi": "3.0.1", "info": { "title": "Bulk Phone Number Validator — E.164, Carrier & Line Type", "description": "Validate and format thousands of phone numbers at once: validity, E.164 / international / national format, line type (mobile, landline, VoIP, toll-free), country, carrier, timezone and area. Fast, offline, keyless phone-list cleaning for CRM, SMS and leads.", "version": "0.1", "x-build-id": "nNZvTg0sDW9Rcv8Oq" }, "servers": [ { "url": "https://api.apify.com/v2" } ], "paths": { "/acts/haketa~bulk-phone-validator/run-sync-get-dataset-items": { "post": { "operationId": "run-sync-get-dataset-items-haketa-bulk-phone-validator", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } }, "/acts/haketa~bulk-phone-validator/runs": { "post": { "operationId": "runs-sync-haketa-bulk-phone-validator", "x-openai-isConsequential": false, "summary": "Executes an Actor and returns information about the initiated run in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK", "content": { "application/json": { "schema": { "$ref": "#/components/schemas/runsResponseSchema" } } } } } } }, "/acts/haketa~bulk-phone-validator/run-sync": { "post": { "operationId": "run-sync-haketa-bulk-phone-validator", "x-openai-isConsequential": false, "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.", "tags": [ "Run Actor" ], "requestBody": { "required": true, "content": { "application/json": { "schema": { "$ref": "#/components/schemas/inputSchema" } } } }, "parameters": [ { "name": "token", "in": "query", "required": true, "schema": { "type": "string" }, "description": "Enter your Apify token here" } ], "responses": { "200": { "description": "OK" } } } } }, "components": { "schemas": { "inputSchema": { "type": "object", "required": [ "phoneNumbers" ], "properties": { "phoneNumbers": { "title": "Phone numbers", "type": "array", "description": "The phone numbers to validate. Any format is accepted (E.164, international, or national). Paste a list — handles thousands to millions. For numbers without a country code, set a Default country below.", "items": { "type": "string" } }, "defaultCountry": { "title": "Default country (ISO code)", "type": "string", "description": "Two-letter country code (e.g. US, GB, DE) used to interpret numbers written in national format without a country code. Leave empty if all numbers include a country code (start with +)." }, "includeCarrierData": { "title": "Include carrier, timezone & area", "type": "boolean", "description": "Look up carrier, timezone and geographic area for valid numbers. Turn off for the fastest, validation-only run on huge lists.", "default": true }, "maxConcurrency": { "title": "Max concurrency", "minimum": 1, "maximum": 200, "type": "integer", "description": "How many numbers to process in parallel.", "default": 50 } } }, "runsResponseSchema": { "type": "object", "properties": { "data": { "type": "object", "properties": { "id": { "type": "string" }, "actId": { "type": "string" }, "userId": { "type": "string" }, "startedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "finishedAt": { "type": "string", "format": "date-time", "example": "2025-01-08T00:00:00.000Z" }, "status": { "type": "string", "example": "READY" }, "meta": { "type": "object", "properties": { "origin": { "type": "string", "example": "API" }, "userAgent": { "type": "string" } } }, "stats": { "type": "object", "properties": { "inputBodyLen": { "type": "integer", "example": 2000 }, "rebootCount": { "type": "integer", "example": 0 }, "restartCount": { "type": "integer", "example": 0 }, "resurrectCount": { "type": "integer", "example": 0 }, "computeUnits": { "type": "integer", "example": 0 } } }, "options": { "type": "object", "properties": { "build": { "type": "string", "example": "latest" }, "timeoutSecs": { "type": "integer", "example": 300 }, "memoryMbytes": { "type": "integer", "example": 1024 }, "diskMbytes": { "type": "integer", "example": 2048 } } }, "buildId": { "type": "string" }, "defaultKeyValueStoreId": { "type": "string" }, "defaultDatasetId": { "type": "string" }, "defaultRequestQueueId": { "type": "string" }, "buildNumber": { "type": "string", "example": "1.0.0" }, "containerUrl": { "type": "string" }, "usage": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "integer", "example": 1 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } }, "usageTotalUsd": { "type": "number", "example": 0.00005 }, "usageUsd": { "type": "object", "properties": { "ACTOR_COMPUTE_UNITS": { "type": "integer", "example": 0 }, "DATASET_READS": { "type": "integer", "example": 0 }, "DATASET_WRITES": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_READS": { "type": "integer", "example": 0 }, "KEY_VALUE_STORE_WRITES": { "type": "number", "example": 0.00005 }, "KEY_VALUE_STORE_LISTS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_READS": { "type": "integer", "example": 0 }, "REQUEST_QUEUE_WRITES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_INTERNAL_GBYTES": { "type": "integer", "example": 0 }, "DATA_TRANSFER_EXTERNAL_GBYTES": { "type": "integer", "example": 0 }, "PROXY_RESIDENTIAL_TRANSFER_GBYTES": { "type": "integer", "example": 0 }, "PROXY_SERPS": { "type": "integer", "example": 0 } } } } } } } } } } ```