Pricing

Rating

Developer

Actor stats

Categories

Share

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 falsein 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;10free on Free plan (paid plan needed to reach the 1,000-number minimum). Get token: https://console.apify.com/account/integrations

Changelog

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

👁 Demo

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

Examples

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

*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:

+1234567890E.164(preferred)
1234567890 Without plus
+1234567890 With spaces
+1-234-567-890 With dashes
(123)456-7890US 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"
}

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
• International headers: Non-English phone columns are detected automatically when possible

Output

Each validated number returns:

Telegram accounts only exist on mobile numbers. Landlines and other non-mobile lines are listed with skipReason: "not_mobile", and numbers that cannot be read are listed with skipReason: "invalid_format". These rows have hasTelegram: null, are not submitted for checking, and are never charged, so nothing in your input silently disappears. Only mobile numbers count toward the per-run minimum.

Output Example

👁 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 =newApifyClient({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 inrange(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

More from Clearpath (Email tools):

• Email Account Checker - Check emails for real account registration on Gmail, Outlook, Yahoo, iCloud, Mail.ru.
• Email Address Validator - Bulk email deliverability validation (syntax, MX, SMTP, catch-all, disposable).
• Email Finder & Verifier - Find and verify B2B email addresses by name and domain.

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