# Telegram Channel Info Scraper — members, bio & invite links (`memo23/telegram-channel-info-scraper`) Actor

Turn any list of t.me links into structured channel intelligence — names, bios, avatars, live member counts, verified badges, content counters. Resolves private invite links without joining. Channels, groups, bots & users auto-detected. No API key, no login, no proxy needed.

- **URL**: https://apify.com/memo23/telegram-channel-info-scraper.md
- **Developed by:** [Muhamed Didovic](https://apify.com/memo23) (community)
- **Categories:** Social media, Agents, AI
- **Stats:** 23 total users, 19 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: 5.00 out of 5 stars

## Pricing

from $5.00 / 1,000 channel results

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.

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 Scraper — channels, groups & bots from t.me links

Scrape **Telegram channel, group, and bot metadata** straight from t.me links — display name, bio, avatar, subscriber/member counts, verified badge, and content counters. Works with **public usernames AND private invite links** (`t.me/+...`), needs **no Telegram account, no API key, and no login**, and returns clean JSON/CSV you can plug into any workflow.

![How Telegram Channel Scraper works](https://raw.githubusercontent.com/muhamed-didovic/muhamed-didovic.github.io/main/assets/how-it-works-telegram-channel.png)

### Why use this scraper?

- **Invite links supported** — `t.me/+hash` and legacy `t.me/joinchat/...` links return the group/channel name, bio, avatar, and live member + online counts **without joining**.
- **Zero setup** — no Telegram API credentials, no phone number, no session files. Paste links, press Start.
- **Every entity type** — public channels, private groups, bots, and user profiles are auto-detected and typed (`channel` / `group` / `bot` / `user`).
- **Content counters** — public channels also get exact photos, videos, files, and links counts.
- **Forgiving input** — post URLs (`t.me/channel/123`), web previews (`t.me/s/channel`), `telegram.me` aliases, and bare `@usernames` are all normalized automatically.
- **Fast and parallel** — a sliding window of concurrent HTTP requests; hundreds of channels resolve in seconds.

### Overview

Give the actor any list of t.me links or usernames. For each one it fetches Telegram's public preview page, detects what kind of entity it is, and returns one structured row with the name, bio, avatar URL, member counts, and (for public channels) content counters. That's it — one row in, one row out, no padding.

### Supported inputs

| Input | Example | Result |
|---|---|---|
| Public channel | `https://t.me/telegram` | name, bio, avatar, subscribers, photo/video/link counters |
| Private invite link | `https://t.me/+Zt3-XNsQ5h9jYWE8` | name, bio, avatar, members + online, invite hash |
| Legacy invite link | `https://t.me/joinchat/AbCdEf123` | normalized to `t.me/+AbCdEf123` |
| Bot | `https://t.me/BotFather` | name, bio, avatar, monthly users |
| User profile | `https://t.me/durov` | name, bio, avatar |
| Post URL | `https://t.me/telegram/123` | normalized to the channel root |
| Web preview | `https://t.me/s/bloomberg` | normalized to the channel root |
| Bare handle | `@durov` or `durov` (via the *Usernames* field) | same as the full URL |

### Use cases

- **Channel discovery & vetting** — bulk-check member counts and bios before advertising, partnering, or joining.
- **Crypto / trading community intel** — resolve invite links shared on social media into named, sized communities.
- **Influencer & media monitoring** — track subscriber growth of news channels and creators over time (schedule the actor, diff the counts).
- **Lead enrichment** — turn t.me links found on websites into structured channel data for your CRM.
- **Trust & safety research** — catalogue channel metadata at scale from lists of invite links.
- **Bot market research** — monthly-user counts for competing Telegram bots.

### How it works

1. **Normalize** — every input (URL, invite link, post URL, `@handle`) is normalized to a canonical t.me preview URL and deduplicated.
2. **Fetch** — each preview page is fetched with browser-grade TLS fingerprints (impit) in a parallel sliding window. t.me has no anti-bot, so no proxy is needed.
3. **Parse** — display name, bio (line breaks preserved), avatar, verified badge, and counts are extracted; the entity type is detected from the page structure.
4. **Enrich** — for public channels, the `t.me/s/` web preview adds exact photos / videos / files / links counters (toggle with `channelStats`).
5. **Push** — one dataset row per entity, JSON or CSV.

### Input configuration

```json
{
    "startUrls": [
        "https://t.me/telegram",
        "https://t.me/+Zt3-XNsQ5h9jYWE8"
    ],
    "usernames": ["@durov"],
    "channelStats": true,
    "maxItems": 1000
}
```

| Field | Type | Default | Description |
|---|---|---|---|
| `startUrls` | array | — | t.me / telegram.me links — any mix of channels, groups, bots, invite links |
| `usernames` | array | `[]` | Bare handles as an alternative to full URLs |
| `channelStats` | boolean | `true` | Fetch photo/video/file/link counters for public channels (1 extra request each) |
| `maxItems` | integer | `1000` | Hard cap on entities scraped in the run |
| `maxConcurrency` | integer | `10` | Parallel requests |
| `proxy` | object | none | Optional — t.me needs no proxy; direct is fastest |

### Output overview

One row per Telegram entity:

```json
{
    "url": "https://t.me/+Zt3-XNsQ5h9jYWE8",
    "username": null,
    "fullName": "SOLANA SUMMER",
    "bio": "Com : https://t.me/+Zt3-XNsQ5h9jYWE8\n\nChannel : https://t.me/Solanasummmers",
    "avatarUrl": "https://cdn4.telesco.pe/file/NFdH2M17pF...jpg",
    "memberCounts": 456,
    "type": "group",
    "subscribers": null,
    "members": 456,
    "online": 80,
    "monthlyUsers": null,
    "verified": false,
    "inviteHash": "Zt3-XNsQ5h9jYWE8",
    "scrapedAt": "2026-07-15T21:13:58.521Z"
}
```

Public channels additionally include:

```json
{
    "fullName": "Telegram News",
    "username": "telegram",
    "type": "channel",
    "subscribers": 10075225,
    "memberCounts": 10075225,
    "verified": true,
    "photos": 13,
    "videos": 222,
    "files": null,
    "links": 367
}
```

### Key output fields

| Field | Description |
|---|---|
| `fullName` | Display name of the channel / group / bot / user |
| `username` | Public handle; `null` for private invite-link entities |
| `bio` | Description text with line breaks preserved |
| `avatarUrl` | Profile photo on Telegram's CDN (`telesco.pe`) |
| `memberCounts` | Headline count — subscribers (channels), members (groups), monthly users (bots) |
| `type` | `channel` / `group` / `bot` / `user` — auto-detected |
| `subscribers` / `members` / `online` / `monthlyUsers` | Granular counts; only the ones the entity exposes are set |
| `verified` | Telegram's blue-check verification badge |
| `inviteHash` | The `+hash` part of invite links; `null` for public entities |
| `photos` / `videos` / `files` / `links` | Content counters (public channels with `channelStats: true`) |

### FAQ

**Do I need a Telegram account or API key?**
No. The actor reads Telegram's public t.me preview pages — no account, no `api_id`/`api_hash`, no phone number, no session string.

**Does it work with private invite links?**
Yes — that's a headline feature. `t.me/+hash` links return the entity's name, bio, avatar, member count, and online count without joining. The `username` field is `null` for these because Telegram doesn't expose it pre-join.

**Can it scrape channel messages/posts?**
No — this actor is for channel *metadata*. Message scraping is a different (and much heavier) problem. If you paste a post URL, the actor resolves it to the channel and returns the channel's data.

**Can it search for channels by keyword?**
No — Telegram has no public channel search. Feed it links or usernames from your own sources (websites, social media, directories).

**Are member counts exact?**
Yes for the headline counts — they come from the live page (e.g. `10 075 225 subscribers`). The photo/video/link counters for very large channels are Telegram's own values.

**What happens with dead or invalid links?**
Unrecognizable inputs are reported and skipped at the start; deleted/invalid entities are logged and skipped without producing a row. You only pay for actual results.

**Does it expose emails or phone numbers?**
No — Telegram doesn't publish these on preview pages, so the actor can't (and doesn't pretend to) return them.

### Support

- **Issues tab** — fastest way to report a problem or request a field; I typically respond within 24 hours.
- The actor sends me automatic failure alerts, so broken runs are usually being fixed before you write in.

### Additional services

Need a custom pipeline (channel-growth tracking, invite-link resolution at scale, integration with your CRM), a private variant of this actor, or a scraper for another platform? Reach out via the Issues tab or my Apify profile — custom work is available.

### Explore more scrapers

Check my Apify profile for more scrapers — jobs (LinkedIn, Indeed, Glassdoor, Upwork), real estate (Zillow, Realtor, Rightmove, ImmoScout24, Idealista), reviews (Trustpilot, Glassdoor), travel (Expedia), and many more directory and listing sites.

### 🤖 For AI Agents & LLM Apps

Compact reference for AI agents calling this actor via the [Apify MCP server](https://mcp.apify.com) or the Apify API (actor: `memo23/telegram-channel-scraper`).

**Purpose:** Resolve t.me links (public channels, groups, bots, users, and private invite links) into structured metadata rows — name, bio, avatar, and member/subscriber counts — with no Telegram account or API key.

**Minimal input:**

```json
{
    "startUrls": ["https://t.me/telegram"],
    "maxItems": 20
}
```

Instead of (or alongside) `startUrls` you can pass `usernames` — bare handles like `@durov` or `durov`; the two lists are merged and deduplicated.

**Output:** one row per entity — `url`, `username`, `fullName`, `bio`, `avatarUrl`, `memberCounts`, `type` (`channel`/`group`/`bot`/`user`), `subscribers`, `members`, `online`, `monthlyUsers`, `verified`, `inviteHash`, `scrapedAt`; public channels also add `photos`, `videos`, `files`, `links`.

**Behaviors an agent should know:**

- Always set `maxItems` — it caps entities scraped (default 1000).
- `channelStats` defaults true and adds photo/video/file/link counters for public channels at one extra HTTP request each; set false to skip.
- Private invite links (`t.me/+hash`) return name, bio, avatar, members, and online without joining; `username` is `null` for them and `inviteHash` is set.
- No proxy is needed — t.me has no anti-bot; there is no keyword channel search, so feed known links/usernames.
- Metadata only — no messages, emails, or phone numbers; unrecognizable or dead links are skipped without a row, and you pay only for actual results.
- Billing: Pay-per-event billing — see the Pricing tab on the actor page.

### ⚠️ Disclaimer

This actor collects only **publicly available data** from Telegram's public t.me preview pages — the same information any logged-out visitor sees in a browser. It does not access private content, does not join groups or channels, does not read messages, and does not bypass any authentication. You are responsible for how you use the data: comply with Telegram's Terms of Service, applicable data-protection laws (GDPR, CCPA), and platform policies in your jurisdiction. This actor is not affiliated with or endorsed by Telegram.

### SEO Keywords

telegram channel scraper, telegram scraper, scrape telegram channel, telegram channel info, telegram members count scraper, telegram invite link resolver, t.me scraper, telegram group scraper, telegram bot scraper, telegram channel metadata, telegram subscriber count, telegram channel analytics, extract telegram channel data, telegram channel details api, telegram osint, telegram channel lookup, bulk telegram channel checker, telegram channel export, telegram data extraction, scrape t.me links

# Actor input Schema

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

Full t.me URLs — one channel, group, bot, or user per link. Private invite links (t.me/+hash) are supported: they return the entity's name, bio, avatar, and member count without joining.

## `usernames` (type: `array`):

Bare Telegram handles, with or without the @ — e.g. `@telegram` or `durov`. Merged with the URL list above and deduplicated.

## `channelStats` (type: `boolean`):

For public channels, also fetch the t.me/s/ web preview to add exact photos, videos, files, and links counters to the output. Adds one extra HTTP call per public channel. Groups, bots, and invite-link entities are unaffected.

## `maxItems` (type: `integer`):

Hard cap on the number of Telegram entities scraped in this run. Use it to limit billing on large link lists.

## `maxConcurrency` (type: `integer`):

Maximum number of t.me pages processed in parallel.

## `minConcurrency` (type: `integer`):

Minimum number of t.me pages processed in parallel.

## `maxRequestRetries` (type: `integer`):

Number of retries before a failed request is given up.

## `proxy` (type: `object`):

t.me is served from Telegram's edge with no anti-bot, so no proxy is needed — direct connections are fastest. Configure a proxy here only if your infrastructure requires one.

## Actor input object example

```json
{
  "startUrls": [
    "https://t.me/telegram",
    "https://t.me/durov"
  ],
  "usernames": [],
  "channelStats": true,
  "maxItems": 1000,
  "maxConcurrency": 10,
  "minConcurrency": 1,
  "maxRequestRetries": 5,
  "proxy": {
    "useApifyProxy": false
  }
}
```

# 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 = {
    "startUrls": [
        "https://t.me/telegram",
        "https://t.me/durov"
    ],
    "usernames": [],
    "proxy": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("memo23/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 = {
    "startUrls": [
        "https://t.me/telegram",
        "https://t.me/durov",
    ],
    "usernames": [],
    "proxy": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("memo23/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 '{
  "startUrls": [
    "https://t.me/telegram",
    "https://t.me/durov"
  ],
  "usernames": [],
  "proxy": {
    "useApifyProxy": false
  }
}' |
apify call memo23/telegram-channel-info-scraper --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,memo23/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/xdrjAZ4QoKQIpDgzG/builds/Sod3KictRAqIEvtRb/openapi.json