# WhatsApp Number Lookup — Profile, Telegram, Bulk (`datapilot/whatsapp-number-lookup-profile-telegram-bulk`) Actor

This Actor accepts one or multiple US phone numbers, validates their format, checks WhatsApp availability, optionally cross-checks Telegram, and returns organized JSON results for each number.

- **URL**: https://apify.com/datapilot/whatsapp-number-lookup-profile-telegram-bulk.md
- **Developed by:** [Data Pilot](https://apify.com/datapilot) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $26.00 / 1,000 scraped results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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 Lookup — Profile, Telegram, Bulk** is a powerful Apify Actor designed to discover, verify, and enrich US phone numbers with WhatsApp registration status, profile details, and optional Telegram cross-checking. This tool provides comprehensive **WhatsApp Number Lookup — Profile, Telegram, Bulk** intelligence including registration status, account type, profile picture, about text, and Telegram presence for any US phone number. Whether you're validating leads, cleaning a contact list, or conducting OSINT research, the WhatsApp Number Lookup — Profile, Telegram, Bulk actor delivers actionable insights efficiently.

With direct WhatsApp click-to-chat parsing, optional Telegram cross-checking, concurrent bulk processing, and reliable Apify Dataset delivery, this **WhatsApp Number Lookup — Profile, Telegram, Bulk** actor ensures comprehensive coverage across any list of US phone numbers. It focuses on key signals including registration status, account type (Business vs. Personal), and profile metadata, making **WhatsApp Number Lookup — Profile, Telegram, Bulk** an essential tool for lead verification and contact intelligence.

***

### 📋 Table of Contents

- [Features](#-features)
- [Data Source](#-data-source)
- [How It Works](#-how-it-works)
- [Input](#-input)
- [Output](#-output)
- [Technical Stack](#-technical-stack)
- [Data Fields](#-data-fields-explained)
- [Use Cases](#-use-cases)
- [Quick Start](#-quick-start)
- [Configuration](#-configuration)
- [Performance](#-performance)
- [Important Notes](#-important-notes)
- [License & Legal](#-license--legal)

***

### 🔥 Features

- **WhatsApp Click-to-Chat Parsing** – Uses WhatsApp's public `wa.me` links to determine registration status without needing the WhatsApp API. This is the core of **WhatsApp Number Lookup — Profile, Telegram, Bulk**.
- **Business vs. Personal Detection** – Automatically classifies each number as a WhatsApp Business or Personal account.
- **Profile Metadata Extraction** – Captures profile picture URL and about/description text from OpenGraph and Twitter meta tags.
- **Optional Telegram Cross-Check** – Checks the same number against Telegram's public profile pages for a fuller **WhatsApp Number Lookup — Profile, Telegram, Bulk** picture.
- **US Phone Number Validation** – Sanitizes and validates 10/11-digit US numbers before processing, flagging invalid formats clearly.
- **Bulk Concurrent Processing** – Processes multiple phone numbers in parallel using an async semaphore, configurable via `maxConcurrent`.
- **Proxy Fallback Handling** – Automatically retries without a proxy if a proxied request fails.
- **Residential Proxy Support** – Optional Apify residential proxy for reliable **WhatsApp Number Lookup — Profile, Telegram, Bulk** access.
- **Single-Batch Dataset Push** – Pushes all bulk lookup results to Apify Dataset together once processing completes.
- **Detailed Logging** – Logs progress and completion status for every bulk **WhatsApp Number Lookup — Profile, Telegram, Bulk** run.
- **Graceful Error Handling** – Returns a clear "invalid format" or "network timeout" record instead of failing the whole batch.

***

### 📊 Data Source

#### **WhatsApp & Telegram Public Profile Pages**

- **Authority**: WhatsApp's public `wa.me` click-to-chat pages and Telegram's public `t.me` profile pages
- **Access Method**: Browser-impersonated HTTP requests via \`\`, parsing rendered HTML and OpenGraph metadata
- **Coverage**: Any US phone number reachable through WhatsApp's public link system
- **Data**: Registration status, account type, profile picture, about text, and Telegram presence
- **Access**: Public pages, no official API key required
- **Update Frequency**: Reflects each number's live status at time of run

***

### ⚙️ How It Works

The WhatsApp Number Lookup — Profile, Telegram, Bulk actor accepts one or more US phone numbers, sanitizes and validates each into an 11-digit format, then fetches WhatsApp's public `wa.me` page for that number. Response text is scanned for known "not registered" phrases, business-account indicators, and OpenGraph meta tags containing profile picture and about text. If Telegram cross-checking is enabled, the same number is also checked against Telegram's public `t.me` profile page for a name and avatar. All numbers are processed concurrently up to a configurable limit, and every result is pushed to the Apify Dataset together as one batch at the end of the run.

**Key Processing Steps:**

1. **Input Parsing** – Accept a single phone number or a list of US phone numbers
2. **Proxy Setup** – Configure Apify residential proxy if enabled, with automatic no-proxy fallback
3. **Phone Sanitization** – Strip non-digit characters and normalize to 11-digit US format
4. **Format Validation** – Reject numbers that don't match the expected 10/11-digit US pattern
5. **Concurrent Dispatch** – Queue all numbers for processing under a semaphore-limited concurrency pool
6. **WhatsApp Check** – Fetch the `wa.me` page and parse registration, account type, picture, and about text
7. **Telegram Check** – Optionally fetch the `t.me` page and parse name/avatar, if enabled
8. **Result Assembly** – Combine WhatsApp and Telegram data into one record per phone number
9. **Batch Gathering** – Wait for all concurrent lookups to complete via `asyncio.gather`
10. **Dataset Push** – Push the full batch of **WhatsApp Number Lookup — Profile, Telegram, Bulk** records at once
11. **Summary Logging** – Report the total number of numbers successfully checked

**Key Benefits:**

- Pull WhatsApp registration and profile data for any US phone number without manual checks
- Optionally cross-reference the same number on Telegram in the same run
- Process large lists of numbers concurrently for fast bulk verification
- Feed lead-verification pipelines, contact-cleaning tools, or OSINT research workflows
- Automate recurring **WhatsApp Number Lookup — Profile, Telegram, Bulk** checks as your contact list grows

***

### 📥 Input

The Actor accepts the following input parameters:

| Field | Type | Default | Description |
|-------|------|---------|-------------|
| `phoneNumbers` | array | `["+14155238886"]` | List of US phone numbers to check. |
| `phoneNumber` / `phone` | string | *(optional)* | Single-number fallback used if `phoneNumbers` is not provided. |
| `crossCheckTelegram` | boolean | `true` | Whether to also check each number against Telegram. |
| `maxConcurrent` | integer | `5` (max `20`) | Maximum number of numbers processed concurrently. |
| `proxyConfiguration` | object | `{"useApifyProxy": true}` | Apify Proxy configuration. |

**Example Input:**

```json
{
  "phoneNumbers": ["+14155551234", "+14155555678"],
  "crossCheckTelegram": true,
  "maxConcurrent": 5
}
```

**Check a Single Number:**

```json
{
  "phoneNumber": "+14155551234"
}
```

**Bulk Lookup Without Telegram Cross-Check:**

```json
{
  "phoneNumbers": ["+14155551234", "+14155555678", "+14155559999"],
  "crossCheckTelegram": false,
  "maxConcurrent": 10
}
```

***

### 📤 Output

The Actor pushes **WhatsApp Number Lookup — Profile, Telegram, Bulk** records with the following structure:

| Field | Type | Description |
|-------|------|-------------|
| `phone` | string | The normalized phone number checked (E.164 format) |
| `country` | string | Always `"United States (+1)"` |
| `is_registered` | boolean | Whether the number is registered on WhatsApp |
| `account_type` | string | `"WhatsApp Business"`, `"Personal Account"`, `"Unregistered"`, or `"Invalid"` |
| `about` | string | About/description text extracted from the WhatsApp profile page |
| `profile_pic_url` | string | URL of the profile picture, or a placeholder if unavailable |
| `status_details` | string | Human-readable status summary |
| `telegram` | object | `{exists, username, avatar}` — Telegram cross-check results |
| `checked_at` | string | ISO 8601 timestamp of when the record was checked |

**Example WhatsApp Number Lookup — Profile, Telegram, Bulk Record:**

```json
{
  "phone": "+14155551234",
  "country": "United States (+1)",
  "is_registered": true,
  "account_type": "WhatsApp Business",
  "about": "Customer Support | Mon-Fri 9am-5pm",
  "profile_pic_url": "https://pps.whatsapp.net/...",
  "status_details": "Active WhatsApp account",
  "telegram": {
    "exists": true,
    "username": "Support Team",
    "avatar": "https://cdn4.telesco.pe/..."
  },
  "checked_at": "2026-08-17T09:00:00.000Z"
}
```

***

### 🧰 Technical Stack

- **HTTP Client:** \`\` with Chrome TLS fingerprint impersonation for reliable page access
- **Sources:** WhatsApp `wa.me` click-to-chat pages and Telegram `t.me` public profile pages
- **HTML/Meta Parsing:** Regex-based extraction of OpenGraph and Twitter card meta tags
- **Concurrency:** `asyncio.Semaphore` for controlled parallel bulk processing
- **Date Handling:** `datetime` with timezone-aware UTC timestamps
- **Async:** `asyncio` with executor-run blocking requests for non-blocking concurrent lookups
- **Proxy:** Apify Proxy, optional via `useApifyProxy`, with automatic no-proxy fallback on failure
- **Logging:** Apify Actor logging system
- **Platform:** Apify Actor serverless environment

***

### 📊 Data Fields Explained

#### **Identification**

- **phone / country**: The normalized number checked and its country context

#### **WhatsApp Status**

- **is\_registered / account\_type**: Whether the number is on WhatsApp, and whether it's a Business or Personal account
- **about / profile\_pic\_url**: Publicly visible profile details, when available
- **status\_details**: A short human-readable summary of the check outcome

#### **Telegram Cross-Check**

- **telegram.exists / telegram.username / telegram.avatar**: Whether the same number has a public Telegram presence, and its visible name/avatar

***

### 🎯 Use Cases

- **Lead Verification** – Confirm phone numbers are active on WhatsApp before outreach campaigns
- **Contact List Cleaning** – Remove unregistered or invalid numbers from a marketing database
- **Business Account Detection** – Identify which contacts use WhatsApp Business for B2B targeting
- **Cross-Platform OSINT** – Check both WhatsApp and Telegram presence for a number in one pass
- **Customer Onboarding** – Validate phone numbers at signup before enabling WhatsApp-based support
- **Fraud Prevention** – Flag numbers with suspicious or inconsistent registration patterns
- **Sales & Marketing Ops** – Prioritize outreach to numbers confirmed active on WhatsApp
- **Compliance & KYC** – Support identity-verification workflows with multi-platform presence checks

***

### 🚀 Quick Start

#### **1. Prepare Input**

Go to Apify Console and enter:

```json
{
  "phoneNumbers": ["+14155551234", "+14155555678"],
  "crossCheckTelegram": true
}
```

#### **2. Run the Actor**

Click **Start**. The Actor will:

- Sanitize and validate each US phone number
- Check WhatsApp registration status and profile details concurrently
- Optionally cross-check each number on Telegram
- Push all results to the Dataset as one batch

#### **3. Monitor Progress**

Console shows:

```
🚀 Processing lookup for 2 US phone number(s)...
✅ Successfully checked 2 US numbers!
🎉 Complete!
```

#### **4. View & Download Results**

- **Results Tab**: All **WhatsApp Number Lookup — Profile, Telegram, Bulk** records
- **Export**: JSON, CSV, Excel, or HTML
- **Filter**: By registration status, account type, or Telegram presence
- **API Access**: Available via the Apify API

***

### ⚙️ Configuration

Single number:

```json
{
  "phoneNumber": "+14155551234"
}
```

Bulk list with higher concurrency:

```json
{
  "phoneNumbers": ["+14155551234", "+14155555678", "+14155559999"],
  "maxConcurrent": 15
}
```

WhatsApp-only check, no Telegram:

```json
{
  "phoneNumbers": ["+14155551234"],
  "crossCheckTelegram": false
}
```

***

### 📈 Performance

#### **Processing Speed**

- Up to `maxConcurrent` numbers processed in parallel (capped at 20)
- Two requests per number when Telegram cross-checking is enabled, one when disabled
- Scales efficiently for bulk lists thanks to semaphore-controlled concurrency

#### **Resource Usage**

- Memory: Low, since no browser instance is launched
- Network: One or two lightweight requests per phone number, depending on Telegram cross-checking
- Proxy: Optional residential proxy tunnel with automatic no-proxy fallback on failure

***

### ⚠️ Important Notes

#### **Legal & Compliance**

- **Fair Use**: Respects WhatsApp's and Telegram's public pages and applies concurrency limits to reduce load
- **Public Data Only**: Retrieves only publicly visible profile information exposed via public click-to-chat and profile pages
- **Privacy**: Collecting personal contact data may be subject to privacy regulations (e.g., GDPR, TCPA) — use only for consented or legitimate purposes
- **Legal**: Not legal advice — consult qualified professionals before using this data for compliance-sensitive decisions

#### **Data Quality**

- **Freshness**: Reflects each number's live status at time of run
- **Completeness**: Private or restricted profiles may return placeholder values for picture and about text
- **Accuracy**: Third-party page parsing accuracy may vary if WhatsApp or Telegram change their public page structure
- **Verification**: Manually verify high-stakes results before acting on them

#### **Best Practices**

- Only submit valid 10/11-digit US phone numbers for accurate **WhatsApp Number Lookup — Profile, Telegram, Bulk** results
- Enable Telegram cross-checking only when you need the extra data point, to reduce request volume
- Keep `maxConcurrent` reasonable to avoid rate limiting on large bulk runs
- Always configure a residential proxy for the most reliable access at scale
- Re-run periodically if tracking changes in registration status over time

***

### 📄 License & Legal

**Terms of Use:**

- Use for legitimate verification, OSINT, and lead-qualification purposes
- Respect the terms of service of WhatsApp and Telegram
- Do not use for unsolicited contact, harassment, spam, or unlawful surveillance
- Use data responsibly and in compliance with applicable privacy and telemarketing laws

**Disclaimer:**
WhatsApp Number Lookup — Profile, Telegram, Bulk is provided as-is for research and verification purposes. Users are responsible for compliance with all applicable laws, including telemarketing and privacy regulations, and the terms of service of WhatsApp and Telegram. This is not legal advice.

***

### ⚖️ WhatsApp Number Lookup — Profile, Telegram, Bulk Excellence

This Actor is optimized for **WhatsApp Number Lookup — Profile, Telegram, Bulk** research with:

- ✅ Public click-to-chat based WhatsApp verification
- ✅ Business vs. Personal account classification
- ✅ Optional Telegram cross-checking in the same run
- ✅ Concurrent bulk processing with configurable limits
- ✅ Proxy fallback for reliable access
- ✅ Production-ready code

# Actor input Schema

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

List of US phone numbers (e.g. +14155238886, 16503885800).

## `crossCheckTelegram` (type: `boolean`):

Check if number has an active public Telegram profile.

## `maxConcurrent` (type: `integer`):

Concurrent worker requests.

## `proxyConfiguration` (type: `object`):

Apify Proxy configuration.

## Actor input object example

```json
{
  "phoneNumbers": [
    "+14155238886",
    "+16503885800"
  ],
  "crossCheckTelegram": true,
  "maxConcurrent": 5,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

## `crawlResults` (type: `string`):

No description

## `lookupOverview` (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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("datapilot/whatsapp-number-lookup-profile-telegram-bulk").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("datapilot/whatsapp-number-lookup-profile-telegram-bulk").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 '{}' |
apify call datapilot/whatsapp-number-lookup-profile-telegram-bulk --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,datapilot/whatsapp-number-lookup-profile-telegram-bulk"
        }
    }
}
```

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/z0FX2NATP9V4GM22e/builds/9pu8esMcFMpVTqwHh/openapi.json