Telegram Group Member

A Telegram group members export that returns 23 structured fields per account, drawn from the group's visible participant list and from the people who post in its message history — built for teams that need the member data in a table, not on a screen.

• 23 fields per member: numeric ID, every active username, names, phone when the account publishes it, last-seen state, and Telegram's premium, verified, scam, fake, restricted, and deleted flags.
• Two discovery passes in one run, and every row records which one produced it, alongside the group's ID, handle, and title.
• Accounts are deduplicated by Telegram user ID inside a run, so a person found in both passes is written once.
• Rows are written as they are found, so a run that reaches its timeout still keeps everything collected up to that point.

Run a one-result test · View API

The smallest useful run asks for one member from one public group: one Actor start plus one result event, $0.01055 at FREE-tier prices before variable usage. Billing is per member row written to the dataset, so a run that returns less than you asked for costs less.

What does Telegram Group Member do?

It resolves one public, username-addressable Telegram group and returns one dataset row per unique member account it can reach, up to the number of rows you request.

Two passes feed the export. The first reads the group's participant list. Telegram marks that list hidden on most modern supergroups and answers with only a fraction of it — in our measurements, 22 accounts from a 5,396-member group and 38 from one with 26,305. The second pass reads the group's message history and treats every distinct author as a member. On a hidden-list group, that second pass is what produces a usable number of rows, and the found_in field on every row tells you which pass it came from.

The result is a stable table: the same 23 columns every run, deduplicated by numeric ID, stamped with the group and the processing time.

It is not a private-group access tool. It does not join groups, does not accept invite links, and does not reconstruct a hidden roster in full. A message author is not proof of current membership — the account may have left. A member who has never posted and is not in the visible participant list is not reachable through any public surface, by this Actor or any other.

How do I run Telegram Group Member?

1. Set telegram_url to a public group. Python, @Python, and https://t.me/Python all resolve to the same target.
2. Set max_results to the number of member rows you want. Start with one.
3. Decide on deep_search. Off keeps the run to the visible participant list; on adds message authors, which is where most members come from on a hidden-list group.
4. Start the run and open the default dataset.

The smallest useful input, reused in every example on this page:

{
  "deep_search": false,
  "max_results": 1,
  "telegram_url": "https://t.me/Python"
}

The limit applies per run, and it counts rows written to the default dataset — which is also the unit you are billed on. It is a ceiling and not a target: it can stop a run early, but it cannot make Telegram expose more accounts than it exposes.

What data does Telegram Group Member return?

Group	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 one Telegram account can hold several active handles; username and source_url use the canonical one, and source_url is null for an account with no public handle at all. phone is populated only when the member has set phone visibility to everybody — measured on 85 of 3,274 members across five groups — so null is the normal case, not an error. last_seen is either an ISO timestamp or one of online, recently, last_week, last_month, offline, and is null when Telegram reports no status. Values the source does not supply stay null rather than being filled with a placeholder.

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": "Python",
  "found_in": "participants",
  "processed_at": "2026-08-04T00:46:44+00:00"
}

What inputs can I configure?

deep_search — required, boolean. When true, the run also reads the group's message history and adds each distinct author it finds. When false, the run stops after the participant list, which on most groups means only a few dozen rows are available.

telegram_url — required, string. Accepts a bare username, @username, t.me/username, telegram.me/username, the www variants of those hosts, and public /s/username preview paths. Invite, joinchat, and plus-style links are rejected, as is a broadcast channel: a channel has subscribers rather than members, and Telegram exposes neither list.

max_results — required, integer, minimum 1. The run ends as soon as that many rows have been written. Free-plan runs return at most 10 rows whatever value you submit; the run reports when that cap is what reduced your request.

There are no other inputs. There is no date range, no country or language filter, and no credential field — the Actor supplies its own Telegram access.

What platforms and markets does Telegram Group Member cover?

Coverage is Telegram groups and supergroups addressable by a public username, worldwide. There is no per-country or per-language restriction — and no such filter either: what you get is the group you asked for.

Not covered: private and invite-only groups, broadcast channels, direct messages, and other platforms. Language and region follow the group itself, so treat each export as a sample of one community rather than of a market.

Message-author discovery walks available history from newest to oldest without a user-selected date bound, so the accounts it finds skew toward recent activity in an active group and toward whoever ever posted in a quiet one.

Why use Telegram Group Member?

Capability	What it gives a data team
Fixed 23-field contract	Schema you can validate once and load repeatedly without per-run mapping
Two discovery passes with found_in	Ability to separate "on the visible list" from "actually posts" in the same table
Group fields on every row	Multi-group exports that stay separable without external bookkeeping
In-run deduplication by numeric ID	No duplicate members across the two passes
Incremental writes	A timed-out run still yields the rows it already collected
Per-result billing	Cost that tracks rows delivered rather than time spent

The trade-off is honest and worth stating: this Actor cannot give you a complete member list, because Telegram does not publish one. It gives you a reproducible, well-typed sample with its provenance attached, and it tells you which pass found each row so you can judge the sample yourself.

