# Telegram Member Scraper (`scrapeai/telegram-member-scraper`) Actor

Pull the full member roster from any public Telegram group — up to 10,000,000 users per run, with optional Deep Search to surface hidden and historical members the standard API hides. Each member record includes username, names, premium flag, language, and last-seen signal.

- **URL**: https://apify.com/scrapeai/telegram-member-scraper.md
- **Developed by:** [ScrapeAI](https://apify.com/scrapeai) (community)
- **Categories:** Social media, Lead generation, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.99 / 1,000 results

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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

## Telegram Member Scraper

Pull the full member roster from any public Telegram group — up to 10,000,000 users per run, with optional Deep Search to surface hidden and historical members the standard API hides. Each member record includes username, names, premium flag, language, and last-seen signals.

***

### What does Telegram Member Scraper do?

**Telegram Member Scraper** allows you to extract member lists, active participants, group admins, and historical group contributors from any public Telegram group or supergroup without needing a Telegram login or API key.

By combining public group metadata with **Deep Search**, it inspects group posts, replies, comments, reaction signals, forward sources, and system join events to surface members that standard API endpoints hide or truncate.

### Why use Telegram Member Scraper?

- **No Telegram Login Required**: Extract member data publicly without registering phone numbers or user tokens.
- **Deep Search Technology**: Uncover historical, silent, and active group participants beyond the standard 200-member member list cap.
- **Enriched Member Profiles**: Collect display names, usernames, Telegram Premium flags, user roles (owner/admin/member), language codes, and last-seen activity signals.
- **High Volume Capacity**: Extract up to **10,000,000 user records per run** across multiple target Telegram groups.
- **Apify Platform Integration**: Schedule regular scrapings, export via REST API, or connect to Webhooks, Google Sheets, Make, and Zapier.

### What data can Telegram Member Scraper extract?

Each scraped item in the output dataset contains structured member details:

| Field Name | Type | Description |
| :--- | :--- | :--- |
| `groupHandle` | String | Target Telegram group handle (e.g. `@durov_chat`). |
| `groupTitle` | String | Display title of the Telegram group. |
| `username` | String | Telegram username of the member (e.g. `@username`). |
| `firstName` | String | First name of the member. |
| `lastName` | String | Last name of the member (if available). |
| `fullName` | String | Complete display name of the member. |
| `role` | String | Role within the group (`owner`, `admin`, `member`). |
| `isPremium` | Boolean | Signal indicating whether user has Telegram Premium. |
| `isBot` | Boolean | Whether the user account is a bot. |
| `isVerified` | Boolean | Whether the member account is officially verified. |
| `languageCode` | String | Detected primary language code (e.g. `en`, `ru`, `es`, `de`). |
| `lastSeen` | String | Activity signal (e.g. `Recently`, `Online`, `Within a week`). |
| `discoverySource` | String | Source signal (`message_author`, `member_mention`, `group_roster`, `comment_author`). |
| `scrapedAt` | String | ISO 8601 UTC timestamp when data was scraped. |

### How to scrape Telegram group members

1. **Specify Target Groups**: Enter the Telegram group usernames or URLs (e.g. `durov_chat`, `@telegram`, `https://t.me/durov_chat`).
2. **Enable Deep Search**: Keep `deepSearch: true` to surface hidden and historical group participants.
3. **Set Max Members**: Adjust maximum members limit per group (up to 10,000,000).
4. **Run the Actor**: Click **Start** to process the groups and extract member profiles.
5. **Download Dataset**: Export your records in JSON, CSV, Excel, or XML format.

### Input

See the **Input** tab in Apify Console for all available settings:

```json
{
  "groups": [
    "durov_chat",
    "@telegram"
  ],
  "startUrls": [
    {
      "url": "https://t.me/durov_chat"
    }
  ],
  "deepSearch": true,
  "maxMembers": 1000,
  "includeBots": false
}
```

### Output

You can download the dataset in various formats such as JSON, HTML, CSV, or Excel. Here is a sample JSON output:

```json
[
  {
    "groupHandle": "@durov_chat",
    "groupTitle": "Durov's Channel Chat",
    "username": "@durov",
    "firstName": "Pavel",
    "lastName": "Durov",
    "fullName": "Pavel Durov",
    "role": "owner",
    "isPremium": true,
    "isBot": false,
    "isVerified": true,
    "languageCode": "en",
    "lastSeen": "Recently",
    "discoverySource": "group_roster",
    "scrapedAt": "2026-08-06T12:00:00.000Z"
  },
  {
    "groupHandle": "@durov_chat",
    "groupTitle": "Durov's Channel Chat",
    "username": "@elena_ros",
    "firstName": "Elena",
    "lastName": "Rostova",
    "fullName": "Elena Rostova",
    "role": "member",
    "isPremium": true,
    "isBot": false,
    "isVerified": false,
    "languageCode": "ru",
    "lastSeen": "Recently",
    "discoverySource": "comment_author",
    "scrapedAt": "2026-08-06T12:00:05.000Z"
  }
]
```

### How much will it cost to scrape Telegram group members?

Scraping public Telegram groups with Cheerio crawler is fast and cost-efficient:

- **Lightweight HTTP Crawling**: Consumes minimal compute units (CUs).
- **Average Cost**: ~$0.05 to $0.15 per 10,000 member records extracted.
- Free tier accounts receive monthly Apify platform credits, sufficient for scanning multiple public groups.

### Disclaimer and Support

> Our Actors are ethical and do not extract any private user data, such as private phone numbers or hidden personal messages. They only extract what group members have chosen to share publicly in Telegram groups. We therefore believe that our Actors, when used for ethical purposes by Apify users, are safe. However, you should be aware that your results could contain personal data. Personal data is protected by GDPR in the European Union and other privacy regulations worldwide. You should not scrape personal data unless you have a legitimate reason to do so.

# Actor input Schema

## `groups` (type: `array`):

List of public Telegram group handles or URLs to extract members from (e.g. \['durov\_chat', '@telegram', 'https://t.me/durov']).

## `startUrls` (type: `array`):

Telegram group URLs to extract members from.

## `deepSearch` (type: `boolean`):

Deep Search scans group message history, replies, comments, reaction signals, and user interactions to surface hidden and historical members that standard API lists hide.

## `maxMembers` (type: `integer`):

Maximum number of member records to extract per group (1 to 10,000,000).

## `includeBots` (type: `boolean`):

Whether to include bot accounts in the extracted member list.

## `proxyConfiguration` (type: `object`):

Select proxies to be used by your crawler.

## Actor input object example

```json
{
  "groups": [
    "durov_chat",
    "@telegram"
  ],
  "startUrls": [
    {
      "url": "https://t.me/durov_chat"
    }
  ],
  "deepSearch": true,
  "maxMembers": 1000,
  "includeBots": false
}
```

# Actor output Schema

## `dataset` (type: `string`):

No description

# 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 = {
    "groups": [
        "durov_chat",
        "@telegram"
    ],
    "startUrls": [
        {
            "url": "https://t.me/durov_chat"
        }
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("scrapeai/telegram-member-scraper").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 = {
    "groups": [
        "durov_chat",
        "@telegram",
    ],
    "startUrls": [{ "url": "https://t.me/durov_chat" }],
}

# Run the Actor and wait for it to finish
run = client.actor("scrapeai/telegram-member-scraper").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 '{
  "groups": [
    "durov_chat",
    "@telegram"
  ],
  "startUrls": [
    {
      "url": "https://t.me/durov_chat"
    }
  ]
}' |
apify call scrapeai/telegram-member-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,scrapeai/telegram-member-scraper"
        }
    }
}

```

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/a0xBtQsdPQatLmne7/builds/lhp4AIHZ0GCOwxST5/openapi.json