# WhatsApp Number Checker (`muhammetakkurtt/whatsapp-number-checker`) Actor

Bulk-check which phone numbers are registered on WhatsApp — no account, no QR code and no ban risk. Validate active vs. inactive numbers and optionally return each number's public profile photo and WhatsApp Business status, exportable to CSV, Excel, JSON or the API.

- **URL**: https://apify.com/muhammetakkurtt/whatsapp-number-checker.md
- **Developed by:** [Muhammet Akkurt](https://apify.com/muhammetakkurtt) (community)
- **Categories:** Lead generation, Social media, Automation
- **Stats:** 6 total users, 4 monthly users, 100.0% runs succeeded, 2 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $4.00 / 1,000 number checkeds

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/actors/running/actors-in-store.md#pay-per-event

## What's an Apify Actor?

An Actor is a serverless cloud program that runs on the Apify platform. It has two run modes.
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.

Apify vocabulary and the platform model are defined once, in the agent quickstart at https://apify.com/agents.md.

## 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.

Do not guess an integration path. Every one of them is in the agent quickstart at https://apify.com/agents.md: the Apify MCP server, Agent Skills with the Apify CLI, the JavaScript and Python clients, the REST API, and the account-free path for an agent with no human to sign in. It also carries the rule on stating cost before the first paid run.

For examples already wired to this Actor's own input schema, see the [API](#api) section below.

Each client library has reference documentation the quickstart does not restate: [JavaScript/TypeScript](https://docs.apify.com/api/client/js/docs.md) (`npm install apify-client`) and [Python](https://docs.apify.com/api/client/python/docs.md) (`pip install apify-client`).

# README

## WhatsApp Number Checker — Bulk Validate & Verify Numbers on WhatsApp

**Check whether phone numbers are registered on WhatsApp — in bulk, fast, and with no account, no QR code, no device linking and no ban risk.** Paste a list of phone numbers and get a clean, structured dataset back: which numbers are **active on WhatsApp**, and optionally each number's **public profile photo** and **WhatsApp Business** status.

Use it to clean and validate phone lists before a WhatsApp campaign, confirm that leads and sign-ups use a real WhatsApp number, and enrich your CRM — all without connecting a phone or logging into WhatsApp.

### Why use this WhatsApp number checker?

- ✅ **Bulk WhatsApp validation** — check hundreds or thousands of numbers in one run and tell active WhatsApp numbers from inactive ones.
- 🔒 **No account, no QR scan, no ban risk** — nothing is linked to your phone or WhatsApp account; you only send numbers and get results.
- 🖼️ **Optional profile photo** — return whether a number has a public WhatsApp profile picture and its URL (`includeAvatar`).
- 💼 **Optional business flag** — detect whether a number is a **WhatsApp Business** account (`includeBusiness`).
- 📄 **Clean, structured output** — one row per number, ready to export to **CSV, Excel, JSON** or feed straight into your CRM, Make, Zapier or n8n.
- 💸 **Pay only for what you check** — transparent pay-per-result pricing; numbers that can't be checked are never charged.

### What can you do with it?

- **WhatsApp marketing & notifications** — clean your list before a broadcast to cut bounce rates, avoid wasted sends and protect your sender reputation.
- **Lead validation & qualification** — verify that leads, sign-ups or customers actually have an active WhatsApp number before you reach out.
- **CRM & database enrichment** — add WhatsApp presence, profile photo and Business-account signals to your contacts.
- **List cleaning & deduplication** — flag and drop inactive or invalid numbers to keep your contact database tidy.

### Input

| Field | Type | Description |
|---|---|---|
| `phoneNumbers` | array | Phone numbers to check, in international **E.164** format with a leading `+` and country code (e.g. `+14155550123`). Required. |
| `includeAvatar` | boolean | Also return the public profile-photo flag and its URL. Default `false`. |
| `includeBusiness` | boolean | Also return whether the number is a WhatsApp Business account. Default `false`. |

```json
{
  "phoneNumbers": ["+14155550123", "+12025550133"],
  "includeAvatar": false,
  "includeBusiness": false
}
```

### Output

One dataset item per number — export as CSV, Excel, JSON or XML:

```json
{
  "phone_number": "+14155550123",
  "registered": true,
  "success": true,
  "error": null
}
```

With `includeAvatar` and `includeBusiness` enabled, the matching fields are added:

```json
{
  "phone_number": "+14155550123",
  "registered": true,
  "avatar": true,
  "avatar_url": "https://...",
  "business": false,
  "success": true,
  "error": null
}
```

| Field | Description |
|---|---|
| `phone_number` | The number that was checked. |
| `registered` | `true` if the number is on WhatsApp, `false` if not. |
| `avatar` | Whether the number has a public profile photo (only with `includeAvatar`). |
| `avatar_url` | URL of the public profile photo, if any (only with `includeAvatar`). |
| `business` | Whether the number is a WhatsApp Business account (only with `includeBusiness`). |
| `success` | Whether the check completed. |
| `error` | Reason the number could not be checked, if any. |

### How it works

Paste your numbers, press **Start**, and the actor validates each number's format, checks whether it is on WhatsApp, and writes a clean row per number to the dataset. There is no account to connect, no QR code to scan and no device to link — you simply send numbers and receive results.

### Pricing

This actor uses the **pay-per-event** model: you pay a small fee **per number checked**, plus a small extra **only when a profile photo is returned** (`includeAvatar`). Numbers that are invalid or can't be checked are **not charged**. Volume discounts apply automatically on higher Apify plans.

### Free trial

Free Apify users can try this actor with up to **10 numbers per run**, **2 runs per 24 hours**, and **1 automated (scheduled/API/webhook) run per 24 hours**. Upgrade to any paid Apify plan to remove these limits and check in full volume.

### How to check if a number is on WhatsApp (step by step)

1. Add your phone numbers to **Phone numbers**, each in international format (e.g. `+14155550123`).
2. Optionally enable **Include profile photo** and/or **Include business flag**.
3. Press **Start** and wait for the run to finish.
4. Export the results from the **Dataset** tab as CSV, Excel or JSON.

### FAQ

**Do I need a WhatsApp account or to log in?**
No. You never connect a phone, scan a QR code or log into WhatsApp. You only provide the numbers you want to check.

**Is there any ban or block risk?**
No. The actor doesn't use your WhatsApp account, so there is nothing to ban or block.

**What phone number format should I use?**
International **E.164** format: a leading `+`, the country code, then the number, with no spaces or dashes — for example `+14155550123`. Numbers that aren't in this format are flagged and not charged.

**Can I check numbers in bulk?**
Yes. Add as many numbers as you need in one run; results are written one row per number.

**Which countries are supported?**
Any country — just provide each number in full international format with its country code.

**How do I export the results?**
From the run's **Dataset** tab, or via the Apify API, as CSV, Excel, JSON or XML. You can also connect it to Make, Zapier or n8n.

**Is checking WhatsApp numbers allowed?**
Use this actor only on numbers you own or have a lawful basis and consent to check, and handle the results — especially profile photos — in line with WhatsApp's terms and the privacy laws that apply to you (such as GDPR and KVKK). See **Responsible use** below.

### Responsible use

This actor is a tool for legitimate list validation and data hygiene — not for unsolicited messaging or for profiling people without their consent. Only check numbers you own or have permission to look up, store results securely, and comply with WhatsApp's terms and applicable data-protection laws (GDPR, KVKK and similar).

# Actor input Schema

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

Phone numbers to check, in international E.164 format with a leading + and country code (for example +447700900123). Invalid and duplicate entries are skipped. Free Apify plan users can check up to 10 numbers per run; paid plans have no trial cap.

## `includeAvatar` (type: `boolean`):

Also return whether the number has a public WhatsApp profile photo and its URL. Use only on numbers you own or have consent to look up. Costs an extra charge per number.

## `includeBusiness` (type: `boolean`):

Also return whether the number is a WhatsApp Business account.

## Actor input object example

```json
{
  "phoneNumbers": [
    "+12025550123",
    "+12125550133"
  ],
  "includeAvatar": false,
  "includeBusiness": false
}
```

# Actor output Schema

## `results` (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": [
        "+12025550123",
        "+12125550133"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("muhammetakkurtt/whatsapp-number-checker").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": [
        "+12025550123",
        "+12125550133",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("muhammetakkurtt/whatsapp-number-checker").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).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": [
    "+12025550123",
    "+12125550133"
  ]
}' |
apify call muhammetakkurtt/whatsapp-number-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,muhammetakkurtt/whatsapp-number-checker"
        }
    }
}
```

The hosted server signs you in with OAuth on first connect, so no API token belongs in this config. Clients without OAuth support can send an `Authorization: Bearer <APIFY_API_TOKEN>` header instead, using a token from API & Integrations in Apify Console (https://console.apify.com/settings/integrations).

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/Fr3hGGjUD9Ak1hY1G/builds/faSGSUtcFkLvBoHXm/openapi.json