Telegram Member Scraper

Telegram Member Scraper exports the members of a public Telegram group as structured 23-field profiles — from the group's visible participant list and, because Telegram hides that list on most groups, from the people who actually post in it.

• Two discovery passes in one run: the group's participant list, plus the authors of its message history.
• 23 fields per member, including numeric ID, every active username, names, phone when the member makes it public, last-seen state, and Telegram's premium, verified, scam, fake, restricted, and deleted flags.
• Every row names the group it came from and which pass found it, so multi-group exports stay traceable.
• Ask for as few as 1 member. Rows are written as they are found, so a run that hits its timeout keeps everything already returned.

Run a small test · View API

The smallest useful run asks for one member from one public group: one apify-actor-start event plus one result event, which is $0.01080 at FREE-tier prices. Billing is per member row written to the dataset.

What does Telegram Member Scraper do?

It takes one public, username-addressable Telegram group and returns one dataset row per unique member account it can reach, up to the number you ask for.

Two passes feed that dataset. The first reads the group's participant list. On most modern supergroups Telegram marks that list hidden and answers with only a fraction of it — in our measurements, 22 people out of a 5,396-member group and 38 out of 26,305. The second pass reads who posted in the group's message history and treats each distinct author as a member. That second pass is what produces useful numbers on a hidden-list group, and the found_in field on every row tells you which pass produced it.

Accounts are deduplicated by numeric Telegram ID within a run, so a person who appears in both passes is written once.

What it is not: it does not join, log into, or bypass a private group, and it does not reconstruct a hidden roster in full. A message author may have left long ago, and a member who has never posted and is not in the visible list cannot be discovered by any public means.

How do I use Telegram Member Scraper?

1. Paste a public group as telegram_url — DatascienceChats, @DatascienceChats, or https://t.me/DatascienceChats all resolve to the same target.
2. Leave Deep Search on. With it off you get only the handful of members the group still exposes publicly.
3. Set Max Results to the number of member rows you want. Start small.
4. Press Start, then open the default dataset.

The smallest useful input, reused in the API and MCP examples below:

{
  "deep_search": true,
  "max_results": 1,
  "telegram_url": "https://t.me/DatascienceChats"
}

max_results is a ceiling, not a promise. It stops the run early; it cannot make Telegram expose more people than it exposes. Compare the row count you got against the count you asked for before scaling a request up.

Input

Three inputs, all required.

Input	Type	Effect
telegram_url	string	The target group. Accepts a bare username, @username, t.me/username, telegram.me/username, the www hosts, and public /s/username preview paths. Invite, joinchat, and plus-style links are rejected, as is a broadcast channel — a channel has subscribers, not members, and Telegram exposes neither.
deep_search	boolean	When on, the run also reads the group's message history and adds each distinct author. When off, it stops after the participant list.
max_results	integer	How many member rows to return, minimum 1. The run ends as soon as it has that many. Free-plan runs return at most 10 rows regardless of the value you submit.

Output

One row per unique member, 23 fields:

• Identity: id, username, usernames, source_url, first_name, last_name, type.
• Contact and activity: phone, last_seen.
• Telegram flags: is_premium, is_verified, is_deleted, is_scam, is_fake, is_restricted, stories_hidden, premium_contact.
• Source group: group_id, group_username, group_title, found_in.
• Provenance: processed_at, processor.

usernames is an array because Telegram lets one account hold several active handles; username and source_url use the canonical one. phone is filled only when the member has set phone visibility to everybody — measured on 85 of 3,274 members across five groups, so expect it to be null most of the time. last_seen is either an ISO timestamp or one of online, recently, last_week, last_month, offline, and is null when Telegram reports nothing at all. An abbreviated, illustrative row from the scenario above:

{
  "id": 1036017898,
  "username": "raveblonde",
  "usernames": ["raveblonde"],
  "source_url": "https://t.me/raveblonde",
  "first_name": "Alexey",
  "type": "user",
  "phone": null,
  "last_seen": "recently",
  "is_premium": true,
  "group_username": "DatascienceChats",
  "found_in": "messages",
  "processed_at": "2026-08-04T00:46:44+00:00"
}

Use cases

Community research. Take a bounded, reproducible sample of a topic group, then summarize the mix of users and bots, premium accounts, and last-seen states — reporting what you asked for next to what you got.

Multi-group comparison. Run the same request against several groups and use group_id, group_username, and group_title to keep the exports separable in one table. Never merge rows across groups on display name alone.

Active-participant lists. Filter on found_in: "messages" to keep only people who actually posted — a stronger activity signal than a membership record.

Moderation triage. Use Telegram's own is_scam, is_fake, is_restricted, and is_deleted flags as source signals inside a documented review, not as verdicts.

