# WhatsApp Number Validator & Checker (`michael.g/whatsapp-number-validator`) Actor

Bulk WhatsApp number validator and phone number checker. Check if phone numbers are registered on WhatsApp, clean contact lists, validate leads, and export structured results.

- **URL**: https://apify.com/michael.g/whatsapp-number-validator.md
- **Developed by:** [Michael G](https://apify.com/michael.g) (community)
- **Categories:** Lead generation, Automation, MCP servers
- **Stats:** 9 total users, 9 monthly users, 100.0% runs succeeded, 3 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $1.00 / 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

### What Does WhatsApp Number Validator Do?

WhatsApp Number Validator checks phone numbers in bulk and returns a clear `hasWhatsapp` result for each unique phone number.

For each phone number, the Actor:

1. Parses and normalizes the phone number where possible.
2. Removes duplicate numbers.
3. Checks whether the number is registered on WhatsApp.
4. Returns `hasWhatsapp: true`, `false`, or `null`.
5. Adds phone metadata such as country, region code, location, and possible time zones.
6. Saves results to the Apify dataset.

### What checks are performed?

| Check | Description |
| --- | --- |
| Phone number parsing | Detects whether the input can be parsed as a phone number |
| Phone normalization | Converts phone numbers to international E.164 format where possible |
| Duplicate handling | Checks each unique normalized phone number only once |
| WhatsApp availability | Checks whether the phone number is registered on WhatsApp |
| Country detection | Returns country and region code when available |
| Location metadata | Returns phone-number-based location metadata when available |
| Timezone metadata | Returns possible time zones inferred from phone number metadata |

`location` and `timezones` are inferred from phone number metadata. They are not live GPS location data.

### `hasWhatsapp` Values

| Value | Meaning |
| --- | --- |
| `true` | The phone number was checked and is registered on WhatsApp |
| `false` | The phone number was checked and is not registered on WhatsApp |
| `null` | The input was skipped and was not checked |

For skipped records, `hasWhatsapp` is `null`, not `false`.

### Why Validate WhatsApp Numbers?

- Clean WhatsApp contact lists before campaigns
- Remove numbers that are not registered on WhatsApp
- Reduce wasted outreach volume
- Improve CRM phone data quality
- Validate leads from scrapers, forms, CRMs, Google Sheets, and datasets
- Prepare WhatsApp contact lists before sales, support, or marketing workflows
- Segment contacts by `hasWhatsapp` before sending messages

Use this Actor only for compliant workflows. Message people only when you have the right to contact them and follow applicable laws and platform rules.

### Example Input

```json
{
  "phoneNumbers": [
    "+919876543210",
    "+14155552671",
    "test"
  ]
}
````

- `+919876543210` shows a number registered on WhatsApp.
- `+14155552671` shows a checked number that is not registered on WhatsApp.
- `test` shows an invalid-format input that is skipped.
- Use international format when possible, for example `+1234567890`.
- Include the country code for best results.

### Example Output

```json
[
  {
    "input": "+919876543210",
    "phoneNumber": "+919876543210",
    "hasWhatsapp": true,
    "country": "India",
    "regionCode": "IN",
    "location": "India",
    "timezones": [
      "Asia/Calcutta"
    ]
  },
  {
    "input": "+14155552671",
    "phoneNumber": "+14155552671",
    "hasWhatsapp": false,
    "country": "United States",
    "regionCode": "US",
    "location": "San Francisco, CA",
    "timezones": [
      "America/Los_Angeles"
    ]
  },
  {
    "input": "test",
    "phoneNumber": null,
    "hasWhatsapp": null,
    "error": "Invalid phone number format",
    "country": null,
    "regionCode": null,
    "location": null,
    "timezones": []
  }
]
```

### Output Fields

| Field | Description |
| --- | --- |
| `input` | Original input value used for this result |
| `phoneNumber` | Normalized phone number in E.164 format, or `null` for skipped inputs |
| `hasWhatsapp` | WhatsApp availability result: `true`, `false`, or `null` |
| `error` | Error message for skipped invalid-format inputs |
| `country` | Country inferred from phone number metadata |
| `regionCode` | ISO country/region code inferred from phone number metadata |
| `location` | Location metadata inferred from phone number metadata |
| `timezones` | Possible time zones inferred from phone number metadata |

### How Do I Use WhatsApp Number Validator?

1. Enter phone numbers in the Actor input.
2. Use international format when possible, for example `+1234567890`.
3. Include the country code.
4. Run the Actor.
5. Open the dataset to review results.
6. Filter by `hasWhatsapp = true` to get numbers registered on WhatsApp.

### Deduplication and Billing Behavior

- Duplicate phone numbers are normalized and checked only once.
- The Actor returns one result per unique normalized phone number.
- Repeated invalid-format inputs are deduplicated.
- Technical check errors are reported in logs and `SUMMARY`, but are not returned as dataset results.
- This helps avoid charging users for failed checks.

### How much does WhatsApp Number Validator cost?

This Actor uses the Pay-per-result pricing model, so your costs can be easily calculated: it will cost you **$2.50 to check 1,000 phone numbers**, which is $0.0025 per phone number. Apify provides you with $5 in free usage credits every month on the [Apify Free plan](https://apify.com/pricing?fpr=home), allowing you to **check up to 50 phone numbers** for free using those credits.

For regular WhatsApp number validation, consider upgrading to the [$29/month Starter plan](https://apify.com/pricing?fpr=home), which can **get you up to 11,600 checked phone numbers every month.**

### Integrations and WhatsApp Number Validator

WhatsApp Number Validator can be connected with almost any cloud service or web app thanks to integrations on the Apify platform. You can integrate with Make, n8n, Zapier, Clay, Slack, Airbyte, Google Sheets, Google Drive, CRMs, lead generation workflows, and [more](https://docs.apify.com/platform/integrations).

### Your feedback

We're always working on improving the performance of our Actors. If you've got any technical feedback for WhatsApp Number Validator or found a bug, please create an issue on the Actor's [Issues tab](https://console.apify.com/actors/2S3AHDNnyMLe40CGK/issues) in Apify Console.

# Actor input Schema

## `phoneNumbers` (type: `array`):

List of phone numbers to check. Include country codes for better accuracy, e.g. +1234567890.

## Actor input object example

```json
{
  "phoneNumbers": [
    "+919876543210",
    "+14155552671"
  ]
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "phoneNumbers": [
        "+919876543210",
        "+14155552671"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("michael.g/whatsapp-number-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 '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = { "phoneNumbers": [
        "+919876543210",
        "+14155552671",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("michael.g/whatsapp-number-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": [
    "+919876543210",
    "+14155552671"
  ]
}' |
apify call michael.g/whatsapp-number-validator --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=michael.g/whatsapp-number-validator",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "WhatsApp Number Validator & Checker",
        "description": "Bulk WhatsApp number validator and phone number checker. Check if phone numbers are registered on WhatsApp, clean contact lists, validate leads, and export structured results.",
        "version": "0.0",
        "x-build-id": "Av5qZAqJPXgnCk30T"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/michael.g~whatsapp-number-validator/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-michael.g-whatsapp-number-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/michael.g~whatsapp-number-validator/runs": {
            "post": {
                "operationId": "runs-sync-michael.g-whatsapp-number-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/michael.g~whatsapp-number-validator/run-sync": {
            "post": {
                "operationId": "run-sync-michael.g-whatsapp-number-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": "List of phone numbers to check. Include country codes for better accuracy, e.g. +1234567890.",
                        "default": [
                            "+919876543210",
                            "+14155552671"
                        ],
                        "items": {
                            "type": "string"
                        }
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```