# Telegram Channel Info Scraper (`khadinakbar/telegram-channel-info-scraper`) Actor

Scrape public Telegram channel and group info plus engagement stats. Use for subscriber counts, bios, verification, and recent-view averages. Do not use for message history — see telegram-channel-scraper. Returns one row per channel. Charged $0.005 per channel found.

- **URL**: https://apify.com/khadinakbar/telegram-channel-info-scraper.md
- **Developed by:** [Khadin Akbar](https://apify.com/khadinakbar) (community)
- **Categories:** Social media, Lead generation, MCP servers
- **Stats:** 1 total users, 0 monthly users, 0.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $5.00 / 1,000 channel info scrapeds

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/actors/running/actors-in-store.md#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 Channel Info Scraper

Turn public Telegram channel and group usernames into one structured info row each. Paste handles or `t.me` URLs and get title, bio, subscriber or member count, verification badge, avatar, media counters, and optional engagement stats from the public preview. No Telegram login, bot token, or phone number.

This Actor is built for analysts and agents that need a size-and-reach check on known public handles before they spend on full message history.

### Best fit for this Actor

- Enrich a known list of public Telegram handles with subscriber counts and bios.
- Compare public channel size and recent preview engagement before outreach.
- Feed MCP or CRM workflows with one predictable row per channel.

For full public message history, continue with [Telegram Channel Scraper](https://apify.com/khadinakbar/telegram-channel-scraper) after you finish the size check. For keyword discovery of public channels, start with [Telegram Keyword Search Scraper](https://apify.com/khadinakbar/telegram-keyword-search-scraper) and then return here for info enrichment.

### Practical scenario

A growth analyst pastes `durov` and `telegram`, keeps `includeEngagementStats` enabled, and sets `maxRecentPosts` to `10`. The run returns one row per public channel: title, bio, subscriber count, verification, and `engagement.avgViews` from the public preview sample. A private or unknown handle finishes `SUCCEEDED` with `VALID_EMPTY` and no `channel-info` charge. Handles that clear the size bar are then passed to the message scraper for post history.

### Quick start input

```json
{
  "channels": ["durov", "telegram"],
  "includeEngagementStats": true,
  "maxRecentPosts": 10
}
```

`channels` accepts bare usernames, `@handles`, or `https://t.me/...` / `https://t.me/s/...` URLs. Duplicate handles are collapsed before any HTTP call.

### Input reference

| Field | Type | What it controls |
|---|---|---|
| `channels` | array (required) | Public usernames or `t.me` URLs. Example: `durov`. Max 100 unique values. |
| `includeEngagementStats` | boolean | Sample recent public preview posts for view averages. Default true. |
| `maxRecentPosts` | integer | Preview posts sampled for stats only. Default 20, max 50. Post bodies are omitted from the dataset. |
| `maxChannels` | integer | Hard cap after dedupe. Default 100. |
| `proxyConfiguration` | object | Optional Apify proxy. Enable Residential when Telegram rate-limits direct HTTP. |

### What data you receive

One dataset item is one public channel or group info row.

```json
{
  "inputChannel": "durov",
  "username": "durov",
  "channelUrl": "https://t.me/durov",
  "title": "Pavel Durov",
  "description": "Official channel",
  "entityType": "channel",
  "isVerified": true,
  "subscriberCount": 1300000,
  "photoCount": 12,
  "videoCount": 4,
  "engagement": {
    "postsSampled": 10,
    "avgViews": 10250,
    "medianViews": 9000,
    "minViews": 8000,
    "maxViews": 12500,
    "lastPostAt": "2026-08-20T15:33:00.000Z",
    "postsPerDay": 1.2
  },
  "provider": "telegram-web-preview",
  "sourceUrl": "https://t.me/s/durov",
  "matchFound": true,
  "outcome": "FOUND",
  "scrapedAt": "2026-08-21T12:00:00.000Z"
}
```

| Field | Meaning |
|---|---|
| `title` + `description` | Public display name and bio |
| `subscriberCount` | Public subscriber or member count |
| `entityType` | `channel` or `group` when the public counters reveal it |
| `engagement` | Sampled preview view averages and `lastPostAt` when enabled |
| `sourceUrl` / `provider` | Telegram public page and fetch route used for the row |

`OUTPUT` and `RUN_SUMMARY` in the default key-value store hold `outcome`, `itemsPushed`, `channelsFound`, and `chargedEventCounts`.

### Use through the API

```bash
curl -X POST "https://api.apify.com/v2/acts/khadinakbar~telegram-channel-info-scraper/runs" \
  -H "Authorization: Bearer $APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"channels":["durov"],"includeEngagementStats":true,"maxRecentPosts":10}'
```

Download rows as JSON, CSV, Excel, or HTML from the Dataset tab.

### Use with AI agents through Apify MCP

> Look up public Telegram channel info for durov and telegram. Return username, title, subscriberCount, isVerified, and engagement.avgViews. Keep the scope to public profile and stats.

Connect via <https://mcp.apify.com>. Read `OUTPUT.outcome` and `itemsPushed` to interpret empty datasets. Cost signal: about `$0.005` per found channel plus platform usage. Private or missing handles surface as `VALID_EMPTY` CLEAR rows without a `channel-info` charge.

### Connect the workflow

- After you confirm channel size, scrape message history with [Telegram Channel Scraper](https://apify.com/khadinakbar/telegram-channel-scraper).
- When you still need handles to check, discover them with [Telegram Keyword Search Scraper](https://apify.com/khadinakbar/telegram-keyword-search-scraper).

### Pricing

This Actor uses Pay per event plus Apify platform usage. The live Pricing tab is the current source of truth for billing details.

- `apify-actor-start`: $0.00005 per run
- `channel-info`: **$0.005** per found channel info row

A one-channel prefill is about $0.005 in result events plus a few seconds of Apify platform usage. Missing or private handles have no `channel-info` charge.

### How it works

1. Normalize and deduplicate usernames and `t.me` URLs.
2. Fetch `t.me/s/{username}` first, then fall back to `t.me/{username}` when needed.
3. Parse public counters, bio, verification, and optional preview engagement.
4. Charge `channel-info` for found rows, then write the dataset item.

### Best results

- Pass public usernames or `t.me` profile URLs rather than invite hashes.
- Keep `maxRecentPosts` near 10 when you only need a fast engagement sample.
- Enable Apify Residential proxy when Telegram returns repeated rate-limit responses.
- A typo handle finishes `SUCCEEDED` with `VALID_EMPTY` and no channel charge.

### Builder's note

I found that Telegram's public `t.me/s/{username}` HTML already exposes subscriber counters and per-post view labels without login, which is enough for a lean info-and-stats product. Keeping message bodies out of this Actor lets agents run a cheap size check first, then call the sibling message scraper only for handles that matter. Preview-first with a profile-page fallback covers channels that omit `/s/` counters while staying on plain HTTP.

### Legal and responsible use

Use this Actor on public Telegram web preview data you are authorized to process, follow applicable law and Telegram's terms, and keep the output in your own compliance workflow. This Actor is independent of Telegram.

Issues and feature requests: use the Actor Issues tab on Apify.

# Actor input Schema

## `channels` (type: `array`):

Public Telegram channel or group usernames or t.me URLs to look up. Example: durov or https://t.me/durov. Up to 100 unique public handles per run. NOT invite links (+hash) and NOT a message-scrape request — for post history use telegram-channel-scraper.

## `includeEngagementStats` (type: `boolean`):

When true, sample recent public preview posts and attach avg/median/min/max views, lastPostAt, and postsPerDay. Defaults to true. Does not return message text rows. Set false for profile counters only.

## `maxRecentPosts` (type: `integer`):

How many public preview posts to sample for engagement stats only. Defaults to 20. Prefill 10 keeps quality tests fast. Maximum 50. Not a message export limit — post bodies are not saved.

## `maxChannels` (type: `integer`):

Hard cap on unique channels processed after dedupe. Defaults to 100. Lower this to bound spend. Each found channel costs $0.005.

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

Optional Apify proxy. Leave off for the default direct HTTP path. Enable Apify Residential if Telegram returns 403/429. This is not a Telegram account session.

## Actor input object example

```json
{
  "channels": [
    "durov",
    "telegram"
  ],
  "includeEngagementStats": true,
  "maxRecentPosts": 10,
  "maxChannels": 10
}
```

# Actor output Schema

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

One row per channel: found info/stats or CLEAR outcomes.

## `output` (type: `string`):

Final outcome, itemsPushed, channelsFound, and chargedEventCounts.

## `runSummary` (type: `string`):

Per-channel outcomes, retries, blocked fetches, and billing counters.

# 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 = {
    "channels": [
        "durov"
    ],
    "includeEngagementStats": true,
    "maxRecentPosts": 10,
    "maxChannels": 10
};

// Run the Actor and wait for it to finish
const run = await client.actor("khadinakbar/telegram-channel-info-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 = {
    "channels": ["durov"],
    "includeEngagementStats": True,
    "maxRecentPosts": 10,
    "maxChannels": 10,
}

# Run the Actor and wait for it to finish
run = client.actor("khadinakbar/telegram-channel-info-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 '{
  "channels": [
    "durov"
  ],
  "includeEngagementStats": true,
  "maxRecentPosts": 10,
  "maxChannels": 10
}' |
apify call khadinakbar/telegram-channel-info-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,khadinakbar/telegram-channel-info-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/V6O6eMXhm6VhnhGOx/builds/v1uO04mrzkGgXyLUt/openapi.json