# Telegram Channel Scraper: Messages, Views, Reactions (`alexmorain/telegram-channel-scraper`) Actor

Scrape public Telegram channels without an account: every message with text, views, reactions, media, forwards and polls. Find channels by keyword. 30,000 messages in 2 minutes. Date filters, new-only watch, webhook.

- **URL**: https://apify.com/alexmorain/telegram-channel-scraper.md
- **Developed by:** [Alexis Morain](https://apify.com/alexmorain) (community)
- **Categories:** Social media, News, Automation
- **Features:** Limited permissions
- **Stats:** 1 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.40 / 1,000 messages

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

### What does Telegram Channel Scraper do?

**Telegram Channel Scraper** reads public Telegram channels and returns every message as a clean row: text, HTML, date, views, reactions, photos, videos, documents, polls, forwards, replies and link previews. It works from the public web preview of each channel (`t.me/s/<channel>`), so you need **no Telegram account, no API ID, no phone number and no login**. Think of it as a Telegram channel API that works with a list of channel names.

It reads a channel's pages in parallel, by message id, instead of clicking "next" one page at a time. On the default 1 GB it delivered **30,000 messages in 2 minutes** from a single channel, with no proxy and no refused request (measured on the Apify platform, November 2026).

What it does not do: it does not read private channels, groups, chats or member lists, it does not download media files (you get the URLs), and in this version it does not return the comments under a post.

### Why use Telegram Channel Scraper?

Telegram is where news, crypto announcements, drops, leaks, job boards and communities publish first. Reading it by hand does not scale, and the official API asks for an account you have to keep alive.

- **Media monitoring and OSINT**: follow hundreds of news and political channels and keep a searchable archive.
- **Crypto and finance**: capture project announcements, calls and signals with their timestamps and view counts.
- **Brand and competitor tracking**: search a word inside a list of channels and get every mention with its reach.
- **Research and data science**: build text datasets by channel, by language, by period.
- **Lead and sponsorship research**: find which channels post what, how many views they get and how reactions compare.
- **Alerting**: schedule a run, turn on the watch mode, and receive only messages that were never delivered before, with a webhook when the run ends.

On Apify you also get scheduling, an API, integrations (Make, Zapier, n8n, Slack, Google Sheets), run history and monitoring, with no server to maintain.

### What data can Telegram Channel Scraper extract?

One row per message (`type: "message"`). With **Add one row per channel** you also get one `channel` row per channel.

| Field | Type | Description |
|---|---|---|
| `channel`, `id`, `url` | text, number, text | Channel username, message id and permanent message URL |
| `date` | text | Publication time, ISO 8601 with UTC offset |
| `text`, `html` | text | Plain text with line breaks, and the HTML with bold, italics, links and custom emoji |
| `views`, `viewsText` | number, text | Views as a number, and as Telegram prints it (`4.67M`) |
| `reactions`, `reactionsTotal` | array, number | Each reaction with emoji or custom emoji id, paid Stars flag and count; the sum |
| `edited`, `signature` | boolean, text | The message was edited; the author signature when the channel signs posts |
| `forwardedFrom`, `forwardedFromUrl` | text | Original source of a forwarded message |
| `replyToId`, `replyToUrl`, `replyToText` | number, text | The message this one replies to, with an excerpt |
| `mediaTypes`, `media` | array | Photos (CDN URL), videos (URL, thumbnail, duration), documents (title), polls. Albums come back as one message with several photos |
| `poll` | object | Native poll: question, type, options with their share of votes |
| `linkPreview` | object | The card under the message: URL, site name, title, description, image |
| `links`, `hashtags`, `buttons` | arrays | Every link and hashtag in the text, and the inline buttons |
| `viaBot` | text | Bot used to post, for example `@vote` |
| `unsupportedMedia` | boolean | True when Telegram's web preview shows nothing but "Please open Telegram" (some media types) |

Channel rows carry `title`, `verified`, `subscribers`, `description`, `photosCount`, `videosCount`, `linksCount` and the channel picture.

### How to scrape Telegram channels

1. Open the **Input** tab and paste your channels, one per line: `@durov`, `durov`, `https://t.me/durov` or `t.me/s/durov`.
2. Set **Max messages per channel**. The default is 100, newest first. Use `0` to read a channel to its first message.
3. Optional: set a date window (`7 days`, `2026-11-01`), **Keywords** to keep only matching messages, or an id to start after.
4. Click **Start**. Messages appear in the dataset while the run is going.
5. Download the dataset as JSON, CSV, Excel, XML or HTML, or read it through the API.

To follow channels over time, schedule the run (for example every hour) and set **Watch mode** to **New only**.

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

Pay per event, no subscription and no compute bill on top. Check the **Pricing** tab for the price of your Apify plan.

| Event | Free and Bronze plans | Gold plans and above |
|---|---|---|
| Message delivered | $0.70 per 1,000 | $0.40 per 1,000 |
| Channel profile (optional) | $1.00 per 1,000 | $0.50 per 1,000 |
| Run start | $0.002 per GB of memory (the default 1 GB is one event) | same |

So 10,000 messages cost $7.00 plus $0.002 on a Free plan. A channel row is only billed when you ask for it (the optional channel row, or a channel found by keyword: with the @username lookup on, found channels without a public @username are free; with it off, every channel found is billed). Rows for channels that could not be read, and messages already delivered by an earlier run in watch mode, are free.

You choose the limit of every run. Set **Max messages per channel**, and use the maximum charge setting of your Apify run to cap the total spend; the actor stops cleanly when the cap is reached.

### Input

See the **Input** tab for every option. The ones people ask about most:

- **Find channels by keyword**: words to look for in the names and descriptions of public channels (see below). Optional.
- **Telegram channels**: usernames or links. Private invite links (`t.me/+...`) have no public preview and are skipped.
- **Only messages since / until**: absolute (`2026-11-01`) or relative (`7 days`). `until` jumps to the right place in the channel with about 15 requests; it does not read everything newer first.
- **Only messages after this id**: the number at the end of a message URL.
- **Keywords**: deliver only messages containing one of your words or phrases, ignoring case. The actor reads the history and keeps the matches; messages that do not match are free.
- **Telegram search inside the channels**: Telegram's own search box. It returns at most about 22 of the newest matches per channel, see the limits below.
- **Watch mode / Watch name**: deliver each message once across runs.
- **Webhook URL**: receives a JSON summary at the end of every run.

### Output

You can download the dataset in various formats such as JSON, HTML, CSV or Excel. A message looks like this (shortened):

```json
{
  "type": "message",
  "channel": "durov",
  "id": 537,
  "url": "https://t.me/durov/537",
  "date": "2026-08-03T07:19:56+00:00",
  "text": "The 2026 International Olympiad in Artificial Intelligence starts today. ...",
  "html": "<tg-emoji emoji-id=\"5927026418616636353\">...</tg-emoji> The 2026 International Olympiad in <b>Artificial ...",
  "views": 4090000,
  "viewsText": "4.09M",
  "edited": false,
  "signature": "Pavel Durov",
  "mediaTypes": ["photo"],
  "media": [{ "type": "photo", "url": "https://cdn4.telesco.pe/file/...", "link": "https://t.me/durov/537" }],
  "reactions": [
    { "emoji": "⭐", "customEmojiId": null, "paid": true, "count": 15500 },
    { "emoji": null, "customEmojiId": "5399847211989246390", "paid": false, "count": 39800 }
  ],
  "reactionsTotal": 55300,
  "links": [],
  "hashtags": [],
  "scrapedAt": "2026-11-12T09:00:00Z"
}
```

A channel that cannot be read comes back as a free row, so a pipeline always knows why:

```json
{ "type": "error", "channel": "someghostchannel", "url": "https://t.me/someghostchannel", "status": "no_preview" }
```

`status` is `no_preview` (private, banned, renamed away, or no public web preview) or `unreachable` (Telegram did not answer after several tries).

#### Run it from code

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("alexmorain/telegram-channel-scraper").call(run_input={
    "channels": ["durov", "telegram"],
    "maxMessages": 200,
    "sinceDate": "7 days",
    "keywords": ["launch"],
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["channel"], item["id"], item["views"], (item["text"] or "")[:80])
```

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('alexmorain/telegram-channel-scraper').call({
    channels: ['durov', 'telegram'],
    keywords: ['update', 'release'],
    maxMessages: 200,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items.length);
```

```bash
curl -X POST "https://api.apify.com/v2/acts/alexmorain~telegram-channel-scraper/run-sync-get-dataset-items?token=<YOUR_APIFY_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"channels": ["durov"], "maxMessages": 50}'
```

### Tips and advanced options

- **Find channels by keyword.** Telegram has no channel search on the web, so put words in **Find channels by keyword** and the actor reads a public channel directory. A broad word returns up to about 1,500 channels (`bitcoin`: 47 pages of 30), each as a `channel` row with title, subscribers, description and categories, and the `keyword` that found it. **Look up the @username** (on by default) adds one request per channel: channels without a public @username are left out and are **not charged**. With it **off**, every channel found is billed as a channel profile, with or without a @username. **Read the messages of the channels found** chains the result straight into the message reader. The search runs at two requests per second through a residential proxy that we pay for (measured November 2026: about 1,000 channels with usernames in 9 minutes); it covers what the directory lists, not every channel on Telegram, and it stops cleanly, keeping what it found, if the directory stops answering. Channel rows found this way are billed as **channel profile** events, one per channel returned. A search word whose directory page stops answering is skipped; the search stops after three such words in a row and keeps what it found.

- **Follow channels without paying twice.** Schedule the run and turn on Watch mode **New only**. The actor keeps, for each channel, the ranges of messages already read and delivered in a named key-value store called `telegram-monitor` in your account. The first run fixes the starting point of the watch, older history is never pulled in later. If a run stops early (message limit, spending limit), the next run fills the gap and does not deliver the same message twice. You can add channels to the list at any time. Use **Watch name** to keep two schedules apart.

- **Bound big channels.** A date window or `afterMessageId` stops reading as soon as it reaches older messages. A `0` limit on a channel of several hundred thousand messages is what you pay for, one row at a time.

- **Search a word in the whole history.** Use **Keywords**, not Telegram search. Telegram's own search stops after about 22 matches per channel (we measured the same cap on five channels and five words), so it cannot find an old mention. With Keywords the actor reads the channel and keeps the matches, you pay for matches only. Pair it with a date window: a rare word on a channel of 300,000 messages makes the actor read all of them, and a run stops by itself after 50,000 messages read with fewer than one match per 500.

- **Speed.** The default 1 GB and 32 parallel requests read about 250 messages per second. More memory reads faster (2 GB: about 420 per second, two start events). Telegram's public pages need no proxy in our measurements; the Proxy field is there if a run ever reports refused requests.

- **Pipelines.** For one channel at a time, use `run-sync-get-dataset-items` with a small `maxMessages`. The watch mode and the webhook are made for scheduled runs.

### Limits you should know

- **Views, subscribers and reaction counts are rounded by Telegram** above a thousand (`4.67M`, `15.5K`). `views` is that figure as a number, `viewsText` is what Telegram printed. Exact counts exist only inside the Telegram apps.
- **Public channels with a web preview only.** Some channels disable the preview, and Telegram redirects them; they come back as `no_preview`. Groups, private channels and chats are out of reach without an account.
- **No comments yet.** Replies under a channel post (the discussion thread) are not returned in this version.
- **Media is returned as links** to Telegram's CDN. Photo and video URLs can expire, download what you need soon. Some media types show only "Please open Telegram"; those rows have `unsupportedMedia: true` and no text.
- **Deleted messages do not exist for us**; ids with no message are simply absent. An album is one message, with several photos.
- **Telegram's own search is capped at about 22 matches per channel.** That is Telegram's limit on its public pages. Use Keywords for anything deeper.
- **The channel search is the directory's search, not Telegram's.** It matches the directory's own names and descriptions, so a channel can be missing, and subscriber counts are the directory's (not rounded by Telegram, but possibly a few days old).
- **Telegram can change or close its web preview** at any time, without notice. If a run returns nothing, open an issue.

### FAQ, disclaimers and support

#### Is it legal to scrape Telegram channels?

The actor only reads what Telegram shows to any visitor of `t.me/s/<channel>`: no login, no private chat, no member list. Public does not mean free of rules. Message texts and signatures can contain personal data (names, handles, phone numbers people wrote themselves). In the EU and the UK, once you download the rows you are the data controller under the GDPR, not this actor and not Apify.

In practice:

- Know your legal basis before you collect, and write it down. Legitimate interest and journalism or research exemptions are different bases with different duties.
- Collect only the channels and fields you need, and delete data you no longer use.
- Do not use the data to profile or harass individuals, and answer access or deletion requests.
- Respect Telegram's terms and the laws of your country. Some channels host illegal content; do not store or redistribute it.

If you are unsure whether your reason is legitimate, consult your lawyer. This text is not legal advice.

#### Do I need a Telegram account or an API key?

No. The actor reads the same public pages a browser reads.

#### Can it scrape a whole Telegram channel?

Yes. Set **Max messages per channel** to `0`. There is no page cap: ids are reachable from the newest message down to message 1. Time grows with the size of the channel (about 250 messages per second on the default memory).

#### Can I get only the messages that contain a word?

Yes, use **Keywords**. It works on the whole history, not only on recent posts, and only the matching messages are billed. Telegram's own search box is also available but returns at most about 22 matches per channel.

#### Can I scrape Telegram groups or private channels?

No. Groups and private channels do not have a public web preview, and this actor deliberately does not log in.

#### Why do the views look rounded?

Telegram only gives rounded figures on its public pages. See the limits above.

#### What happens if the run is interrupted or the platform moves it?

Rows already delivered are not delivered or charged again after a restart, and the watch registry only records what was actually delivered.

#### How do I get help or ask for a feature?

Use the **Issues** tab of this Actor. For programmatic access, see the **API** tab.

### Guide and use cases

Use cases for outbound and automation, the output fields, pricing and common questions are on the [Telegram Channel Scraper page](https://alexis.morain.fr/en/scrapers/telegram-channel-scraper/) of my site. The [Social media and content family page](https://alexis.morain.fr/en/scrapers/families/social-content/) puts it side by side with the other scrapers of the same family.

# Actor input Schema

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

Public channels to read, one per line: <code>@durov</code>, <code>durov</code>, <code>https://t.me/durov</code> or <code>t.me/s/durov</code>. A channel that is private, banned, renamed away or without a public web preview comes back as a free row with <code>status</code> set to <code>no_preview</code>. Private invite links (<code>t.me/+...</code>) have no public preview and are skipped.

## `findChannels` (type: `array`):

Optional. Words or phrases to look for in the names and descriptions of public Telegram channels (up to 20), for example <code>bitcoin</code> or <code>real estate</code>. Telegram has no channel search on the web, so the actor reads a public channel directory: up to about 1,500 channels for a broad word, each with title, subscribers, description and categories. One <b>channel profile</b> is billed per channel returned (see the @username option below for what counts). Can be combined with <b>Telegram channels</b>.

## `maxFoundChannels` (type: `integer`):

Stops each search word after this many channels. A broad word has up to about 1,500; a narrow one far fewer.

## `resolveUsernames` (type: `boolean`):

The directory lists channels without their Telegram @username; looking it up takes one extra request per channel (the run is slower, about 2 channels per second). <b>On:</b> channels without a public @username are left out and are <b>not</b> charged; every channel returned is billed as one <b>channel profile</b>. <b>Off:</b> you get the title, subscribers and description only (much faster, the <code>channel</code> field stays empty) and <b>every channel found is billed as a channel profile</b>, with or without a @username.

## `readFoundChannels` (type: `boolean`):

Also reads the channels found, with the message options below (<b>Max messages per channel</b>, dates, keywords). Needs the @username lookup. Billed as usual per message.

## `maxMessages` (type: `integer`):

The most recent messages to deliver for each channel, newest first. <code>0</code> reads the channel to its very first message (a channel of 350,000 messages takes minutes, and you pay per message). Combine with the date window below to bound a run.

## `sinceDate` (type: `string`):

Keep messages posted on or after this date: <code>2026-11-01</code>, <code>2026-11-01T08:00:00Z</code> or a relative time such as <code>7 days</code>. Reading stops as soon as it reaches older messages, so a recent window on a huge channel is fast and cheap.

## `untilDate` (type: `string`):

Keep messages posted on or before this date. The actor jumps straight to that point in the channel (about 15 requests), it does not read everything newer first. Cannot be combined with the watch mode.

## `afterMessageId` (type: `integer`):

Keep messages whose id is greater than this number (the number at the end of a message URL, <code>t.me/durov/537</code> gives <code>537</code>). Applies to every channel of the run. Leave empty to read from the newest message down.

## `searchQuery` (type: `string`):

Only messages found by Telegram's own in-channel search (the search box of the channel's web page). <b>Telegram returns at most about 22 of the newest matches per channel</b>, whatever the word: handy for a quick look at recent mentions, not for history. To filter a long history, use <b>Keywords</b> below.

## `keywords` (type: `array`):

Deliver only messages whose text, link preview or poll question contains one of these words or phrases (any of them, ignoring case). The actor reads the channel as usual and keeps the matches, so it works on the whole history, unlike Telegram's search. Messages that do not match are <b>free</b>. A run that reads 50,000 messages with fewer than one match per 500 stops early: narrow it with a date window.

## `includeChannelInfo` (type: `boolean`):

Adds a <code>channel</code> row per channel: title, @username, verified badge, subscribers, description and counters of photos, videos and links. Billed as <b>channel info</b>. Subscriber counts are rounded by Telegram (<code>9.14M</code>).

## `monitorMode` (type: `string`):

With <b>New only</b> the actor remembers what it has already read and delivered for each channel in a named key-value store of your account, and only delivers messages that never went out before. Put the run on a schedule to follow channels. The first run reads the window you asked for and fixes the starting point of the watch; older history is never pulled in later. A run cut short (message limit, spending limit) leaves no hole: the next run fills it.

## `registryKey` (type: `string`):

Optional name of this watch. Two schedules with different names keep separate memories; without a name, the memory is tied to the search query only, so you can add channels to the list at any time.

## `webhookUrl` (type: `string`):

Optional. A JSON summary of the run is sent here by <code>POST</code> when it ends: status, number of messages and the channels that could not be read. Works with Slack, Discord, Zapier, Make or n8n URLs.

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

How many pages are fetched at the same time. 32 reads about 20 messages per page; lower it if you run through a proxy that rate-limits.

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

Optional. Telegram's public pages normally need no proxy. Leave off unless a run reports refused requests.

## Actor input object example

```json
{
  "channels": [
    "durov"
  ],
  "maxFoundChannels": 100,
  "resolveUsernames": true,
  "readFoundChannels": false,
  "maxMessages": 30,
  "includeChannelInfo": false,
  "monitorMode": "off",
  "maxConcurrency": 32
}
```

# Actor output Schema

## `messages` (type: `string`):

One row per message: text, date, views, reactions, media

## `channels` (type: `string`):

One row per channel when channel info is on

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

Every row with all fields

# 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"
    ],
    "maxFoundChannels": 100,
    "maxMessages": 30
};

// Run the Actor and wait for it to finish
const run = await client.actor("alexmorain/telegram-channel-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"],
    "maxFoundChannels": 100,
    "maxMessages": 30,
}

# Run the Actor and wait for it to finish
run = client.actor("alexmorain/telegram-channel-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"
  ],
  "maxFoundChannels": 100,
  "maxMessages": 30
}' |
apify call alexmorain/telegram-channel-scraper --silent --output-dataset

```

## MCP server setup

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