Who is Telegram Group Member for?

Data engineers who need a stable table: one schema, predictable nulls, per-row provenance, and a run record they can reconcile against a warehouse load.

Community and growth analysts measuring the composition of a topic group — the ratio of users to bots, how many accounts carry Telegram Premium, how recently members were seen.

Trust and safety reviewers using Telegram's own is_scam, is_fake, is_restricted, and is_deleted flags as inputs to a documented assessment rather than as conclusions.

Researchers comparing the visible participant list against the set of people who actually post, using found_in to keep the two populations apart.

It is not for anyone who needs a guaranteed complete roster, private-group access, or contact data beyond what Telegram itself publishes — and it must not be used for unsolicited outreach, harassment, or covert profiling.

How can I use Telegram Group Member through the API or MCP?

The Actor ID is truefetch/telegram-group-member. The synchronous call below runs the same one-result scenario; keep the token in a secret store rather than in source.

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

Generated client examples for JavaScript, Python, and the OpenAPI definition are on the API page. For an MCP client, follow the Apify MCP documentation:

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

Then call the Actor with the same input:

{
  "actor": "truefetch/telegram-group-member",
  "input": {
    "deep_search": false,
    "max_results": 1,
    "telegram_url": "https://t.me/Python"
  }
}

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 failure — on a hidden-list group that is the expected outcome.

How much does Telegram Group Member cost?

Three billed events: the run starts, resources are consumed, 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
Actor usage	$0.00001	$0.00001	$0.00001	$0.00001	$0.00001	$0.00001
Result (one member)	$0.00055	$0.00050	$0.00044	$0.00041	$0.00041	$0.00041

The smallest useful test, at FREE-tier prices: one start plus one member row is $0.01000 + $0.00055 = $0.01055, before variable actor_usage, which depends on runtime and storage. Result charges follow the rows actually written, so a group that exposes 40 members bills 40 results even if you asked for more. Live prices are always on the Actor page and can change.

How does Telegram Group Member compare with alternatives?

Against manual review: opening profiles by hand is fine for a handful of accounts and produces nothing you can reload — no schema, no timestamps, no row count, no run ID. This Actor is the better choice the moment the same export has to happen twice.

Against a generic web scraper pointed at a t.me preview page: the preview renders a slice of recent messages and no participant data, so a generic crawler cannot produce member identity fields at all.

Against building on Telegram's own client API: that path gives maximum control and requires you to own accounts, sessions, rate limits, and rotation. Choose it when Telegram data is your core system; choose this Actor when you want the table without the plumbing.

Against any tool claiming a complete member list: that claim exceeds what the platform exposes. Compare tools on their field contract, their handling of the hidden-list case, and whether they say where each row came from.

What are the limits and troubleshooting steps?

Fewer rows than requested. Expected, and usually the hidden participant list. Turn deep_search on and re-run; judge the result against what the group exposes rather than against its advertised member count.

"is a channel, not a group". Broadcast channels publish no member list. Use the discussion group attached to the channel.

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

A slow deep 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. There is no date filter on the scan; lower max_results instead.

Widespread nulls in phone or last_seen. Those are the member's own privacy settings surfacing correctly.

The smallest reproducible case for a bug report is the one-result input above. Include the run ID, input, dataset ID, requested count, and actual count.

Frequently asked questions

Get list of Telegram group members: how does it work?

Give this Actor a public group username and a row count: it returns one 23-field row per member it can reach, from the visible participant list and, with deep_search on, from the authors in the group's message history.

Is there a Telegram group members API?

Yes — this Actor exposes one. Call truefetch/telegram-group-member over Apify's REST API or MCP with the three inputs shown above, and read the results from the default dataset.

Does deep search reveal hidden members?

No. It finds accounts that posted in reachable history. A member who has never posted and is not on the visible list cannot be discovered by any public method.

Why is phone null on almost every row?

Telegram only publishes a phone number when the account sets its visibility to everybody. Null means "not published", not "not extracted".

Is a message author still in the group?

Not necessarily. found_in: "messages" means the account posted in reachable history; treat it as an activity signal rather than a membership guarantee.

Are message authors billed the same as participants?

Yes. Every row written to the default dataset is one result event, whichever pass produced it.

Can I export the results to CSV?

Yes. Every row is flat, so the 23 fields map to 23 columns in Apify's CSV, JSON, or Excel export with no post-processing.

Related TrueFetch Actors

• Telegram Channel Message — when the unit you need is the post rather than the person, including timestamps and engagement.
• Telegram Profile — resolve a list of mixed usernames or IDs into user, bot, channel, and group profiles.
• Reddit User Profile — the same profile-level treatment for Reddit accounts when your research spans both platforms.

Support

Questions, bugs, and requests: the TrueFetch community group, or the Issues tab on the Actor page. Include the run ID and the exact input; never share tokens, sessions, or member data in a public thread.

Collect only what you are authorized to collect, and follow Telegram's terms and applicable privacy law when you store or process the results.

Run a one-result test · View API