Telegram Members Scraper

Extract active members visible on the public Telegram web from group and channel URLs — username, display name, profile URL, discovery source, activity signals, and source-group context. No Telegram login, cookies, or Bot API key. Built for community research, lead lists from public chats, and AI agents that start with a t.me link.

This Actor reads Telegram's public preview pages (t.me/<username> and t.me/s/<username>). It collects people who appear as message authors, forwarded-from accounts, or @mentions, then returns one flat row per distinct account. Prefer chats that open a public message preview in a browser. For channel message history (text, views, reactions), continue with Telegram Channel Scraper after you already know the username. When you only have a topic keyword first, discover public chats with Telegram Keyword Search Scraper, then pass matching t.me URLs here.

Best fit for this Actor

• You have a public @username or https://t.me/... group/channel and want a bounded list of active people visible on the public web.
• You need flat rows with username, profileUrl, discoverySource, and sourceGroupMemberCount for enrichment or outreach.
• Best yield comes from public channels (and groups) whose /s/ message preview is open in a normal browser.

Community research workflow: from a public channel to active members

A research desk pastes https://t.me/durov with maxMembers set to 50. The Actor walks the public /s/ preview pages, dedupes authors, forwards, and mentions, and returns rows ranked by messagesSeen. They keep accounts with usernames, export CSV, and optionally re-run with enrichProfiles: true for bios. When a chat has a public profile but no public message preview, the Actor finishes as VALID_EMPTY with zero billed rows and records the public member/subscriber count in RUN_SUMMARY.perGroup so the batch stays interpretable.

Quick start input

{
  "groupUrls": ["https://t.me/durov"],
  "maxMembers": 5,
  "includeMentions": true,
  "enrichProfiles": false
}

maxMembers is a hard cap per group after dedupe, so an agent can bound spend before calling.

Input reference

Field	Type	What it controls
groupUrls	array (required)	Public usernames, @handles, or t.me links. Up to 20. Invite/joinchat/+ links are rejected with INVALID_INPUT.
maxMembers	integer	Billed rows per group. Default 50, prefill 5, max 500.
enrichProfiles	boolean	Fetch each username's public t.me bio/photo. Default false.
includeMentions	boolean	Also collect @mentions from preview text. Default true.
includeBots	boolean	Keep bot-looking accounts. Default false.
proxyConfiguration	object	Optional proxy override. Default path uses Apify Residential.

What data you receive

Each dataset item is one discovered member. Empty/invalid chats leave the dataset empty; use OUTPUT.outcome and RUN_SUMMARY.perGroup for reasons.

Field	Description
username, displayName, profileUrl	Public identity
bio, photoUrl, isVerified, isBot	Profile enrich fields (when enabled / inferred)
discoverySource	message_author, forwarded_from, or mention
messagesSeen, lastActiveAt, lastMessageId	Activity signals from the preview scan
sourceGroupUsername, sourceGroupTitle, sourceGroupUrl, sourceGroupType, sourceGroupMemberCount	Provenance
matchFound, outcome, clearReason	Billing / honesty contract

{
  "username": "example_user",
  "displayName": "Example User",
  "profileUrl": "https://t.me/example_user",
  "bio": null,
  "photoUrl": null,
  "isVerified": false,
  "isBot": false,
  "discoverySource": "mention",
  "messagesSeen": 1,
  "lastActiveAt": "ISO-8601 timestamp",
  "lastMessageId": "123",
  "sourceGroupUsername": "durov",
  "sourceGroupTitle": "Durov's Channel",
  "sourceGroupUrl": "https://t.me/durov",
  "sourceGroupType": "channel",
  "sourceGroupMemberCount": null,
  "scrapedAt": "ISO-8601 timestamp",
  "matchFound": true,
  "outcome": "FOUND",
  "clearReason": null
}

You can download the dataset as JSON, CSV, Excel, or HTML from the run's Output tab.

Public-data contract

• Active/visible members. Authors, forwards, and mentions from the public /s/ preview — the identities Telegram shows without login.
• Preview availability varies. Many groups keep /s/ closed; those chats finish VALID_EMPTY with the public member count when the profile card provides it.
• Channels often attribute posts to the channel itself; forwards and mentions are usually the richest public signal.
• Invite links finish as INVALID_INPUT with zero member-found charges.
• Unknown usernames finish VALID_EMPTY.

Why agents choose this Actor

