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

Telegram group members export for public communities, returning 23-field profiles from the visible participant list and optional message-author discovery. Capture IDs, usernames, names, public flags, presence, bot facts, discovery path, and source-group context.

- **URL**: https://apify.com/truefetch/telegram-group-member.md
- **Developed by:** [TrueFetch](https://apify.com/truefetch) (community)
- **Categories:** Social media, Automation, Developer tools
- **Features:** Limited permissions
- **Stats:** 795 total users, 9 monthly users, 100.0% runs succeeded, 23 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $0.41 / 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/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 Group Member

**Telegram Group Member is a telegram group members export that returns 23-field public account profiles from a public group's visible participant list and, optionally, its message authors.** Every row keeps the source-group context and the discovery path that produced it.

- **Two read-only discovery paths.** Start with Telegram's visible participant list and enable message-author discovery when a broader activity-based sample is useful.
- **A reviewed 23-field contract.** Export identity, public state, presence, bot facts, source-group context, and processing provenance.
- **Traceable and deduplicated rows.** Each Telegram account is unique by numeric ID within a run, and `found_in` distinguishes participants from message authors.
- **Pay for delivered profiles.** One result event is charged only when a member profile is written to the default dataset.

[**Run Telegram Group Member**](https://apify.com/truefetch/telegram-group-member/input) · [**Open the API**](https://apify.com/truefetch/telegram-group-member/api)

At FREE-tier prices, the two-row prefill costs one $0.01000 Actor start plus up to two $0.00055 result events, or **$0.01110** before any separate platform usage charges.

### What does Telegram Group Member do?

Telegram Group Member resolves one public, username-addressable Telegram group and returns one dataset row per unique account it can observe, up to `max_results`.

The first discovery path reads Telegram's participant list. Many large groups expose only a limited visible subset. When `deep_search` is enabled, a second path scans reachable message history and records distinct authors. The `found_in` value is `participants` or `messages`, so downstream systems can keep those populations separate.

This is a public-data export, not a private-group access tool. It does not join groups, accept invite links, reveal a complete hidden roster, send messages, or modify membership. A message author may no longer be a current member, and an account that never posted and is not visible in the participant list cannot be discovered through these public surfaces.

### How do I run Telegram Group Member?

1. Set `telegram_url` to a public group username, `@handle`, or canonical `t.me` URL.
2. Choose `max_results`, starting with the two-profile prefill.
3. Leave `deep_search` off for a fast visible-list sample, or enable it to include distinct message authors.
4. Start the Actor and open the default dataset.

The production prefill is intentionally small and read-only:

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

`max_results` is a ceiling, not a promise that Telegram will expose that many profiles. Rows are stored incrementally, so profiles already collected remain available if a longer discovery run stops early.

### What data does Telegram Group Member return?

The Dataset schema contains 23 sparse fields. Source values that Telegram does not publish remain null instead of being guessed.

| Group | Fields | Meaning |
| --- | --- | --- |
| Source group | `group_id`, `group_username`, `group_title`, `group_member_count`, `group_members_hidden`, `found_in` | The requested community, Telegram's reported size and visibility, and the discovery path |
| Account identity | `id`, `username`, `usernames`, `source_url`, `first_name`, `last_name`, `type` | Numeric identity, active public handles, names, profile URL, and user-or-bot type |
| Public state | `has_photo`, `flags`, `restrictions`, `last_seen`, `colors`, `emoji_status`, `monetization`, `bot_info` | Public photo presence, account flags, restriction reasons, presence, visual metadata, paid-message facts, and bot capabilities |
| Processing | `processor`, `processed_at` | The Actor URL and UTC processing timestamp |

An abbreviated illustrative row:

```json
{
  "group_username": "Python",
  "group_members_hidden": true,
  "found_in": "participants",
  "id": 1036017898,
  "username": "telegram_user",
  "usernames": ["telegram_user"],
  "source_url": "https://t.me/telegram_user",
  "first_name": "Alex",
  "type": "user",
  "flags": ["premium"],
  "last_seen": "recently",
  "processed_at": "2026-08-10T12:00:00+00:00"
}
```

The Actor does not expose a phone field. `flags`, `restrictions`, `colors`, `emoji_status`, `monetization`, and `bot_info` preserve structured public facts instead of flattening them into an outdated set of booleans.

### What inputs can I configure?

`deep_search` — required boolean. When false, stop after the visible participant list. When true, continue through reachable messages and add unique authors. Deep search is broader but can take longer when a group has few distinct recent authors.

`max_results` — required integer, minimum 1. The run stops after this many unique profiles have been written. There is no schema maximum.

`telegram_url` — required string. Accepts a public bare username, `@handle`, canonical `t.me` URL, or `telegram.me` URL. Private invite links, `joinchat` links, plus-style invitations, foreign hosts, and broadcast channels are rejected.

There are no credential, date-range, language, country, or outreach inputs. The Actor performs a read-only export and never invites members or sends messages.

### What platforms and markets does Telegram Group Member cover?

Coverage is public Telegram groups and supergroups with a resolvable public username, worldwide. The Actor does not impose a country or language filter; the requested community determines the language and geography represented in the output.

Private or invite-only groups, broadcast channels, direct messages, and non-Telegram platforms are outside scope. Message-author discovery walks available history from newest to oldest, so active communities may produce a recent-activity sample while quieter communities can reach further back.

### Why use Telegram Group Member?

| Capability | Practical value |
| --- | --- |
| Fixed 23-field schema | Validate a warehouse or automation mapping once and reuse it |
| Two discovery paths | Compare the visible list with accounts that actually authored messages |
| `found_in` on every row | Preserve the meaning of each observation instead of mixing populations |
| Group context on every row | Combine exports without losing which community produced a profile |
| Deduplication by Telegram ID | Avoid duplicate rows when both paths encounter the same account |
| Incremental Dataset writes | Retain completed batches from a long run |
| Per-result pricing | Align the main charge with profiles actually delivered |

The useful promise is a structured, reproducible public sample—not a complete roster. Telegram controls visibility, and this README keeps that platform limit explicit.

### Who is Telegram Group Member for?

**Data engineers** can load stable, typed rows with explicit provenance into a warehouse or enrichment workflow.

**Community analysts** can compare visible participants with message authors and study public account types, activity states, or source-group composition.

**Trust and safety teams** can retain Telegram's public flags and restriction reasons as review inputs, without treating them as final judgments.

**Researchers** can collect a bounded, documented public sample while preserving the group and discovery method behind every observation.

This Actor is not suitable for guaranteed complete rosters, private-group access, unsolicited outreach, harassment, or covert profiling.

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

The public Actor ID is `8vxvc9BwwG34zvS5P`. Run the same two-result prefill synchronously with the REST API:

```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":2,"telegram_url":"https://t.me/Python"}'
```

Keep tokens in a secret store, not in source code. Generated JavaScript, Python, and OpenAPI examples are available on the [API page](https://apify.com/truefetch/telegram-group-member/api).

For MCP, connect through the [Apify MCP integration](https://docs.apify.com/platform/integrations/mcp) and call `truefetch/telegram-group-member` with the same input object. For larger jobs, start the run asynchronously, poll its status, and read the default dataset after completion. A result count below `max_results` is not automatically a failure because public visibility can be limited.

### How much does Telegram Group Member cost?

The local pricing contract has two events: one Actor start and one result event for each profile written. There is no separate local `actor_usage` event.

| Billed event | FREE | BRONZE | SILVER | GOLD | PLATINUM | DIAMOND |
| --- | ---: | ---: | ---: | ---: | ---: | ---: |
| Actor start | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 | $0.01000 |
| Result (one profile) | $0.00055 | $0.00050 | $0.00044 | $0.00041 | $0.00041 | $0.00041 |

Examples at FREE-tier result pricing:

| Delivered profiles | Start | Results | Total |
| ---: | ---: | ---: | ---: |
| 1 | $0.01000 | $0.00055 | $0.01055 |
| 2 | $0.01000 | $0.00110 | $0.01110 |
| 100 | $0.01000 | $0.05500 | $0.06500 |

The result charge follows rows actually written, not the requested ceiling. Check the [Actor pricing page](https://apify.com/truefetch/telegram-group-member/pricing) before a production run because Store pricing can change.

### How does Telegram Group Member compare with alternatives?

**Manual review** can work for a handful of profiles but produces no repeatable schema, Dataset, timestamps, or run record.

**A generic scraper aimed at a `t.me` preview page** can read visible posts but cannot obtain the participant-list profile contract exposed by this Actor.

**A custom Telegram client integration** offers maximum control but requires your team to manage accounts, sessions, rate limits, output mapping, and operational recovery.

**Tools promising a complete hidden roster** overstate what public Telegram surfaces expose. Compare tools by their field contract, visibility disclosures, discovery provenance, and handling of partial results.

Choose this Actor when you need a bounded public export with a stable schema and do not want to operate the Telegram client layer yourself.

### What are the limits and troubleshooting steps?

**Fewer profiles than requested.** Telegram may hide most of the participant list. Enable `deep_search` to add distinct message authors, and treat `max_results` as a ceiling.

**The target is reported as a channel.** Broadcast channels have subscribers rather than group members. Use a public discussion group instead.

**The group cannot be read.** Confirm that the target resolves publicly by username. Private invites, `joinchat`, and plus-style links are intentionally rejected.

**A deep-search run is slow.** A group with few distinct authors requires more message scanning per new profile. Reduce `max_results` for a smaller bounded sample.

**Fields are null or absent.** The Dataset contract is sparse because Telegram does not publish every fact for every account. Null is not an extraction failure by itself.

For a reproducible support case, run the two-result prefill and include the run ID, exact input, Dataset ID, requested count, and actual count. Never include API tokens or sensitive member data in a public issue.

### Frequently asked questions

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

Provide one public group and a result ceiling. The Actor reads the visible participant list and, when `deep_search` is enabled, adds distinct message authors while recording the discovery path on every profile.

#### Is there a Telegram group members API?

Yes. Call `truefetch/telegram-group-member` through Apify's REST API or MCP with `deep_search`, `max_results`, and `telegram_url`, then read the default dataset.

#### Does deep search reveal every hidden member?

No. It discovers accounts that authored reachable messages. A hidden member who never posted is not available through that public path.

#### Is a message author guaranteed to be a current member?

No. `found_in: "messages"` proves that the account authored a reachable message, not that it remains in the group today.

#### Can I export Telegram members to CSV or Excel?

Yes. Download the default dataset as CSV, JSON, or Excel. Nested public-state fields remain structured in JSON and may be serialized in tabular exports.

#### Are participant and message-author profiles priced differently?

No. Each profile written to the default dataset is one result event regardless of which discovery path found it.

#### Does the Actor send messages or invite accounts?

No. It is a read-only public-data export and contains no outreach or membership-mutation operation.

### Related TrueFetch Actors

- [Telegram Profile](https://apify.com/truefetch/telegram-profile) — resolve public Telegram users, bots, groups, and channels into structured profile records.
- [Telegram Channel Message](https://apify.com/truefetch/telegram-channel-message) — export public channel posts when the content itself is the unit of analysis.
- [Reddit Community Profile](https://apify.com/truefetch/reddit-community-profile) — collect community-level profile facts for a second public discussion platform.

### Support

For questions, bug reports, or feature requests, use the Issues tab on the [Actor page](https://apify.com/truefetch/telegram-group-member) or the [TrueFetch community group](https://t.me/TrueFetch). Include the run ID and exact non-secret input. Never publish tokens, sessions, or sensitive exported data.

Collect only data you are authorized to process. Follow Telegram's terms, Apify's policies, and applicable privacy, data-protection, and anti-spam law.

[**Run Telegram Group Member**](https://apify.com/truefetch/telegram-group-member/input) · [**Open the API**](https://apify.com/truefetch/telegram-group-member/api)

**Last Updated:** August 12, 2026

# Actor input Schema

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

When enabled, scan message authors after the visible participant list. Keep it off for a fast listed-member sample; enable it when hidden-list groups require broader author-based discovery.

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

Maximum unique member profiles to return, minimum 1. There is no schema maximum. Completed batches remain available if a long discovery run stops early.

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

Public Telegram group as a bare username, @handle, canonical t.me URL, or telegram.me URL. Private invite, joinchat, plus-style, foreign-host, and broadcast-channel targets are rejected.

## Actor input object example

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

# Actor output Schema

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

Telegram member profiles with public identity, source group, discovery path, profile state, bot details, and processing timestamps.

# 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(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 '{
  "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": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,truefetch/telegram-group-member"
        }
    }
}
```

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/8vxvc9BwwG34zvS5P/builds/mW3TrXOcaLgZ6dAIq/openapi.json