Telegram Phone Number Validator | Bulk Verification API (2026)

Copy to your AI assistant

Copy this block into ChatGPT, Claude, Cursor, or any LLM to start using this actor.

clearpath/telegram-phone-number-validator on Apify. Call: ApifyClient("TOKEN").actor("clearpath/telegram-phone-number-validator").call(run_input={...}), then client.dataset(run["defaultDatasetId"]).list_items().items for results. Key inputs: phoneNumbers (array of strings, min 1000), csvFile (string, file upload), defaultCountryCode (string), testMode (boolean, default false in API; when true returns 3 sample records with isSample=true and no credits used — useful for preview/dev). Minimum 1,000 numbers per run, maximum 10,000. Full actor spec (input schema with all params/enums/defaults, output dataset fields, README): GET https://api.apify.com/v2/acts/clearpath~telegram-phone-number-validator/builds/default (Bearer TOKEN) → inputSchema, actorDefinition.storages.dataset, readme. Pricing: $0.003-$0.005/number depending on plan; 10 free on Free plan (paid plan needed to reach the 1,000-number minimum). Get token: https://console.apify.com/account/integrations

Changelog

March 2026 NEW Smart Column Detection — upload any CSV/Excel file, phone column detected automatically even without headers NEW AI Column Detection — files in any language (Arabic, Japanese, German, etc.) are handled via AI fallback NEW Scientific Notation Fix — Excel files with numbers like 9.17E+11 are automatically converted back Google Contacts, HubSpot, Salesforce Exports — works out of the box with multi-column files

Telegram number validation API - Verify 1,000 to 10,000 phone numbers per run and instantly know which ones have active Telegram accounts.

⚠️ Minimum 1,000 phone numbers per run This is a bulk validation service designed for large batches. For lists with 100-999 numbers, use WhatsApp Phone Number Validator instead. Test Mode is enabled by default so you can preview the output format without using credits. Disable Test Mode in the input panel to validate real numbers.

Stop wasting time on invalid Telegram contacts. This actor checks any phone number against Telegram's registration database and returns a simple yes/no for each number. Perfect for cleaning contact lists, validating leads, or building Telegram marketing campaigns.

• Bulk processing - Validate 1,000 to 10,000 numbers per run (minimum 1,000)
• Multiple input formats - Direct input, CSV, or Excel files
• Smart parsing - Auto-detects phone columns and normalizes formats
• Global coverage - Works with phone numbers from any country
• No Telegram account needed - Fully automated validation

---

Pricing

Apify Plan	Per Number	Per 1,000
Free	First 10 numbers free per account (paid plan needed to reach the 1,000 minimum)	-
No subscription	$0.005	$5.00
Bronze	$0.004	$4.00
Silver	$0.003	$3.00
Gold	$0.0025	$2.50

Examples

Numbers	No subscription	Bronze	Silver	Gold
1,000	$5.00	$4.00	$3.00	$2.50
5,000	$25.00	$20.00	$15.00	$12.50
10,000	$50.00	$40.00	$30.00	$25.00

Duplicates are auto-removed — you only pay for unique numbers.

---

Quick Start

Minimum 1,000 numbers per run. Examples below show 3 phones for brevity — pad with the rest of your list.

Basic - Direct Input

{
  "phoneNumbers": [
    "+1234567890",
    "+4915123456789",
    "+447911123456"
  ]
}

From CSV File

{
  "csvFile": "https://example.com/contacts.csv"
}

From Excel File

{
  "csvFile": "https://example.com/contacts.xlsx"
}

Combined Input

{
  "phoneNumbers": ["+1234567890"],
  "csvFile": "https://example.com/more-contacts.csv"
}

---

Input Parameters

Parameter	Type	Required	Description
phoneNumbers	array	No*	List of phone numbers with country code (e.g., +1234567890). Min 1,000, Max 10,000.
csvFile	string	No*	URL or Apify Key-Value store key to CSV or Excel (.xlsx) file with phone numbers
defaultCountryCode	string	No	Country code to prepend to numbers without a + prefix (e.g., 91 for India, 1 for US)
onlyTelegramUsers	boolean	No	Only output numbers that have Telegram (default: false)

*At least one of phoneNumbers or csvFile is required. Minimum 1,000 unique numbers required.

Phone Number Formats

The actor accepts phone numbers in various formats and normalizes them automatically:

+1234567890      E.164 (preferred)
1234567890       Without plus
+1 234 567 890   With spaces
+1-234-567-890   With dashes
(123) 456-7890   US format

Numbers Without Country Code

If your CSV contains local numbers without country code prefix (e.g., 9876543210 instead of +919876543210), use the defaultCountryCode field:

{
  "csvFile": "https://example.com/indian-contacts.csv",
  "defaultCountryCode": "91"
}

