# 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:** 697 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

> **Affiliate disclosure:** Some Apify links below include the `aiagentapi` referral parameter. TrueFetch may receive referral attribution when you use those links; your Actor price does not change.

**Telegram Group Member creates a structured sample of visible participant profiles from one public Telegram group. You can optionally extend discovery to unique authors found in accessible message history, while keeping the result grounded as a sample rather than promising a complete or hidden roster.**

- **Three required inputs choose one username-addressable group, a 100 to 10,000,000 profile cap, and whether message-author discovery is enabled.**
- **The default dataset uses 18 stable fields for IDs, names, usernames, account type, activity signals, source flags, and processing provenance.**
- **The paired production path was tested on July 24, 2026: a request for 100 against a group reporting 13,964 members returned 7 complete 18-field profiles in 7.47 seconds.**
- **The Store page showed 691 total users, 26 monthly users, 98.1% successful runs, 18 bookmarks, and a 5.00/5 rating from 4 ratings on July 24, 2026.**

[**Create a 100-profile sample**](https://apify.com/truefetch/telegram-group-member/input?fpr=aiagentapi) · [**Integrate Telegram Group Member**](https://apify.com/truefetch/telegram-group-member/api?fpr=aiagentapi)

A full FREE-plan cap of 10 returned profiles has a **$0.01550 fixed-event subtotal** before variable `actor_usage`. Telegram privacy, group configuration, participant visibility, message history, rate limits, runtime, and current pricing determine actual yield and cost. Use a maximum total charge and process only data you are authorized to collect.

### What does Telegram Group Member do?

The Actor accepts one public Telegram group identifier and returns unique person or bot profiles that the source makes visible during the run. It can use the standard participant surface and, when requested, accessible message history to discover additional author IDs. Results are deduplicated by numeric user ID within the run.

Each row can include a first and last name, known usernames, visible phone number, user-or-bot classification, language code, last-seen category, story visibility, premium-contact setting, and Telegram-provided deleted, verified, premium, scam, fake, and restricted flags. The processor URL and timestamp establish when and where the row was produced.

This is not a private-group access tool, guaranteed member export, phone directory, outreach service, identity proof, or historical membership ledger. A message author is not necessarily a current member, and a silent member who never appears through an accessible source cannot be inferred.

### How do I run Telegram Group Member?

Open the [input page](https://apify.com/truefetch/telegram-group-member/input?fpr=aiagentapi), keep discovery off for the first test, request 100 profiles, and use the public example group. The same scenario appears in every integration example below:

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

When the run finishes, inspect the default dataset. Confirm that every row contains the expected 18 keys, compare requested and actual counts, review nulls, and retain the run ID and original input. Terminal success alone does not establish completeness.

Only after that baseline should you test `deep_search: true`. Run it with the same modest profile cap so you can compare whether message-author discovery adds useful unique records and how much longer the request takes.

### What data does Telegram Group Member return?

The 18-field contract is intentionally compact:

- **Run provenance:** `processor`, `processed_at`.
- **Stable identity:** `user_id`, `entity_type`, `usernames`.
- **Visible profile text:** `first_name`, `last_name`, `phone_number`, `lang_code`.
- **Activity and contact signals:** `last_seen`, `stories_hidden`, `premium_contact`.
- **Telegram flags:** `is_deleted`, `is_verified`, `is_premium`, `is_scam`, `is_fake`, `is_restricted`.

The output does not contain the source group identifier or a label distinguishing participant discovery from message-author discovery. Keep run-level context with every export if you need lineage.

This representative record uses the shared public-group scenario and documented keys. The values are illustrative:

```json
{
  "processor": "https://apify.com/truefetch/telegram-group-member?fpr=aiagentapi",
  "processed_at": "2026-07-24T07:11:36+00:00",
  "user_id": 123456789,
  "first_name": "Example",
  "last_name": "Participant",
  "usernames": [
    "example_participant"
  ],
  "phone_number": null,
  "entity_type": "user",
  "is_deleted": false,
  "is_verified": false,
  "is_premium": false,
  "is_scam": false,
  "is_fake": false,
  "is_restricted": false,
  "lang_code": null,
  "last_seen": "recently",
  "stories_hidden": false,
  "premium_contact": false
}
```

Null, empty, false, and `unknown` should remain distinct. They can reflect privacy, source availability, field relevance, or the current profile state; they should not be filled with guesses.

### What inputs can I configure?

`telegram_url` is a required string. It accepts a username, @username, standard `t.me/username` or `telegram.me/username` URL, and public preview variants. It rejects invitation, `joinchat`, plus-style, private, blank, malformed, and unrelated-host inputs. The resolved target must be a group rather than a broadcast channel.

`max_results` is a required integer from 100 through 10,000,000. It is a ceiling for unique profiles, not an expected row count. A free user must still submit at least 100, but the runtime limits that plan to at most 10 results. Large values increase practical completion risk and do not expand what Telegram exposes.

`deep_search` is a required boolean. False keeps the request focused on visible participant discovery. True can add unique authors from accessible group messages, stopping at the requested cap or earlier source and runtime limits. It cannot reveal a hidden membership list or confirm that an author remains in the group.

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

The Actor covers Telegram groups that can be addressed through a public username. It does not cover private invite-only access, broadcast-channel audience lists, direct messages, or other social platforms.

There is no country, city, language, date, or demographic filter. Geographic and language coverage follows the group and the fields Telegram reveals. A phone number or language code is frequently null, and `last_seen` may be categorical rather than precise.

Message-author discovery uses available group history without a user-selected date range. For regional or time-bounded research, filter the resulting authorized dataset using reliable external context rather than assuming the rows represent a defined market or period.

### Why use Telegram Group Member?

Use this Actor when you need a reproducible, bounded profile sample instead of opening visible participants one by one. Numeric IDs support within-run deduplication, the timestamp supports auditability, and the 18-field shape is easy to export or validate.

The discovery toggle supports two research postures. Standard mode is the safer baseline for an available participant sample. Message-author mode can broaden an activity-oriented sample when Telegram returns few participants, provided downstream users keep its historical and current-membership ambiguity visible.

The API surface also makes outcome verification explicit. Requested count, returned count, status, run ID, and dataset ID can be recorded together rather than hiding short output behind a broad “members scraped” claim.

### Who is Telegram Group Member for?

**Community analysts** can build a small authorized sample for manual review and aggregate summaries.

**Trust and safety teams** can treat Telegram-provided scam, fake, verified, deleted, and restriction fields as source signals within a documented assessment.

**Data engineers** can schedule bounded runs, validate the 18-field contract, attach run-level group lineage, and deliver the dataset to an approved system.

**Researchers** can compare participant-only and message-author samples without representing either as a complete census. It is not appropriate for spam, unsolicited contact campaigns, covert tracking, or sensitive profiling.

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

The synchronous HTTP endpoint below runs the shared discovery-off baseline. Replace `YOUR_TOKEN` and keep it out of source control and logs:

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

Configure an MCP client using the [Apify MCP guide](https://docs.apify.com/platform/integrations/mcp?fpr=aiagentapi):

```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": 100,
    "telegram_url": "https://t.me/DatascienceChats"
  }
}
```

For larger requests, start asynchronously, poll the run, fetch the dataset, and compare actual rows with the cap. MCP execution rights depend on the plan and credentials of the calling client.

### How much does Telegram Group Member cost?

Charges combine one Actor start, variable resource usage, and a result event for each profile written to the default dataset.

| 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/event | $0.00001/event | $0.00001/event | $0.00001/event | $0.00001/event | $0.00001/event |
| Result profile | $0.00055 | $0.00053 | $0.00051 | $0.00050 | $0.00050 | $0.00050 |

A full FREE-plan cap is **$0.01000 + 10 × $0.00055 = $0.01550**, before variable `actor_usage`. A schema-valid request still uses `max_results: 100`, but fewer than 10 returned rows produce fewer result events. Check live prices before committing a budget.

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

Manual Telegram review is suitable for a handful of visible profiles but lacks a repeatable schema, processing timestamp, programmatic row count, or run record. A generic page scraper may capture rendered text but does not provide the same user-ID-centered contract.

[Telegram Profile](https://apify.com/truefetch/telegram-profile?fpr=aiagentapi) is preferable when you already have mixed user, bot, channel, or group identifiers and want entity metadata. [Telegram Channel Message](https://apify.com/truefetch/telegram-channel-message?fpr=aiagentapi) is preferable when the output unit is a message. Telegram Group Member is specifically for a bounded profile sample associated with one public group.

No alternative can guarantee a hidden roster without access the platform does not expose. Evaluate tools by their documented target rules, returned rows, field contract, price events, and observed results rather than a headline maximum.

### What are the limits and troubleshooting steps?

A reported group size is not the available participant count. In the July 24 paired test, the source reported 13,964 members while only 7 profiles were returned for a request of 100. Treat this as an expected visibility limitation, not evidence of a complete list.

If the target is rejected, retry a canonical public username, @handle, or standard Telegram username URL. Confirm it is a group, not a broadcast channel or invite-only link. If output is small, validate the returned rows before enabling message-author discovery.

Discovery mode can take much longer on an old or active group and has no input date bound. Repeated authors, unavailable history, source errors, deleted senders, and practical runtime can reduce new results. Preserve run ID, input, dataset ID, requested cap, and actual count when requesting support.

### Frequently asked questions

#### Does message-author discovery export hidden members?

No. It returns additional unique authors visible in accessible history. It cannot infer silent hidden members or guarantee current membership.

#### Why is the minimum request 100 when free output is capped at 10?

The input schema requires at least 100, while the runtime applies a separate free-plan maximum of 10 results.

#### Can I target a private invitation link?

No. Invitation, plus-style, and joinchat links are rejected. Use a public username-addressable group.

#### Why is `phone_number` usually null?

Telegram controls phone visibility. Null is a normal result and should not be treated as an extraction error.

#### Are historical authors billed as result profiles?

If an author profile is written to the dataset, it uses the same result event as a participant profile. The row itself does not identify the discovery path.

### Related TrueFetch Actors

- [Telegram Channel Message](https://apify.com/truefetch/telegram-channel-message?fpr=aiagentapi) exports public messages with timestamps, source engagement, and optional stored media.
- [Telegram Profile](https://apify.com/truefetch/telegram-profile?fpr=aiagentapi) resolves mixed Telegram entity identifiers into user, bot, channel, group, and supergroup profiles.
- [Reddit User Profile](https://apify.com/truefetch/reddit-user-profile?fpr=aiagentapi) provides a separate public-account profile dataset for authorized research.

### Support and last updated

Contact the [TrueFetch group](https://t.me/TrueFetch) or [support](https://t.me/AiAgentApi) with the Actor name, run ID, sanitized public target, discovery setting, requested cap, actual row count, and relevant status. Never share tokens, sessions, private group material, or personal secrets.

Collect only data you are authorized to process. Follow Telegram terms, applicable law, privacy duties, copyright, and retention rules. Do not use the Actor for harassment, surveillance, doxxing, spam, sensitive profiling, unauthorized outreach, or attempts to bypass group privacy.

Last updated: July 24, 2026.

# Actor input Schema

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

After participant lookup, inspect accessible message history for additional unique authors, stopping at the requested cap or earlier source and runtime limits. This is not a hidden roster or current-member guarantee.

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

Requested maximum profiles from 100 to 10,000,000. Free users receive at most 10; source visibility, duplicates, history, runtime, and practical limits can return fewer.

## `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": 100,
  "telegram_url": "https://t.me/DatascienceChats"
}
```

# 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": 100,
    "telegram_url": "https://t.me/DatascienceChats"
};

// 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": 100,
    "telegram_url": "https://t.me/DatascienceChats",
}

# 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": 100,
  "telegram_url": "https://t.me/DatascienceChats"
}' |
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/acts/8vxvc9BwwG34zvS5P/builds/zWWmFaAjINKojgvhc/openapi.json