# Telegram Group Member (`truefetch/telegram-group-member`) Actor

Extract Telegram group members — full name, username, public phone number, bio, profile photo URL, and 18 fields. Collect thousands per run. Telegram API credentials included.

- **URL**: https://apify.com/truefetch/telegram-group-member.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Social media, News, Videos
- **Stats:** 701 total users, 25 monthly users, 100.0% runs succeeded, 22 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.49 / 1,000 results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

**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**](https://apify.com/truefetch/telegram-group-member/input) · [**View API**](https://apify.com/truefetch/telegram-group-member/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:

```json
{
  "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:

```json
{
  "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.

```bash
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](https://apify.com/truefetch/telegram-group-member/api). For an MCP client, follow the [Apify MCP documentation](https://docs.apify.com/platform/integrations/mcp):

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

Then call the Actor with the same input:

```json
{
  "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](https://apify.com/truefetch/telegram-group-member) 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](https://apify.com/truefetch/telegram-channel-message) — when the unit you need is the post rather than the person, including timestamps and engagement.
- [Telegram Profile](https://apify.com/truefetch/telegram-profile) — resolve a list of mixed usernames or IDs into user, bot, channel, and group profiles.
- [Reddit User Profile](https://apify.com/truefetch/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](https://t.me/TrueFetch), or the Issues tab on the [Actor page](https://apify.com/truefetch/telegram-group-member). 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**](https://apify.com/truefetch/telegram-group-member/input) · [**View API**](https://apify.com/truefetch/telegram-group-member/api)

# Actor input Schema

## `deep_search` (type: `boolean`):

Also collect members from the people who posted in the group. Telegram hides the participant list on most groups, so without this a run returns only the few dozen members the group still exposes. Leave it on unless you specifically want just that visible list.

## `max_results` (type: `integer`):

Members to return, minimum 1. Telegram hides the participant list on most groups, so the visible list alone returns only a few dozen people however large the group is — measured at 22 of 5,396 and 38 of 26,305. Turn on Deep Search to read members from the group's message history, which is what reaches larger numbers: measured at 5 to 10 members per second, depending on how many distinct people post. Rows are saved as they are found, so a run that hits its timeout keeps everything already returned.

## `telegram_url` (type: `string`):

Public Telegram group as a username, @username, t.me username URL, or telegram.me username URL. Invite, joinchat, plus-style, private, and non-Telegram links are rejected.

## Actor input object example

```json
{
  "max_results": 2,
  "telegram_url": "https://t.me/Python"
}
```

# Actor output Schema

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

Telegram participant profiles in the default dataset with identifiers, names, usernames, activity signals, flags, and provenance.

# 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 = {
    "deep_search": false,
    "max_results": 2,
    "telegram_url": "https://t.me/Python"
};

// Run the Actor and wait for it to finish
const run = await client.actor("truefetch/telegram-group-member").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 = {
    "deep_search": False,
    "max_results": 2,
    "telegram_url": "https://t.me/Python",
}

# Run the Actor and wait for it to finish
run = client.actor("truefetch/telegram-group-member").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "deep_search": false,
  "max_results": 2,
  "telegram_url": "https://t.me/Python"
}' |
apify call truefetch/telegram-group-member --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=truefetch/telegram-group-member",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/actors/8vxvc9BwwG34zvS5P/builds/VPUbedJRlFXdGnKLn/openapi.json