Choose something else if you need a complete member census, private-group access, or contact details beyond what Telegram publishes.

API and integrations

The synchronous call below runs the same one-member scenario. Keep the token in a secret store.

curl -X POST "https://api.apify.com/v2/acts/PSRx5Q0FWQwgLpfuL/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"deep_search":true,"max_results":1,"telegram_url":"https://t.me/DatascienceChats"}'

For an MCP client, follow the Apify MCP documentation:

{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com/?token=YOUR_TOKEN"
    }
  }
}

Then call the same Actor and input:

{
  "actor": "agentx/telegram-member-scraper",
  "input": {
    "deep_search": true,
    "max_results": 1,
    "telegram_url": "https://t.me/DatascienceChats"
  }
}

For a large export, start the run asynchronously, poll it, and read the dataset separately. Set a maximum total charge, and do not configure a retry that treats "fewer rows than requested" as a failed run — on a hidden-list group that is the normal result.

Pricing

Two billed events: the run starts, and each member row is written.

Billed event	FREE	BRONZE	SILVER	GOLD	PLATINUM	DIAMOND
Actor start	$0.01000	$0.01000	$0.01000	$0.01000	$0.01000	$0.01000
Result (one member)	$0.00080	$0.00072	$0.00064	$0.00060	$0.00060	$0.00060

Smallest useful run, at FREE-tier prices: one start plus one member row is $0.01000 + $0.00080 = $0.01080. A run that returns fewer members than requested is charged for the rows it actually wrote. Current prices are always shown on the Actor page.

Alternatives

Reading a group by hand works for a few dozen visible profiles and gives you nothing repeatable: no schema, no timestamps, no row count, no run record. A generic page scraper pointed at a t.me preview page sees only what the web preview renders — a slice of recent messages, and no participant data at all.

Tools that promise a complete member list for any group are promising something Telegram does not expose. The honest ceiling is everyone in the visible participant list plus everyone who has posted in reachable history. Certified current membership needs access inside the group itself, which is a different workflow rather than a better scraper.

Limits and troubleshooting

Far fewer rows than requested. Expected on a hidden-list group. Confirm Deep Search is on, then judge the result against what the group exposes rather than against its member count.

"is a channel, not a group". Broadcast channels have no member list. Use the discussion group linked to the channel instead.

The group could not be read. Check the link is a public username form and resolves without an invite. Private, joinchat, and plus-style links are rejected by design.

A long Deep Search run. History reading yields roughly 5 to 10 new members per second depending on how many distinct people post, so a quiet group is slow per useful row. Lower max_results or accept a longer run; the history scan has no date filter.

Nulls in phone or last_seen. Those are privacy settings on the member's account, not extraction errors.

When reporting a problem, keep the run ID, input, dataset ID, requested count, and actual count.

Frequently asked questions

How do I scrape Telegram group members?

Give this Actor a public group username and a member count, leave Deep Search on, and it returns one 23-field row per member it can reach — from the participant list and from the group's message history.

How do I export Telegram members to CSV?

Run the Actor, open the default dataset, and use Apify's CSV export; every row is flat, so the 23 fields map to 23 columns with no post-processing.

Does Deep Search reveal hidden members?

No. It finds people who posted in the group. A member who has never posted and is not in the visible participant list cannot be found by any public method.

Why does a free-plan run stop at 10 rows?

The free plan is capped at 10 member rows per run in the Actor itself. The run tells you when that cap was what reduced your request.

Is a message author still a member of the group?

Not necessarily. found_in: "messages" means the account posted in reachable history; it may have left since. Treat it as an activity signal, not a membership guarantee.

Can I scrape a private group with an invite link?

No. Invite, joinchat, and plus-style links are rejected. This Actor only reads public, username-addressable groups.

Related AgentX Actors

• Telegram Chat Scraper — when the unit you want is the message, not the person.
• Telegram Info Scraper — resolve a list of usernames or IDs into user, bot, channel, and group profiles.
• Telegram Private Group Scraper — a different access workflow with its own authorization requirements.

Enrich your data with AgentX

• All Jobs Scraper — match the names you collected against job listings across boards.
• All Shopping Scraper — add product and price context when a group is commerce-oriented.
• All Video Scraper — pull video sources referenced by a community into the same pipeline.

Support

Questions, bug reports, and feature requests: the AgentX community, or the Issues tab on the Actor page. Include the run ID and input; never share Telegram sessions or API tokens.

Collect only what you are authorized to collect, follow Telegram's terms and applicable privacy law, and do not use this Actor for harassment, spam, surveillance, or unsolicited outreach.

Run a small test · View API