# WhatsApp Number Lookup — Profile, Leaks, Telegram, Bulk (`eduair94/whatsapp-data-lookup`) Actor

Verify any WhatsApp number worldwide. Returns profile picture (real pics for normal users, not just businesses), about/status, business flag, Telegram cross-check, Google/TrueCaller intel, leak/breach data, and bulk verification. Covers gaps left by generic WA lookup actors.

- **URL**: https://apify.com/eduair94/whatsapp-data-lookup.md
- **Developed by:** [Eduardo Airaudo](https://apify.com/eduair94) (community)
- **Categories:** Lead generation, Automation, Other
- **Features:** Limited permissions
- **Stats:** 2,601 total users, 223 monthly users, 100.0% runs succeeded, 20 bookmarks
- **User rating**: 4.95 out of 5 stars

## Pricing

from $50.00 / 1,000 live whatsapp lookup — number founds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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

## Phone Number Lookup for WhatsApp — Profile, Telegram, Breach Check, Bulk

> WhatsApp is a trademark of WhatsApp LLC. This actor is operated by CheckLeaked, an independent service not affiliated with, endorsed by, or sponsored by WhatsApp LLC or Meta Platforms, Inc.

Verify any WhatsApp number worldwide and get back far more than a yes/no answer. This actor returns the real profile picture (even for normal, non-business users), the `about` / status text, Telegram presence and profile, carrier data, Google and TrueCaller intel, and — uniquely — matches against a curated **phone-number breach database** (Facebook leak, Dehashed, LeakCheck Pro, HIBP).

Supports bulk input up to 100,000 numbers per run. Pay-per-event pricing: you are only charged for successful, fresh lookups.

### Why this actor

Generic WhatsApp lookup actors on the store answer one question: does this number exist on WhatsApp? They typically return a profile picture only when the number is registered as a WhatsApp Business account, offer no cross-platform intelligence, and have no access to leaked phone-number records.

This actor closes those gaps:

- **Profile pictures for normal users** — not just businesses. If the user has a public avatar, you get the URL.
- **About / status text** — the short bio users set on their profile.
- **Telegram cross-check** — same phone, Telegram profile if it exists: username, display name, last-seen, Premium flag, verified flag, photo URL.
- **Dedicated phone-number breach database** — match the number against Facebook's 533M leak, Adecco, and other dumps indexed by Dehashed, LeakCheck Pro, and HIBP.
- **Permanent cache** — repeat queries served from our database at a fraction of the price.
- **Database-only mode** — query the archive without ever hitting WhatsApp.
- **Bulk throughput** — up to 50 concurrent workers per run.

### Pricing — Pay per event

You only pay for successful results. Numbers that are not on WhatsApp, upstream timeouts, rate-limit errors, and validation failures are always free.

| Event                                 | When it fires                                                     | Price      |
| ------------------------------------- | ----------------------------------------------------------------- | ---------- |
| Live WhatsApp lookup — number found   | Fresh upstream check, number exists, result not served from cache | `$0.05`    |
| Cached WhatsApp lookup — number found | Served from our permanent cache, no live upstream call            | `$0.0002`  |
| Database-only search hit              | Record found in archived / leak database, no live lookup          | `$0.0002`  |
| Profile picture addon                 | Non-default profile picture URL returned (live fetch)             | `+$0.10`   |
| Leak / breach data addon              | One or more breach records returned                               | `+$0.002`  |

Typical costs:

- 1,000 fresh successful lookups (no addons) → **$50**
- 1,000 cached lookups → **$0.20**
- 10,000 numbers, cache-first, 70% cache hit rate, no addons → **~$150**
- Numbers that are not on WhatsApp, timeouts and errors → **$0**

**Running more than ~10,000 live checks a month?** The same data is much cheaper as a flat-rate API key: from **$105 per 50,000 requests** (120-day validity, every request counted, ≈$0.002 each) at [whatsapp-sub.checkleaked.com](https://whatsapp-sub.checkleaked.com/) or the Pro/Ultra/Mega plans on [RapidAPI](https://rapidapi.com/airaudoeduardo/api/wp-data). Use this Actor when you want zero setup, pay only for hits, or need the no-code integrations.

### Input

| Field               | Type          | Default | Description                                                                                |
| ------------------- | ------------- | ------- | ------------------------------------------------------------------------------------------ |
| `numbers`           | array<string> | —       | Phone numbers in international format, with or without `+`. Auto-normalized (digits only). |
| `preferCache`       | boolean       | `true`  | Try the permanent cache first; fall through to a live lookup only on miss.                 |
| `onlyCache`         | boolean       | `false` | Never make live WhatsApp calls. Pairs with the cheapest pricing tiers.                     |
| `includeProfilePic` | boolean       | `true`  | Include the profile picture URL when available.                                            |
| `includeAbout`      | boolean       | `true`  | Include the `about` / status text.                                                         |
| `includeTelegram`   | boolean       | `false` | Cross-check the same number on Telegram and return the full profile if present.            |
| `includeLookup`     | boolean       | `false` | TrueCaller-style name and spam lookup.                                                     |
| `includeGoogle`     | boolean       | `false` | Cached Google search intel for the number.                                                 |
| `includeLeaks`      | boolean       | `false` | Query phone-number breach databases (FB leak, Dehashed, LeakCheck Pro, HIBP).              |
| `fbProfilePic`      | boolean       | `false` | Return the Facebook leak profile picture when available, independently from other leaks.   |
| `includeCarrier`    | boolean       | `false` | Mobile carrier + country lookup.                                                           |
| `concurrency`       | integer       | `5`     | Parallel workers (1 – 50).                                                                 |
| `timeoutMs`         | integer       | `30000` | Per-lookup timeout in milliseconds.                                                        |

#### Example input

```json
{
  "numbers": ["+14155552671", "+5491112345678"],
  "preferCache": true,
  "includeProfilePic": true,
  "fbProfilePic": true,
  "includeTelegram": true,
  "includeLeaks": true,
  "concurrency": 10
}
```

### Output

Each number produces one row in the default dataset. Fields that were not requested are omitted from the output.

```json
{
  "number": "59898297150",
  "exists": true,
  "isBusiness": false,
  "urlImage": "https://whatsapp-db.checkleaked.com/59898297150.jpg",
  "facebookProfilePicUrl": "https://whatsapp-db.checkleaked.com/fb/1217097936.jpg",
  "about": "Available",
  "telegram": {
    "id": 714847253,
    "username": "DeadAir94",
    "first_name": "Edu",
    "last_name": "Air",
    "premium": true,
    "user_was_online": "2026-04-17 17:20:35 UTC",
    "photoUrl": "https://.../714847253_photo.jpeg"
  },
  "leakedData": {
    "entries": [
      {
        "entry": {
          "name": "Eduardo Airaudo",
          "phone": "98297150",
          "database_name": "Facebook",
          "company": "Taquigrafia",
          "source": { "Name": "Facebook", "BreachDate": "2019-08-01" }
        }
      }
    ],
    "results": 3
  },
  "fbLeak": {
    "data": {
      "firstName": "Eduardo",
      "lastName": "Airaudo",
      "fbId": "1217097936",
      "regionCode": "UY"
    }
  },
  "source": "fresh",
  "fetchedAt": "2026-04-23T13:26:35.807Z"
}
```

The `source` field is one of:

- `fresh` — live WhatsApp lookup (charged at the fresh rate)
- `cache` — served from our cache (charged at the cached rate)
- `database` — archived / leak record only (charged at the database rate)
- `not-found` — number not on WhatsApp (free)
- `error` — upstream issue that persisted through 4 retry attempts, or invalid input (free; see `error` for the reason)

A `SUMMARY` object is also written to the key-value store with per-source counts once the run finishes.

### Use cases

- **KYC and fraud prevention** — verify that a phone number is a real, active WhatsApp user, not a burner.
- **Authorized investigations** — fraud, scam and security investigations carried out with a lawful basis.
- **CRM data hygiene** — check that numbers your customers gave you are active and flag business accounts.
- **Security research** — check whether a user's phone has appeared in a known breach before onboarding them.

### Performance

- Median fresh lookup: **~1.5 seconds**
- Cached lookup: **<200 ms**
- Sustained throughput at `concurrency=20`: **~800 numbers / minute**
- Bulk cap per run: **100,000 numbers**

### FAQ

**Am I charged when a number is not on WhatsApp?**
No. Only successful lookups of numbers that exist on WhatsApp are billed. Not-found and errors are always free.

**Am I charged twice if I enable both profile pic and leaks?**
Addons stack on top of the base lookup charge. A cached lookup with pic + leaks costs `$0.0002 + $0.10 + $0.002 = $0.1022` total; a live lookup with the same addons costs `$0.05 + $0.10 + $0.002 = $0.152`. Leave `includeProfilePic` off when you only need existence / business status.

**How long is the cache kept?**
Cached entries are permanent until overwritten by a later fresh lookup for the same number. Set `preferCache: false` if you need a guaranteed-live read.

**What about rate limits and transient errors?**
The actor paces itself at 4 requests/second per run and retries transient upstream failures automatically — HTTP 429 (rate limit), 502/503/504 (upstream restart or no free WhatsApp session) and socket errors — up to 4 attempts with exponential backoff, honouring `Retry-After`. A row only becomes `source: "error"` after the last attempt fails; the `error` field then says what happened (for example `Upstream rate limit (HTTP 429) persisted after 4 attempts`). Validation failures such as a number without a country code are reported immediately with the upstream message and never retried. Error rows are never billed.

**Does this actor phone home or store my numbers?**
Numbers are normalized, sent to the lookup backend, and the responses are written to your Apify dataset. No separate logging or retention on the actor side.

**Can I run this on Apify proxy?**
All HTTPS calls go to a single upstream endpoint; using Apify proxy for outbound here adds latency without benefit.

### Output schema

Datasets can be exported to JSON, JSONL, CSV, XML, Excel, and HTML directly from the Apify console or via API. Use the `SUMMARY` key-value store entry for per-run aggregates.

### Feedback and issues

Open an issue on the actor's **Issues** tab in the Apify console, or email the maintainer listed on the store page. Feature requests welcome — especially around additional data sources and cross-platform checks.

### Legal

Results contain personal data about third parties. Using this actor means accepting the CheckLeaked [Terms of Service](https://whatsapp.checkleaked.cc/terms); see also the [Privacy Policy](https://whatsapp.checkleaked.cc/privacy).

- You must have a lawful basis — and the person's consent where the law requires it — for every number you look up, under GDPR, CCPA, LGPD and any other law that applies to you.
- Prohibited: stalking, harassment, locating or monitoring people, eligibility decisions (employment, credit, housing, insurance), discrimination or targeting by sensitive characteristics, unsolicited marketing, and resale of results.
- Breach-check results may only be used for security, fraud prevention and exposure assessment.
- Phone number owners can opt out at https://whatsapp.checkleaked.cc/opt-out. Opted-out numbers return no data; delete what you hold about them when notified.

WhatsApp is a trademark of WhatsApp LLC. CheckLeaked is not affiliated with, endorsed by, or sponsored by WhatsApp LLC or Meta Platforms, Inc.

# Actor input Schema

## `numbers` (type: `array`):

List of phone numbers in international format (with or without '+'). Example: +14155552671, 5491112345678.

## `preferCache` (type: `boolean`):

Try /number_cache first. If cached entry exists, skip live lookup. Falls through to live fetch on miss unless 'onlyCache' is set.

## `onlyCache` (type: `boolean`):

Never make live WhatsApp calls. Returns only data already in the database. Pairs with super-cheap per-hit pricing.

## `includeProfilePic` (type: `boolean`):

Return WhatsApp profile picture URL when available. Works for normal users (not just businesses).

## `includeAbout` (type: `boolean`):

Return the user's WhatsApp status / about text when available.

## `includeTelegram` (type: `boolean`):

Include Telegram presence + profile if the same number is on Telegram.

## `includeLookup` (type: `boolean`):

Attach the cached TrueCaller lookup (name, spam score, tags) for the number.

## `includeGoogle` (type: `boolean`):

Attach cached Google search results for the number (public mentions, OSINT hints).

## `includeLeaks` (type: `boolean`):

Query breach databases (Dehashed, LeakCheck Pro, FB leak) for the number.

## `fbProfilePic` (type: `boolean`):

Fetch the Facebook leak record and return its stored profile picture when available. Independent from includeLeaks.

## `includeCarrier` (type: `boolean`):

Attach mobile carrier + country information for the number.

## `concurrency` (type: `integer`):

How many numbers to process in parallel. Higher = faster but may hit upstream rate limits.

## `timeoutMs` (type: `integer`):

Abort a single number lookup if it takes longer than this many milliseconds.

## Actor input object example

```json
{
  "numbers": [
    "+14155552671"
  ],
  "preferCache": true,
  "onlyCache": false,
  "includeProfilePic": true,
  "includeAbout": true,
  "includeTelegram": false,
  "includeLookup": false,
  "includeGoogle": false,
  "includeLeaks": false,
  "fbProfilePic": false,
  "includeCarrier": false,
  "concurrency": 5,
  "timeoutMs": 30000
}
```

# Actor output Schema

## `results` (type: `string`):

One JSON record per input number, containing WhatsApp presence, optional profile picture, about text, Telegram cross-check, breach data, and the source tier (fresh / cache / database / not-found / error).

## `summary` (type: `string`):

Aggregated counts per source tier for the whole run — total processed, fresh lookups, cache hits, database hits, not-found, errors — plus the finish 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 '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "numbers": [
        "+14155552671"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("eduair94/whatsapp-data-lookup").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 = { "numbers": ["+14155552671"] }

# Run the Actor and wait for it to finish
run = client.actor("eduair94/whatsapp-data-lookup").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 '{
  "numbers": [
    "+14155552671"
  ]
}' |
apify call eduair94/whatsapp-data-lookup --silent --output-dataset

```

## MCP server setup

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

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/7eBLtpkdsw40ZmJaH/builds/ctf5s96a1cDno4to3/openapi.json