# Telegram Profile Contact Scraper (`leads-scraper/telegram-profile-contact-scraper`) Actor

Telegram Profile Contact Scraper SD - Telegram Profile Contact Scraper is a lead generation tool that extracts leads with public contact emails, bio, follower counts and profile URLs from Telegram profile URLs or usernames - Telegram profile scraper for creator outreach.

- **URL**: https://apify.com/leads-scraper/telegram-profile-contact-scraper.md
- **Developed by:** [Leads Scraper](https://apify.com/leads-scraper) (community)
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.19 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.
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

### Telegram Profile Contact Scraper

**Telegram Profile Contact Scraper** turns public Telegram channels and users into a clean contact sheet.
There are two ways in: give the Telegram Profile Contact Scraper **keywords** and it goes looking for public channels and accounts that publish a contact address, or give it **`t.me` links and handles** you already have.
Either way every target is then fetched from its **public** page, so each row carries the address published for it plus the profile data Telegram shows. The two inputs combine in one run, and a run with neither fails.

Read this before you plan a run: **Telegram public pages expose a channel or user title, a description, a photo and the subscriber count.**
That is measured, not assumed, and the subscriber figure lands in `followersCount`.

Post counts are not published, and neither are following or like counts or any verified or private flag, so a Telegram row carries none of those columns. The subscriber count arrives in `followersCount`.

A Telegram target is often a public **channel** rather than a person, so treat `fullName` and `displayName` as the channel or user title, not necessarily a human name.

Within those honest limits the Telegram Profile Contact Scraper does one job well: it finds the public contact address attached to a handle, at batch scale. Email yield does not ride on the description alone, because a keyword run brings the address back with the search result.

### What the Telegram Profile Contact Scraper does

The Telegram Profile Contact Scraper works from either end.
If you already know which channels or handles you want, it enriches them with a public title, description and contact address; if you do not, a keyword run finds public channels and users that publish an address and enriches those the same way.

The Telegram Profile Contact Scraper reads only **public** page data. There is no login, no cookies, no phone number, no bot token, no private or official API, and no browser or JavaScript rendering — everything it collects is what a signed-out visitor sees on the public `t.me` page.

That makes it a practical **Telegram email finder** for creator outreach, a **Telegram profile scraper** for lead enrichment, and a **Telegram bio email extractor** for anyone building a prospecting list.

Typical inputs are a keyword, a list of channel links from a media kit, or an export of handles from your CRM. Output is one flat row per target, so results drop straight into a spreadsheet, a sequencer or a lead database.

### Why choose this Telegram Profile Contact Scraper

Most **Telegram lead generation** workflows stall at the same point: you have the channel, but not the email.
The Telegram Profile Contact Scraper closes that gap in one run, with a stable schema you can map into a CRM once and reuse.

Addresses reach a Telegram Profile Contact Scraper row from the Google result and from the page itself, and both go through the same obfuscation-aware matching.
`name [at] domain [dot] com`, spaced `a @ b`, zero-width characters and full-width `＠` are all normalised before the address is matched.

The Telegram Profile Contact Scraper drops placeholder locals such as `email@`, `yourname@` and `noreply@`.
Real role addresses like `hi@`, `hey@` and `hello@` are deliberately kept, because those are the ones channel owners publish for ad enquiries.

Domain matching is boundary-correct, so `@gmail.com` never matches inside `@gmail.company` — a shorter, cleaner list than a naive regex sweep produces.

Channel owners very often put an "ads / partnerships" address straight into the description, which is exactly what both phases read.

### How the Telegram Profile Contact Scraper works

The Telegram Profile Contact Scraper runs in two phases, and the order is the whole design. Targets you supply skip the first phase and go straight to the fetch.

**Phase 1 — Google harvest, on the GOOGLE_SERP proxy.** Given keywords, the Telegram Profile Contact Scraper searches Google with an email dork — `site:t.me crypto "@gmail.com"` — expanded across keyword x modifier x address domain and paged to `maxPagesPerKeyword`.
Each result block hands back the handle **and** the address published on that page, in one request; the handle is recovered from what Google prints — the site label, the breadcrumb host and path, or a `Name (@handle)` title.
This is where the volume and most of the addresses come from, which matters on Telegram, where a description is the only text a fetch can offer.

**Phase 2 — profile enrichment, on the RESIDENTIAL proxy.** Every target found is then fetched for its title, description and photo, merged into one row with the address from phase one.

Numbered, end to end:

1. Reads `keywords` and/or `profileUrls` and `usernames`, plus your limits and filters.
2. Runs the Google harvest above, collecting handles and the addresses printed beside them.
3. Normalises every target to a canonical `https://t.me/{username}` URL. A bare handle, an `@handle` and a full URL all resolve to the same target, and duplicates are dropped.
4. Fetches each public page through the Apify **residential proxy**, several targets in parallel, with a fresh exit IP on every retry.
5. Parses the HTML with a regex-first cascade: a regex battery matches the field key names directly, then the platform parser fills gaps, then Open Graph / link-preview meta tags fill what is left.
6. Merges and deduplicates addresses from both phases, scanning description, title and external URL with the hygiene rules above.
7. Pushes one row per target to the dataset immediately, then saves progress.

Results stream: each target goes to phase two the moment the Google search finds it, so the first rows are saved seconds into a run and keep arriving while the search continues. Each saved row is logged as it is written, naming the handle, address and counts found.

The first attempt sends a full Chrome header set — client hints, a referer, the sec-fetch family — and a retry falls back to a plain one; both are ordinary requests for a public page.

Matching key names rather than following an object path is deliberate: platforms move those objects between releases, but the key names survive, which is why this **Telegram profile scraper** keeps working across site updates.

Telegram Profile Contact Scraper runs are resumable, keyed to a hash of the input, so a migrated or restarted run continues instead of refetching, while changing the input starts a clean run.

Each page gets up to four attempts with backoff and a fresh exit IP, and a redirect to a login page is treated as rate limiting rather than a missing target.

### Keyword search in the Telegram Profile Contact Scraper

Keyword search in the Telegram Profile Contact Scraper is a real search for targets, not a filter over links you supplied.
Put `crypto` or `berlin tech jobs` into *Search keywords* and the Actor goes looking, with no target list of your own.

Because the query asks Google for pages that already publish an address, a keyword run in the Telegram Profile Contact Scraper returns targets with a contact address on the page rather than targets that merely match a word.
Because a `t.me` link can point at a channel, a group or a person, expect public channels as well as users — both come back as ordinary rows.

*Expand queries* is on by default and searches each keyword in several phrasings, pairing it with the *Query modifiers* — `email`, `contact`, `admin`, `business`, `partnership`.
*Email domains* does double duty: those domains are what the search asks Google for, and the filter on what is kept.

Every handle the Telegram Profile Contact Scraper finds becomes a canonical `https://t.me/{username}` URL and is fetched through the **RESIDENTIAL proxy**, exactly like a link you typed in.
Two proxies, one per job: Google is reachable only through the SERP group, Telegram needs residential exit IPs, and neither can do the other's work.

Add a *Location* to narrow a search, and raise *Pages per keyword* to dig deeper into each query.

### Input schema

These are the exact fields the Telegram Profile Contact Scraper ships with; nothing else is accepted.
Everything is optional, but a run needs either `keywords` or a target in `profileUrls` / `usernames`.

| Field | Type | Default | Meaning |
|---|---|---|---|
| `keywords` | array | prefilled with example terms | Search terms. The Telegram Profile Contact Scraper finds matching channels and accounts on Telegram and scrapes each one. |
| `location` | string | `""` | Added to every keyword search, e.g. `New York`. Keyword search only. |
| `maxPagesPerKeyword` | integer 1–30 | `5` | Google results pages read per query. Raise to find more accounts. Keyword search only. |
| `expandQueries` | boolean | `true` | Search each keyword in several phrasings (keyword + "email", + "contact", …). Keyword search only. |
| `queryModifiers` | array | `email`, `contact`, `admin`, `business`, `partnership` | Extra words combined with each keyword when expansion is on. |
| `profileUrls` | array | `[]` | Full profile URLs. Bare usernames also accepted. |
| `usernames` | array | `[]` | Handles without the URL. Combined with the list above. |
| `customDomains` | array | `[]` | Domains the keyword search asks Google for, and a filter on results. Empty searches the common free-mail providers and keeps every address found. |
| `onlyWithEmail` | boolean | `false` | Skip targets for which no public address was found. |
| `maxProfiles` | integer 1-100000 | `100` | Profiles to save for EACH keyword and EACH contact type: 20 with one keyword = 20 profiles with an email + 20 with a phone number. Profiles you give directly count as one more group. |
| `findEmails` | boolean | `true` | Collect email addresses. Turn off to collect only phone numbers. |
| `findPhones` | boolean | `true` | Collect phone numbers. Turn off to collect only emails. |
| `countries` | array | US, UK, India | Which countries' phone numbers to look for. Name, ISO code or dial code. |
| `maxConcurrency` | integer 1–30 | `10` | How many profiles are fetched in parallel, and how many Google searches run at once. Higher is faster; lower it if rows come back blocked. |
| `proxyGroup` | select | `RESIDENTIAL` | `RESIDENTIAL`, `BUYPROXIES94952` or `UNBLOCKER`. |
| `countryCode` | string | `""` | Two-letter proxy country (US, GB, DE…). Empty for any. |

There is no `dataSource` input on the Telegram Profile Contact Scraper; it exists only on the TikTok member of the family.

#### JSON input example

Starting from keywords, with no list of your own:

```json
{
  "keywords": ["founder", "crypto"],
  "location": "Berlin",
  "maxPagesPerKeyword": 5,
  "expandQueries": true,
  "onlyWithEmail": true,
  "maxProfiles": 500,
  "proxyGroup": "RESIDENTIAL"
}
```

Or both at once — your links are queued first, discovered channels and users after:

```json
{
  "keywords": ["indie dev"],
  "queryModifiers": ["email", "admin", "partnership"],
  "profileUrls": ["https://t.me/quantdailybrief"],
  "usernames": ["cryptoreadingroom", "berlin_techjobs"],
  "maxProfiles": 500
}
```

### Output schema

Every dataset row the Telegram Profile Contact Scraper writes carries all of these fields, including the ones Telegram leaves empty.

| Field | Meaning |
|---|---|
| `success` | True when the page was fetched and parsed, **or** an address was found for the target. A blocked fetch still yields a usable row when Google gave an address |
| `network` | Platform name |
| `dataSource` | Which path produced the row: `page`, `api` or `api+page` |
| `keyword` | The keyword that found this target, or `null` for a supplied link |
| `query` | The exact Google query that found it, or `null` |
| `description` | The result snippet Google showed, cleaned of labels and counters |
| `profileUrl` | The canonical profile URL that was requested |
| `url` | The URL actually returned, after redirects |
| `username` | Handle |
| `fullName` | Display/real name as published |
| `displayName` | Handle or title the platform shows |
| `email` | First public email found, or `null` |
| `emails` | Every public email found, deduplicated |
| `emailSource` | Where the addresses came from: `search` (the Google harvest, the common value on a keyword run), `bio` (the public page), `bio+search`, or `null` |
| `phone` | The first public phone number found, in E.164 form, or `null` |
| `phones` | Every public phone number found, deduplicated |
| `phoneNational` | The same number as its country writes it |
| `phoneCountry` | ISO country the number belongs to |
| `bio` | Public bio / description text |
| `followersCount` | Followers or subscribers, when published |
| `avatarUrl` | Profile picture URL |
| `error` | Why a row failed, or `null` |
| `scrapedAt` | ISO 8601 UTC timestamp |

On this platform the useful columns are `fullName` / `displayName` (the title), `bio` (the description), `avatarUrl` (the photo), `email`, `emails` and the three search columns.
`dataSource` is always `page`, and `secUid` is always empty.

#### JSON output example

```json
{
  "success": true,
  "network": "Telegram",
  "dataSource": "page",
  "keyword": "crypto",
  "query": "site:t.me crypto partnership \"@gmail.com\"",
  "description": "Quant Daily Brief - markets research every weekday morning. Ads and partnerships: quantdaily.partners@gmail.com",
  "profileUrl": "https://t.me/quantdailybrief",
  "url": "https://t.me/quantdailybrief",
  "username": "quantdailybrief",
  "fullName": "Quant Daily Brief",
  "displayName": "Quant Daily Brief",
  "email": "quantdaily.partners@gmail.com",
  "emails": ["quantdaily.partners@gmail.com"],
  "emailSource": "bio+search",
  "bio": "Markets research every weekday morning. Ads and partnerships: quantdaily.partners [at] gmail [dot] com",
  "followersCount": 42817,
  "avatarUrl": "https://cdn4.cdn-telegram.org/file/quantdailybrief-photo.jpg",
  "error": null,
  "scrapedAt": "2026-08-29T10:24:11Z"
}
```

`followersCount` carries the subscriber figure the public page prints. The remaining `null` counts are not an error: Telegram does not publish post, following or like numbers there.
Those columns stay in every Telegram Profile Contact Scraper row anyway, so the schema matches its sibling Actors and your CRM mapping never has to change.

### How to use the Telegram Profile Contact Scraper step by step

1. Open the Telegram Profile Contact Scraper on Apify and click **Try for free**.
2. Type search terms such as `founder` or `crypto` into **Search keywords** to start without a list. Add a **Location** to narrow the search, raise **Pages per keyword** to go deeper, and leave **Expand queries** on to try each **Query modifier**.
3. Or paste `t.me` links into **Telegram profile URLs** and text-only handles into **Usernames / handles**. Both lists are merged and de-duplicated, and both can sit alongside keywords.
4. Set **Max profiles** to the size of your batch. The default is `100`.
5. Turn on **Only save profiles that have an email** for a pure contact list rather than a full audit.
6. Optionally list **Email domains** — those are the domains the search asks Google for, and the filter on what is kept.
7. Leave **Apify proxy group** on `RESIDENTIAL`; public pages block datacenter IPs.
8. Lower **Max concurrency** from its default of `10` if you see blocks, or raise it towards `30` when a run is clean.
9. Click **Start**, then export the dataset as CSV, JSON or Excel, or pull it through the Apify API into your CRM.

A good first run is one keyword, or 10–20 handles, with `onlyWithEmail` off — that shows which columns Telegram fills before you commit a large batch.
You can also start the Telegram Profile Contact Scraper from the Apify API, the CLI or a schedule, and chain it into Google Sheets, Slack or a webhook.

### Use cases for the Telegram Profile Contact Scraper

**Channel advertising and sponsorships.** A keyword sent to the Telegram Profile Contact Scraper returns public channels that publish an ad contact, already attached to the title and description.

**Creator outreach at scale.** Agencies enrich handles collected from briefs and directories in a single run.

**Lead enrichment.** Feed existing CRM records through the Telegram Profile Contact Scraper to attach a public title, description, photo and business email.

**Community and partnership research.** Map the public channels around a niche, and use `query` and `description` as the audit trail for each contact.

**Recruitment channels.** Hiring channels usually publish a posting address — exactly what this **Telegram bio email extractor** collects.

**Data cleanup.** Re-run the Telegram Profile Contact Scraper periodically to refresh stale contact records before a campaign.

In most of these cases the subscriber count from the public page is the sizing signal you need; post-level activity has to come from somewhere else.

### Pricing and plan limits

Billing for the Telegram Profile Contact Scraper is pay-per-event: `actor-start` once per run and `profile-scraped` for each saved row.

On the **free Apify plan a run is capped at 100 profiles**; paid plans are uncapped, subject to your own `maxProfiles` value.

At the end of a run the log reports counts of ok / blocked / not found / errors.

### Limitations

**No post counts.** Telegram public pages expose a channel or user title, a description, a photo and the subscriber count, which lands in `followersCount`.
Post counts are not published, so `postsCount` is `null`, as are `followingCount` and `likesCount`, and flags like `isVerified` are usually `null` as well.

The Telegram Profile Contact Scraper reads **public data only**: no login, no cookies, no phone number, no bot token, no private or official API, no browser and no JavaScript rendering. Messages, members and anything inside a private group are out of reach — only the public preview page is fetched.

It cannot find an email published nowhere. If a channel keeps contact behind an inline button or a second bot, `email` comes back `null`.

Email yield does not depend on the description alone: on a keyword run the address comes back with the Google result, so a thin `t.me` page still produces a contact.

Coverage still depends on what channel owners publish, so no yield rate is promised. The search targets pages that carry an address, but a row comes back for every target found, some with profile data only.

Keyword search needs the GOOGLE_SERP proxy. A keywords-only run fails without it; if profile URLs are supplied too, the Telegram Profile Contact Scraper logs a warning and continues with those.

Pages can rate limit. Retries with fresh residential exit IPs help, but some rows still come back blocked, and the run reports them honestly.

Deleted, renamed or non-existent handles return `success: false` with a reason in `error`, unless an address was already found for them.

You are responsible for how you use the data, including compliance with privacy and anti-spam law in your jurisdiction.

### FAQ

#### Does it return follower counts?

Yes. Telegram public pages expose a channel or user title, description, photo and the subscriber count, and that subscriber figure is written to `followersCount`.
Post counts are not published, so `postsCount`, `followingCount` and `likesCount` come back `null`.

#### Does it need my Telegram account, a phone number or a bot token?

No. The Telegram Profile Contact Scraper never logs in, uses no official API, and reads only what a signed-out visitor can see: the public page is fetched over HTTP and the HTML parsed.

#### Can it find hidden or private email addresses?

No. Addresses reach the Telegram Profile Contact Scraper from the Google result in phase one and from the public description, title or external link in phase two.

#### How do the two phases fit together?

Phase one searches Google on the SERP proxy with an email dork, up to `maxPagesPerKeyword` pages per query, so each result returns a handle and the address published alongside it; phase two fetches that `t.me` page on residential IPs and merges the two into one row.
That is also why a row can be `success: true` with empty profile fields — the address was found even though the page fetch gave nothing.

#### Can I filter to business domains only?

Yes. Put the domains in `customDomains`: the search then asks Google for them, and every other address is discarded.

#### How many profiles can one run handle?

`maxProfiles` in the Telegram Profile Contact Scraper accepts 1 to 100000. The free Apify plan caps a run at 100 profiles; paid plans are uncapped, and an interrupted run resumes instead of refetching.

#### Do I need a proxy?

Yes. `RESIDENTIAL` is the default for the page fetch, because public pages block datacenter IPs; the Google harvest always runs on GOOGLE_SERP.

#### Do `t.me` links still work?

Yes, unchanged. Links, `@handles` and bare usernames all behave as before, and combine with keywords in one run; supplied targets are queued first, discovered ones after.

### Related Actors

The Telegram Profile Contact Scraper shares its engine with 29 siblings, one per platform. Use them together to enrich the same handle across several networks, adding the fields Telegram's public page does not print.

| Actor | What it collects |
|---|---|
| [Telegram Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/telegram-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Telegram |
| [Telegram Profile Phone Number Scraper](https://apify.com/leads-scraper/telegram-profile-phone-number-scraper) | Phone numbers plus bio and follower counts from Telegram profiles |
| [Behance Profile Email Scraper](https://apify.com/leads-scraper/behance-profile-email-scraper) | Emails plus bio and follower counts from Behance profiles |
| [Bluesky Profile Email Scraper](https://apify.com/leads-scraper/bluesky-profile-email-scraper) | Emails plus bio and follower counts from Bluesky profiles |
| [Buy Me a Coffee Profile Email Scraper](https://apify.com/neuro-scraper/buy-me-a-coffee-profile-email-scraper) | Emails plus bio and follower counts from Buy Me a Coffee profiles |
| [DEV Community Profile Email Scraper](https://apify.com/neuro-scraper/dev-to-profile-email-scraper) | Emails plus bio and follower counts from DEV Community profiles |
| [DeviantArt Profile Email Scraper](https://apify.com/leads-scraper/deviantart-profile-email-scraper) | Emails plus bio and follower counts from DeviantArt profiles |
| [Dribbble Profile Email Scraper](https://apify.com/leads-scraper/dribbble-profile-email-scraper) | Emails plus bio and follower counts from Dribbble profiles |
| [Facebook Profile Email Scraper](https://apify.com/leads-scraper/facebook-profile-email-scraper) | Emails plus bio and follower counts from Facebook profiles |
| [Flipboard Profile Email Scraper](https://apify.com/neuro-scraper/flipboard-profile-email-scraper) | Emails plus bio and follower counts from Flipboard profiles |
| [GitHub Profile Email Scraper](https://apify.com/leads-scraper/github-profile-email-scraper) | Emails plus bio and follower counts from GitHub profiles |
| [GitLab Profile Email Scraper](https://apify.com/neuro-scraper/gitlab-profile-email-scraper) | Emails plus bio and follower counts from GitLab profiles |
| [Gumroad Profile Email Scraper](https://apify.com/leads-scraper/gumroad-profile-email-scraper) | Emails plus bio and follower counts from Gumroad profiles |
| [Hashnode Profile Email Scraper](https://apify.com/neuro-scraper/hashnode-profile-email-scraper) | Emails plus bio and follower counts from Hashnode profiles |
| [Hugging Face Profile Email Scraper](https://apify.com/neuro-scraper/hugging-face-profile-email-scraper) | Emails plus bio and follower counts from Hugging Face profiles |
| [Instagram Profile Email Scraper](https://apify.com/leads-scraper/instagram-profile-email-scraper) | Emails plus bio and follower counts from Instagram profiles |
| [Kick Profile Email Scraper](https://apify.com/leads-scraper/kick-profile-email-scraper) | Emails plus bio and follower counts from Kick profiles |
| [Linktree Profile Email Scraper](https://apify.com/leads-scraper/linktree-profile-email-scraper) | Emails plus bio and follower counts from Linktree profiles |
| [Mastodon Profile Email Scraper](https://apify.com/leads-scraper/mastodon-profile-email-scraper) | Emails plus bio and follower counts from Mastodon profiles |
| [Mixcloud Profile Email Scraper](https://apify.com/leads-scraper/mixcloud-profile-email-scraper) | Emails plus bio and follower counts from Mixcloud profiles |
| [Patreon Profile Email Scraper](https://apify.com/leads-scraper/patreon-profile-email-scraper) | Emails plus bio and follower counts from Patreon profiles |
| [Pinterest Profile Email Scraper](https://apify.com/leads-scraper/pinterest-profile-email-scraper) | Emails plus bio and follower counts from Pinterest profiles |
| [Snapchat Profile Email Scraper](https://apify.com/leads-scraper/snapchat-profile-email-scraper) | Emails plus bio and follower counts from Snapchat profiles |
| [SoundCloud Profile Email Scraper](https://apify.com/leads-scraper/soundcloud-profile-email-scraper) | Emails plus bio and follower counts from SoundCloud profiles |
| [Substack Profile Email Scraper](https://apify.com/leads-scraper/substack-profile-email-scraper) | Emails plus bio and follower counts from Substack profiles |
| [Threads Profile Email Scraper](https://apify.com/leads-scraper/threads-profile-email-scraper) | Emails plus bio and follower counts from Threads profiles |
| [TikTok Profile Email Scraper](https://apify.com/leads-scraper/tiktok-profile-email-scraper) | Emails plus bio and follower counts from TikTok profiles |
| [Tumblr Profile Email Scraper](https://apify.com/leads-scraper/tumblr-profile-email-scraper) | Emails plus bio and follower counts from Tumblr profiles |
| [Twitch Profile Email Scraper](https://apify.com/leads-scraper/twitch-profile-email-scraper) | Emails plus bio and follower counts from Twitch profiles |
| [X Profile Email Scraper](https://apify.com/leads-scraper/x-profile-email-scraper) | Emails plus bio and follower counts from X profiles |
| [YouTube Profile Email Scraper](https://apify.com/leads-scraper/youtube-profile-email-scraper) | Emails plus bio and follower counts from YouTube profiles |
| [Behance Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/behance-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Behance |
| [Bluesky Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/bluesky-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Bluesky |
| [Buy Me a Coffee Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/buy-me-a-coffee-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Buy Me a Coffee |
| [DEV Community Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/dev-to-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from DEV Community |
| [DeviantArt Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/deviantart-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from DeviantArt |
| [Dribbble Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/dribbble-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Dribbble |
| [Facebook Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/facebook-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Facebook |
| [Flipboard Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/flipboard-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Flipboard |
| [GitHub Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/github-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from GitHub |
| [GitLab Profile Email and Phone Number Scraper](https://apify.com/neuro-scraper/gitlab-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from GitLab |
| [Gumroad Profile Email and Phone Number Scraper](https://apify.com/leads-scraper/gumroad-profile-email-and-phone-number-scraper) | Emails, phone numbers and profile details from Gumroad |

### Leave a review

If the Telegram Profile Contact Scraper saved you time, please leave a star rating and a short
review on the Actor page.

Reviews are how other buyers judge whether a tool works, and they tell us which features to
build next.

If something did not work, email <neurodata.apify@gmail.com>
instead - bugs get fixed faster than they get complained about.

### Support

Questions about the Telegram Profile Contact Scraper, a bug, or a custom build? Write to **<neurodata.apify@gmail.com>**.

Include your run ID and a sample of the input when you report a parsing problem — it makes a fix much faster.

Feature requests are welcome, including extra output fields and bulk-input formats.

### How the Telegram Profile Contact Scraper counts your profiles

The Telegram Profile Contact Scraper counts profiles **per keyword and per contact type**. Set **Max profiles per keyword** to 20 and run one keyword: you get up to 20 profiles with an email and 20 profiles with a phone number, 40 in total.

Add a second keyword and the Telegram Profile Contact Scraper gives each keyword its own 20 and 20. One keyword can never use up the share of another.

Profile URLs and usernames you give directly count as one more group of their own, with the same maximum.

#### Only emails or only phone numbers with the Telegram Profile Contact Scraper

The Telegram Profile Contact Scraper has two switches, **Find emails** and **Find phone numbers**. Both are on by default.

Turn off **Find phone numbers** and the Telegram Profile Contact Scraper collects emails only. Turn off **Find emails** and it collects phone numbers only. The columns of every row stay the same either way, so a saved export or sheet keeps working.

#### Why choose the Telegram Profile Contact Scraper

- The Telegram Profile Contact Scraper returns the public email and the public phone number of a Telegram profile in one run.
- The Telegram Profile Contact Scraper saves only profiles that carry a contact you asked for, so every row has an email or a phone number.
- The Telegram Profile Contact Scraper also returns the bio, follower counts and the profile link of each account.
- The Telegram Profile Contact Scraper never logs in and reads public Telegram profiles only.
- The Telegram Profile Contact Scraper removes duplicates, so the same profile is never delivered twice.
- The Telegram Profile Contact Scraper is billed per profile, and you pay only for the rows you ask for.
- The Telegram Profile Contact Scraper lets you cap the cost of a run with the maximum cost setting.
- Every row of the Telegram Profile Contact Scraper names the keyword that found it.

# Actor input Schema

## `keywords` (type: `array`):

Search terms - a niche, job title or industry. The Actor finds Telegram accounts matching each term, then scrapes every account it finds. Use this when you do not already have a list of accounts. You can combine keywords with the profile URLs below.

## `location` (type: `string`):

Added to every keyword search, e.g. `New York`. Leave empty to search everywhere. Only applies to keyword search.

## `profileUrls` (type: `array`):

Full Telegram profile URLs, e.g. `https://t.me/username`. Bare usernames also work. Use this when you already know which accounts you want.

## `usernames` (type: `array`):

Telegram handles without the URL. Combined with the list above.

## `customDomains` (type: `array`):

Domains the keyword search asks Google for, e.g. `@gmail.com`. Also filters results to these domains. Leave EMPTY (recommended) to search the 12 biggest free-mail providers - Gmail, Yahoo, Outlook, Hotmail, iCloud, AOL, Proton, Live, GMX, Mail.com, Yandex and Zoho - and keep every address found, including company domains. Listing domains here narrows the search to only those.

## `onlyWithEmail` (type: `boolean`):

Skip profiles whose public bio contains no contact address.

## `maxProfiles` (type: `integer`):

Profiles to save for EACH keyword and EACH contact type: 20 with one keyword saves up to 20 profiles with an email and 20 with a phone number; switch one type off and it is 20 in total. Profiles you give directly (URLs or usernames) count as one more group of their own.

## `findEmails` (type: `boolean`):

Collect email addresses. Turn off to collect only phone numbers.

## `findPhones` (type: `boolean`):

Collect phone numbers. Turn off to collect only emails.

## `countries` (type: `array`):

Which countries' phone numbers to look for. The search asks Google for that country's dial code, and every number found is validated against that country's real numbering plan. Country name, ISO code or dial code all work. Each extra country multiplies the number of searches.

## `maxPagesPerKeyword` (type: `integer`):

How many Google results pages to read per search query. Raise it to find more accounts. Keyword search only.

## `expandQueries` (type: `boolean`):

Search each keyword in several phrasings (keyword + "email", + "contact", ...) to reach accounts a single query misses. Keyword search only.

## `queryModifiers` (type: `array`):

Extra words combined with each keyword when query expansion is on. Leave empty to use the defaults for this platform.

## `maxConcurrency` (type: `integer`):

How many profiles are fetched in parallel, and how many Google searches run at once. Raise it for speed, lower it if you see blocked rows.

## `proxyGroup` (type: `string`):

RESIDENTIAL is recommended. Profile pages block datacenter IPs.

## `countryCode` (type: `string`):

Two-letter country code for the proxy (e.g. US, GB, DE). Empty for any.

## Actor input object example

```json
{
  "keywords": [
    "founder",
    "crypto"
  ],
  "location": "",
  "profileUrls": [],
  "usernames": [],
  "customDomains": [],
  "onlyWithEmail": false,
  "maxProfiles": 100,
  "findEmails": true,
  "findPhones": true,
  "countries": [
    "United States",
    "United Kingdom",
    "India"
  ],
  "maxPagesPerKeyword": 5,
  "expandQueries": true,
  "queryModifiers": [
    "email",
    "contact",
    "admin",
    "business",
    "partnership"
  ],
  "maxConcurrency": 10,
  "proxyGroup": "RESIDENTIAL",
  "countryCode": ""
}
```

# Actor output Schema

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

Records produced by Telegram Profile Contact Scraper, stored in the run's default dataset.

# 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 = {
    "keywords": [
        "founder",
        "crypto"
    ],
    "location": "",
    "countries": [
        "United States",
        "United Kingdom",
        "India"
    ],
    "countryCode": ""
};

// Run the Actor and wait for it to finish
const run = await client.actor("leads-scraper/telegram-profile-contact-scraper").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 = {
    "keywords": [
        "founder",
        "crypto",
    ],
    "location": "",
    "countries": [
        "United States",
        "United Kingdom",
        "India",
    ],
    "countryCode": "",
}

# Run the Actor and wait for it to finish
run = client.actor("leads-scraper/telegram-profile-contact-scraper").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 '{
  "keywords": [
    "founder",
    "crypto"
  ],
  "location": "",
  "countries": [
    "United States",
    "United Kingdom",
    "India"
  ],
  "countryCode": ""
}' |
apify call leads-scraper/telegram-profile-contact-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,leads-scraper/telegram-profile-contact-scraper"
        }
    }
}
```

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/7rTPdR9ybkYKuCLAc/builds/Sf3Cg37iMkpaHha5T/openapi.json
