# Telegram Channel Scraper - Posts, Views & Reactions (`datalume/telegram-channel-scraper`) Actor

Scrape public Telegram channels without login or API key: post text, date, views, reactions, photos, videos, links, forwards and replies. Monitor channels with Only new posts and pay just for what is new. From $0.85 per 1,000 posts; missing channels and failures are free.

- **URL**: https://apify.com/datalume/telegram-channel-scraper.md
- **Developed by:** [Greg](https://apify.com/datalume) (community)
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.85 / 1,000 posts

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

## Telegram Channel Scraper - Posts, Views & Reactions

Scrape posts from **public Telegram channels** - text, date, views, reactions, photos, videos, links, link previews, hashtags, mentions, forwards and replies. No Telegram account, phone number or API key needed.

**From $0.85 per 1,000 posts** ($1.00 on the Apify Free plan). Channels that don't exist, failed pages and duplicates are free.

Use **Only new posts** with a schedule to monitor channels and pay only for what was published since your last run.

### Why this Telegram scraper

| | |
|---|---|
| **No account, no API key** | Reads Telegram's public web preview (`t.me/s/<channel>`). No phone number, no session file, no risk to your own Telegram account |
| **Only new posts** | Built-in monitoring: each run returns only posts published since your last run, per channel. Runs with nothing new cost $0.00005 |
| **Engagement numbers** | Views, every reaction with its count, paid Telegram Stars, subscriber count of the channel |
| **Media and links** | Photo and video URLs, video duration and thumbnail, link previews, all links, hashtags and mentions |
| **Context** | Forwarded-from channel, reply-to post, edited flag, author signature |
| **Filters** | Date range (`2026-11-01` or `7 days`), keyword search inside channels, per-channel and total limits |
| **Fast and cheap to run** | No browser and no proxy needed - 20-60 posts in about 4 seconds |
| **Fair pricing** | One price per post. Channels that don't exist, failed pages and duplicates are free |

### What makes it different

Compared with the 4 most-used Telegram channel post scrapers in Apify Store (checked 15 November 2026 from their public READMEs and pricing):

| | This Actor | Top 4 channel post scrapers |
|---|---|---|
| Only new posts, cursor kept for you (no post IDs to track) | ✅ | 1 of 4 |
| Failed pages and missing channels not charged | ✅ | 1 of 4 |
| Fee per run | $0.00005 | up to $0.005 |
| Price per 1,000 posts | $1.00 | $0.45 - $5 |

The low per-run fee matters for monitoring: an hourly check that finds nothing new costs almost nothing, so a schedule of 720 runs a month adds about $0.04 instead of $3.60.

### What you can do with it

- **Monitor channels** - crypto announcements, news, brand and competitor channels. Schedule a run every hour with `onlyNewPosts: true` and get only fresh posts.
- **Research and archives** - collect a channel's history for analysis, sentiment, topic tracking or an AI/RAG pipeline.
- **Engagement tracking** - views and reactions per post, subscriber count per channel.
- **Keyword search inside channels** - only posts matching a word, using the channel's own search.

### Input

| Field | What it does | Default |
|---|---|---|
| `channels` | Public channel usernames or links: `durov`, `@durov`, `https://t.me/durov`, `https://t.me/s/durov` | - |
| `maxPostsPerChannel` | Newest posts first, up to this many per channel | 100 |
| `onlyNewPosts` | Only posts newer than the newest one returned to you before (per channel and search) | false |
| `dateFrom` / `dateTo` | Date range: `2026-11-01`, or relative: `24 hours`, `7 days`, `2 weeks`, `3 months` | - |
| `searchQuery` | Keyword search inside each channel | - |
| `maxPosts` | Hard cap across all channels (0 = no limit) | 0 |
| `includeChannelInfo` | Add channel description, verified badge, photo and counters to every row | false |
| `proxyConfiguration` | Usually not needed - public channel pages load without a proxy | off |

#### Example: monitor three channels every hour

```json
{
  "channels": ["durov", "telegram", "https://t.me/binance_announcements"],
  "maxPostsPerChannel": 50,
  "onlyNewPosts": true
}
```

Create a schedule for this input. The first run returns the newest 50 posts per channel; every later run returns only posts published since the previous run. If nothing new was posted, you pay only the $0.00005 run start.

#### Example: last week of posts mentioning "wallet"

```json
{
  "channels": ["durov"],
  "searchQuery": "wallet",
  "dateFrom": "7 days"
}
```

### Output

One row per post, newest first:

```json
{
  "channel": "durov",
  "channelTitle": "Pavel Durov",
  "channelSubscribers": 10000000,
  "postId": 540,
  "postUrl": "https://t.me/durov/540",
  "date": "2026-08-10T09:29:58+00:00",
  "text": "🇺🇿 The 2026 International Olympiad in Informatics starts today in Tashkent. ...",
  "views": 5170000,
  "reactionsTotal": 43100,
  "paidStars": 9140,
  "reactions": [
    { "emoji": "⭐", "count": 9140, "paid": true },
    { "emoji": "👍", "count": 43100, "paid": false }
  ],
  "mediaType": "photo",
  "photoUrls": ["https://cdn4.telesco.pe/file/..."],
  "videos": [],
  "links": [],
  "hashtags": [],
  "mentions": [],
  "linkPreview": null,
  "edited": false,
  "author": "Pavel Durov",
  "forwarded": false,
  "forwardedFrom": null,
  "forwardedFromUrl": null,
  "replyToUrl": null,
  "searchQuery": null,
  "scrapedAt": "2026-11-14T15:00:00+00:00"
}
```

- `views`, `channelSubscribers`, reaction counts - Telegram shows rounded numbers above 1,000 (e.g. `5.17M`); they are converted to numbers as shown.
- `reactions` - standard emoji reactions use the emoji; custom emoji reactions are `custom:<id>`; paid Telegram Stars reactions are `⭐` with `paid: true` (not counted in `reactionsTotal`).
- `mediaType` - `text`, `photo`, `video`, `document`, `audio`, `poll`, `sticker`, `roundVideo`, `mixed`, or `unsupported` (media Telegram does not show on the web).
- `photoUrls`, `videos[].videoUrl` - direct media links from Telegram's CDN. **They expire after a while** - download what you need soon after the run.
- `forwardedFrom` - the original channel's name when Telegram shows it (`null` when hidden).

Run statistics (channels found and not found, pages, charged posts) are saved as `RUN_STATS` in the run's key-value store.

### Pricing

Pay per event - only for posts you get, no platform usage fees:

| Apify plan | Post (per 1,000) |
|---|---|
| Free | $1.00 |
| Starter | $0.95 |
| Scale | $0.90 |
| Business | $0.85 |

Plus a tiny **$0.00005 per run** (Actor start - that's $0.05 per 1,000 runs). No proxy costs.

Examples (Free plan prices):

- 10 channels × 100 posts = 1,000 posts → **$1.00**
- Hourly monitoring of 20 channels, ~5 new posts per channel per day → 100 posts/day → **~$3 per month** (+ $0.04 for 720 runs)
- A run where nothing new was posted → **$0.00005**

Set a maximum cost per run in the run options - the Actor stops before exceeding it.

### Reliability (real runs)

Measured on **14 Nov 2026**:

- Public channel pages loaded on **every route we tested** - no proxy, Apify datacenter proxy and residential proxy - for 3 channels, including paging back through older posts (9/9 pages).
- **15/15 back-to-back requests** succeeded with no rate limiting.
- `durov` + `telegram`, 20 posts each: **40 posts in 4 seconds** - text, date, views and reactions on 40/40.
- `binance_announcements` + `durov` + `telegram`: **60 posts in 4 seconds**.
- Temporary errors (HTTP 429 / 5xx) are retried up to 3 times; if a run gets close to its timeout, the Actor stops paging and finishes normally with the posts it already has.

### Use it from Python, n8n or an AI agent (MCP)

**Python** (`pip install apify-client`):

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("datalume/telegram-channel-scraper").call(run_input={
    "channels": ["durov", "telegram"],
    "maxPostsPerChannel": 50,
    "onlyNewPosts": True,
})
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item["date"], item["postUrl"], item["views"], (item["text"] or "")[:80])
```

**n8n, Make, Zapier or any HTTP client:** use the Apify app/node ("Run Actor" → `datalume/telegram-channel-scraper`) with the same JSON input, or call one endpoint that starts the run and returns the posts:

```
POST https://api.apify.com/v2/acts/datalume~telegram-channel-scraper/run-sync-get-dataset-items
Authorization: Bearer <YOUR_APIFY_TOKEN>
Content-Type: application/json
```

A common setup: a schedule every hour with `onlyNewPosts: true` → n8n / Zapier → post new items to Slack, Discord, email or Google Sheets.

**AI agents (Claude, Cursor, VS Code and other MCP clients):** add this Actor as a tool through Apify's hosted MCP server - you sign in to Apify in the browser on first use, no token in the config:

```
https://mcp.apify.com?tools=datalume/telegram-channel-scraper
```

AI agents without an Apify account can also run this Actor and pay per run through Apify's agentic payments (x402, Skyfire) - it uses pay-per-event pricing only.

| You ask | Input |
|---|---|
| "What did @durov post this week?" | `channels: ["durov"], dateFrom: "7 days"` |
| "New Binance announcements since last time" | `channels: ["binance_announcements"], onlyNewPosts: true` |
| "Posts mentioning 'wallet' in the Telegram channel" | `channels: ["telegram"], searchQuery: "wallet"` |

### Good to know

- **Public channels with web preview only** - the ones that open at `https://t.me/s/<channel>` in a browser. Private channels, invite links (`t.me/+…`), group chats and comments are not available.
- Some media (large videos, some documents) is not shown on Telegram's web preview; such posts still return their text and `mediaType`.
- Telegram serves 20 posts per page; very long histories (tens of thousands of posts) take a while.
- "Only new posts" remembers the newest post per channel in a key-value store named `datalume-telegram-state` in your account. Delete it to start over. If more new posts appeared than `maxPostsPerChannel`, only the newest ones are returned.

### FAQ

**Which channels work?**
Any public channel that opens at `https://t.me/s/<channel>` in a browser without logging in. Most public channels do; a few owners turn the web preview off. Those, private channels and groups are reported in the status message and `RUN_STATS` and cost nothing.

**Can I get comments, group chats or private channels?**
No. They are not on Telegram's public web preview, and this Actor never logs in.

**How far back can I go?**
As far as the channel's history goes - the Actor pages back 20 posts at a time until it reaches your limit or `dateFrom`.

**How do I monitor channels?**
Turn on *Only new posts*, set `maxPostsPerChannel` to the most you'd expect between runs, and create a schedule (for example hourly). Each run returns only what is new.

**Why are views like 1,380,000 and not exact?**
Telegram itself shows rounded numbers above 1,000 (`1.38M`); the Actor converts them as shown.

**Do I need a proxy?**
No. Leave the proxy off unless you run very large jobs and see many retries in the log.

**Is it legal?**
This Actor reads only what Telegram publishes on its public web preview pages, which anyone can open without logging in. It does not log in, join channels or read private chats. Posts can contain personal data - make sure your use complies with the GDPR and other laws that apply to you.

**Something is missing or wrong?**
Open an issue on the Actor page with your input and run ID - I usually reply within a day.

> Looking for posts about a keyword across many channels? Use **[Telegram Keyword Search Scraper](https://apify.com/datalume/telegram-keyword-search-scraper)**.

### Tutorial

[How to Scrape a Public Telegram Channel in Python (2026): No API Key, No Login](https://dev.to/datalume/how-to-scrape-a-public-telegram-channel-in-python-2026-no-api-key-no-login-jlf) — how Telegram's public web preview works, paging back through a channel, and the traps that break a simple scraper (reply previews, text extraction, rounded counts, monitoring state).

### Feedback

If this Actor saved you time, a short review on the Store page helps others find it. If something is off, please open an issue first so I can fix it.

### More from datalume

Reliable public-data scrapers - verified results, no charge for failures: **[apify.com/datalume](https://apify.com/datalume)**

***

*This Actor is not affiliated with, endorsed by or sponsored by Telegram. "Telegram" is a trademark of Telegram FZ-LLC. It collects publicly available channel posts only.*

# Actor input Schema

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

Public channel usernames or links, one per line: durov, @durov, https://t.me/durov or https://t.me/s/durov. Private invite links (t.me/+…) and group chats are not supported.

## `maxPostsPerChannel` (type: `integer`):

Newest posts first. The Actor stops paging a channel when it reaches this number.

## `onlyNewPosts` (type: `boolean`):

Return only posts published after the newest post returned to you in an earlier run (per channel and search). Use it with a schedule to monitor channels and pay only for new posts. The first run returns the newest posts up to the limit.

## `dateFrom` (type: `string`):

Only posts published on or after this date: 2026-11-01, or a relative period like 7 days, 24 hours, 2 weeks, 3 months. Paging stops at the first older post.

## `dateTo` (type: `string`):

Only posts published on or before this date (same formats).

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

Optional keyword. Uses the channel's own search on its public page, so only matching posts are returned.

## `maxPosts` (type: `integer`):

Hard cap across all channels (0 = no limit).

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

Adds channelInfo (description, verified badge, photo, photo/video/link counters). Title and subscriber count are always included.

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

Not needed in most cases: public channel pages load without a proxy. Turn on Apify Proxy only if you run very large jobs and see many retries.

## Actor input object example

```json
{
  "channels": [
    "durov",
    "telegram"
  ],
  "maxPostsPerChannel": 20,
  "onlyNewPosts": false,
  "maxPosts": 0,
  "includeChannelInfo": false,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `posts` (type: `string`):

One row per post: date, text, views, reactions, media.

## `media` (type: `string`):

Photo and video URLs, links, link previews, hashtags, mentions.

## `runStats` (type: `string`):

Channels found / not found, pages, charged posts.

# 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",
        "telegram"
    ],
    "maxPostsPerChannel": 20
};

// Run the Actor and wait for it to finish
const run = await client.actor("datalume/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",
        "telegram",
    ],
    "maxPostsPerChannel": 20,
}

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

```

## MCP server setup

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