Your CSV	Default Country Code	Result
9876543210	91	+919876543210 (India) ✅
5551234567	1	+15551234567 (US) ✅
+447911123456	91	+447911123456 (unchanged) ✅

Numbers that already have a + prefix are not modified.

CSV/Excel File Requirements

• Supported formats: .csv, .xlsx
• Delimiters: Comma, semicolon, tab, pipe (auto-detected)
• Column detection: Automatically finds phone columns including:
  • Standard: phone, mobile, cell, tel, telephone, telegram
  • Variations: phone number, mobile number, cell phone, contact number
  • CRM exports: mobile phone, direct phone, work phone, personal phone, primary phone
  • International: telefon, telefono, téléphone, celular, handy
• No headers? Scans content to find phone-like columns automatically
• AI fallback: Non-English headers detected via AI when pattern matching fails

---

Output

Each validated number returns:

Field	Type	Description
phoneNumber	string	Phone number in E.164 format
originalInput	string	Original input as provided
countryCode	string	Detected country code (e.g., US, DE, GB)
isValidFormat	boolean	Whether the phone number has a valid format (7-15 digits)
hasTelegram	boolean	true if number has Telegram, false otherwise
telegramUsername	string|null	Telegram username if available (without @), null if not set
checkedAt	string	ISO 8601 timestamp of validation

Output Example

---

API Integration

Python

from apify_client import ApifyClient

client = ApifyClient("your_api_token")

run = client.actor("clearpath/telegram-phone-number-validator").call(
    run_input={
        "phoneNumbers": ["+1234567890", "+4915123456789"]
    }
)

for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    status = "Telegram" if item["hasTelegram"] else "No Telegram"
    print(f"{item['phoneNumber']}: {status}")

JavaScript

import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: 'your_api_token' });

const run = await client.actor('clearpath/telegram-phone-number-validator').call({
    phoneNumbers: ['+1234567890', '+4915123456789']
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();

items.forEach(item => {
    const status = item.hasTelegram ? 'Telegram' : 'No Telegram';
    console.log(`${item.phoneNumber}: ${status}`);
});

cURL

curl -X POST "https://api.apify.com/v2/acts/clearpath~telegram-phone-number-validator/runs?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"phoneNumbers": ["+1234567890", "+4915123456789"]}'

---

Advanced Usage

Validate from Google Sheets

Export your Google Sheet as CSV and use the public URL:

{
  "csvFile": "https://docs.google.com/spreadsheets/d/YOUR_SHEET_ID/export?format=csv"
}

Large Batch Processing

For lists over 10,000 numbers, split into multiple runs:

from apify_client import ApifyClient

client = ApifyClient("your_api_token")
all_numbers = [...]  # Your large list

# Split into chunks of 10,000
chunks = [all_numbers[i:i+10000] for i in range(0, len(all_numbers), 10000)]

all_results = []
for chunk in chunks:
    run = client.actor("clearpath/telegram-phone-number-validator").call(
        run_input={"phoneNumbers": chunk}
    )
    results = list(client.dataset(run["defaultDatasetId"]).iterate_items())
    all_results.extend(results)

print(f"Validated {len(all_results)} numbers")

Filter Telegram Users Only

Use the onlyTelegramUsers option to only output numbers with Telegram:

{
  "phoneNumbers": ["+1234567890", "+4915123456789"],
  "onlyTelegramUsers": true
}

Or filter programmatically:

telegram_users = [item for item in results if item["hasTelegram"]]
print(f"Found {len(telegram_users)} Telegram users")

---

FAQ

Q: Why is there a minimum of 1,000 numbers? A: Telegram validation uses a bulk processing pipeline with a 1,000-number minimum batch size. For lists of 100 to 999 numbers, use our WhatsApp Phone Number Validator instead, which supports a lower 100-number minimum.

Q: How accurate is the validation? A: Checks directly against Telegram's registration database. Results reflect status at time of validation.

Q: What countries are supported? A: All countries where Telegram operates. Numbers must include country code.

Q: Do I need a Telegram account? A: No. Fully automated, no Telegram credentials required.

Q: How fast is it? A: ~1-2 minutes per 1,000 numbers.

Q: What about duplicates? A: Auto-removed after normalization. You're only charged for unique numbers.

---

Related Actors

• WhatsApp Phone Number Validator - Validate WhatsApp numbers with a lower 100-number minimum batch size. Better suited for smaller lists.

---

Support

• Email: max@mapa.slmail.me
• Feature Requests: Email or submit via issues
• Response Time: Typically within 24 hours

---

Legal

This actor validates publicly available Telegram registration status. Users are responsible for complying with Telegram's Terms of Service and applicable data protection regulations (GDPR, CCPA).