• Bounded cost: $0.005 per saved member plus a $0.00005 start event, with maxMembers as the ceiling.
• One schema for authors, forwards, and mentions, with discoverySource provenance.
• Multi-chat batches can return PARTIAL when some chats hide previews while others yield members.
• Terminal OUTPUT.outcome values (COMPLETE, PARTIAL, VALID_EMPTY, INVALID_INPUT, UPSTREAM_FAILED) are stable enough to branch on.
• After discovery, pass known channel usernames to Telegram Channel Scraper for post history.

Agent checklist

1. Pass public t.me URLs or @handles. Invite/+ links belong outside this Actor.
2. Set maxMembers to the budget you can spend at $0.005 per member.
3. After the run, read OUTPUT.outcome, then the dataset. Preserve profileUrl and sourceGroupUrl.
4. Treat VALID_EMPTY as a truthful no-visible-identity result.
5. Prefer chats that show a working /s/ preview in a browser for denser member yield.

Use through the API

curl "https://api.apify.com/v2/acts/khadinakbar~telegram-members-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "groupUrls": ["https://t.me/durov"],
    "maxMembers": 5,
    "includeMentions": true,
    "enrichProfiles": false
  }'

When the Actor completes, read dataset items from the default dataset and the OUTPUT record from the default key-value store.

Use with AI agents through Apify MCP

Use khadinakbar/telegram-members-scraper with groupUrls=["https://t.me/durov"] and maxMembers=20. Return usernames, profile URLs, discoverySource, and sourceGroupMemberCount. Then inspect OUTPUT.outcome and keep t.me links as provenance.

Connect through https://mcp.apify.com. After the tool call, read the dataset and the OUTPUT / RUN_SUMMARY records. Preserve source URLs.

Pricing

This Actor uses Pay per event plus Apify platform usage. Open the live Pricing tab for current event details, and use Apify's run cost controls to keep the workflow aligned with your budget.

Worked examples at the launch prices (apify-actor-start $0.00005, member-found $0.005):

Input	Rows billed	Event cost
One channel, 5 members	5	~$0.025
One group with no public preview	0	start event only
Two channels, 10 members each	20	~$0.100
Invite / invalid input	0	start event only

Formula: member-found count × $0.005 + start event + platform usage. Platform usage is billed to the user on top of events.

Outcome vocabulary

These values live in the key-value store records OUTPUT and RUN_SUMMARY.

Outcome	Meaning
COMPLETE	Groups were processed and billed members were saved.
PARTIAL	Some groups were incomplete or the event limit was hit; saved rows are still in the dataset.
VALID_EMPTY	Groups were reachable and produced no billed members.
INVALID_INPUT	No valid public Telegram URLs. Fix the input; no member-found events are charged.
UPSTREAM_FAILED	Public Telegram pages returned no usable data for the requested work.

Connect the workflow

• Discover public chats by topic with Telegram Keyword Search Scraper, then pass matching t.me URLs here for active members.
• After you collect public @usernames, scrape that channel's public posts with Telegram Channel Scraper.

Best results

• Prefer public channels (and groups) that show a working t.me/s/<username> preview in a browser.
• Keep maxMembers at 5–20 for first passes to sample yield before scaling.
• Leave includeMentions on for denser channel scans; turn it off for author-only lists.
• Enable enrichProfiles when you need bio/photo context for outreach.
• Re-run on a schedule and diff username values; this Actor is a public-preview snapshot rather than a live Telegram firehose.

Builder's note

I built this after probing Telegram's public HTML instead of assuming a member-list API. Public profile cards expose title and member/subscriber counts, while identities come from the /s/ widget messages — owners, forwarded-from names, and mention links. Many groups redirect /s/ back to the profile card, so the durable product is an honest active-member sample with unbilled empty semantics (no hollow dataset rows), an honest sample rather than a pretend full roster. In my testing, Residential proxies and a bounded maxMembers keep quality prefills inside five minutes while keeping billing aligned with real rows.

FAQ

Do I need a Telegram account? No. The Actor reads public web pages. Runs without a phone number, session, or Bot API token.

Will I get every member of a large group? This Actor returns identities visible on the public web preview. Full login-gated rosters are a different product class.

What if a group has thousands of members but zero rows? Often the public /s/ preview is closed. The Actor finishes VALID_EMPTY and includes the public member count in RUN_SUMMARY.perGroup when available.

Can an AI agent use this? Yes. Pass public groupUrls, cap maxMembers, then inspect OUTPUT.outcome and the dataset profile URLs.

Responsible use

This Actor returns public Telegram web-preview identities for research, monitoring, and enrichment. Use it in line with Telegram terms and applicable laws, and keep it on public listings.