# Telegram Channel Scraper: Posts, Views & Reactions, No Login (`dataizi-srl/telegram-channel-scraper`) Actor

Scrape public Telegram channels via their t.me/s web preview. No login or API key. Posts, views, reactions and media. No comments, no Telegram-wide search.

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

## Pricing

from $0.22 / 1,000 results

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 and reactions, no login

Scrape the posts of any **public Telegram channel** into a clean table, without a Telegram account, a phone number or an API key. Give it channel names or `t.me` links and it returns one row per post: the text, the date, views, reactions, photos and video, polls, link previews, reply and forward details, plus the channel's title and subscriber count on every row. Export the result as JSON, CSV, Excel or HTML, or read it through the API.

It reads the public web preview that Telegram itself publishes at `t.me/s/<channel>`. Nothing is posted, joined or marked as viewed.

### ✅ What you get

- **One flat row per post.** Dates are ISO timestamps, counts are whole numbers, and every row has the same columns, so the data loads straight into a spreadsheet, a database or a monitoring pipeline. A column with no value for a post is empty (`null`, `[]` or `false`), never an empty string.
- **Reply threads and forwards.** For a reply you get the link, id, author and text of the post it answers; for a forward you get the original channel's name and link.
- **Reactions with counts**, including paid Star reactions and custom emoji.
- **Photos, video, documents, stickers, polls and link-preview cards** as URLs and text, plus a flag for posts that belong to an album.
- **Channel details on every row**: title, handle, verified badge, description, avatar, subscriber count and the counts of photos, videos, files and links.
- **A run summary** that says what each channel returned (posts found, no match, preview disabled, not found, blocked), so an empty result always comes with a reason.
- **Date range, in-channel text search and "new posts since the last run"** to keep runs small and your costs low.
- **One required input.** Paste channel names in any form: `telegram`, `@durov`, `https://t.me/telegram`, `https://t.me/s/telegram`, or a link to a single post to start from.

### 💡 Use cases

- **Monitor channels you follow** for news, announcements, releases or price alerts, on a schedule.
- **Track engagement**: views and reactions per post, per channel, over time.
- **Research and journalism**: pull a channel's posts for a date range or a keyword and export them for analysis.
- **Brand and competitor watching**: see what public channels say, how often, and how readers react.
- **Feed your own tools**: send fresh posts to a spreadsheet, a database, a Slack channel or an AI agent.

### 🚀 Quick start

1. Open the actor and click **Start**. The prefilled input reads the latest 20 posts of two public channels, so you see real rows within seconds.
2. Replace the two channels with your own, and set **Posts per channel** to how many you want.
3. Open the **Output** tab: **Posts** is the overview, and the other views show media, engagement, replies and forwards. **All fields** has every column.

### 🔧 Input

Only **Channels** is required.

| Field | What it does |
|---|---|
| **Channels** | Public channels to read: usernames, `@handles` or `t.me` links, one per line. A link to one post (`https://t.me/telegram/123`) starts at that post and goes back in time. |
| **What to extract** | **Posts** (default): one row per post. **Channels**: one row per channel, with its exact subscriber count and profile details. One run returns one kind of row. |
| **Posts per channel** | The newest posts to read from each channel (default 20). `0` means no per-channel cap: the run reads back until the channel's first post, or until your total-row limit, your spending limit or the run timeout stops it. |
| **Maximum rows in total** | Stops the whole run after this many rows across all channels. The default of 100 keeps a first run small; enter `0` for no total limit. Your spending limit still applies. |
| **Posts from this date** | Skips posts published before this date. Accepts `2026-10-01` or a relative time such as `7 days`, `3 weeks`, `1 month` or `1 year`, counted back from the start of the run, in UTC. |
| **Posts up to this date** | Skips posts published after this date. A plain date includes that whole day, so `2026-10-01` to `2026-10-31` gives October. |
| **Search inside channels** | Telegram's own search inside each channel you listed: a word, a phrase or a hashtag such as `#news`. It does not search across Telegram. |
| **New posts since the last run** | Remembers where each channel's last run stopped and returns just the newer posts next time. Use it in a saved task on a schedule. The date filters still apply. |
| **Include personal data** | On by default. Switch it off to set 10 person-level columns to empty (see "Personal data"). |
| **Proxy** | Off by default. You can switch on Apify Proxy. Residential groups, Google SERP groups and custom proxy URLs are refused. |

The date, search and "new since the last run" fields work in **Posts** mode. In **Channels** mode they are ignored, and the log says so.

#### Example input

```json
{
  "channels": ["telegram", "durov"],
  "mode": "posts",
  "maxPostsPerChannel": 20,
  "proxyConfiguration": { "useApifyProxy": false }
}
```

#### Watch channels for new posts

1. Create a **task** with your channels and **New posts since the last run** switched on.
2. Run the task once by hand. The first run has no starting point, so it reads the latest posts up to **Posts per channel** and saves one starting point per channel.
3. Add a **schedule** to the task and set its timezone explicitly. Every run after that returns the posts published since the previous one.

Each task keeps its own starting points, so two tasks on the same channel do not interfere. A run with nothing new ends successfully with no rows, and the run summary says `nothing_new`. A starting point moves forward only after a run has reached the previous one, so a run that was cut short does not make later runs skip posts.

### 📊 Output

A **Posts** run saves one row per post. A **Channels** run saves one row per channel. Both go to the run's dataset; open the **Output** tab for the views below, or read the API for every column.

| View | Mode | What it shows |
|---|---|---|
| Posts | Posts | Link, date, channel, text, views, edited and forwarded flags, reply link |
| Media | Posts | Photos, album flag, video, documents, stickers, link-preview cards |
| Engagement | Posts | Views, reactions, polls, the channel's subscriber count |
| Replies and forwards | Posts | Who a post replied to, where it was forwarded from, authors and signatures |
| Channels | Channels | Title, handle, status, subscribers and media counts, description |
| All fields | Both | Every column of every row |

**Columns of a post row** (the exact names are in the dataset schema):

| Group | Columns |
|---|---|
| Identity | `postKey` (`channel/id`, unique), `postId`, `channelUsername`, `url`, `date`, `scrapedAt` |
| Content | `text`, `textHtml`, `links`, `hashtags`, `mentions` |
| Reach | `views`, `viewsRaw`, `reactions`, `totalReactions` |
| Flags | `isEdited`, `isService`, `isForwarded`, `isAlbum` |
| Authorship | `authorName`, `signature`, `userPhotoUrl`, `viaBot` |
| Forwards | `forwardedFromName`, `forwardedFromUrl` |
| Replies | `replyToUrl`, `replyToId`, `replyToAuthor`, `replyToText`, `replyToThumb` |
| Media | `mediaTypes`, `photoUrls`, `videoUrl`, `videoThumb`, `videoDuration`, `videoDurationSec`, `documentTitle`, `documentSize`, `stickerUrl`, `mediaUnsupportedLabel` |
| Polls | `pollQuestion`, `pollType`, `pollOptions`, `pollVoters` |
| Link preview | `linkPreviewUrl`, `linkPreviewSite`, `linkPreviewTitle`, `linkPreviewDescription`, `linkPreviewImage` |
| Channel (on every post row) | `channelUrl`, `channelTitle`, `channelHandle`, `channelVerified`, `channelDescription`, `channelDescriptionHtml`, `channelAvatarUrl`, `channelCounters`, `channelSubscribersApprox`, `channelPhotosCount`, `channelVideosCount`, `channelFilesCount`, `channelLinksCount` |

A **channel row** holds the channel columns above plus `channelStatus` (`ok` or `preview_disabled`), the exact `channelSubscribers`, and the profile page's `channelProfileTitle`, `channelProfileDescription` and `channelProfileImage`. That is the only place the exact subscriber count appears: post rows carry the rounded count Telegram shows next to the posts.

Two things to know about the numbers. Telegram rounds large counts in its preview, so `views`, reaction counts and `channelSubscribersApprox` are approximate above a thousand (`viewsRaw` keeps Telegram's own text, such as `4.79M`). And photo, video and sticker URLs expire soon after the run, so download the files you need promptly.

#### The run summary

Every run saves a `OUTPUT` record in the key-value store (Output tab, **Run summary**) with one entry per channel: its outcome (`ok`, `no_match`, `nothing_new`, `preview_disabled`, `not_found`, `blocked`, `failed`, or `not_read` when a limit or the run timeout stopped the run before that channel was read), the posts and pages read, and what stopped the crawl. The run's final status message names the same outcome and the counts.

### 🤖 Use it from code or from an AI agent

Call it with the Apify API or client:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("dataizi/telegram-channel-scraper").call(run_input={
    "channels": ["telegram"],
    "maxPostsPerChannel": 50,
})
for post in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(post["date"], post["views"], post["url"])
```

Or with one HTTP request that runs the actor and returns the rows:

```bash
curl -X POST "https://api.apify.com/v2/acts/dataizi~telegram-channel-scraper/run-sync-get-dataset-items" \
  -H "Authorization: Bearer <YOUR_API_TOKEN>" \
  -H "Content-Type: application/json" \
  -d '{"channels":["telegram"],"maxPostsPerChannel":20}'
```

AI agents can call it through the [Apify MCP server](https://mcp.apify.com): the input form and the output schema describe every field, so an agent can pick the right columns without extra instructions. Add this to your MCP client's configuration; the client signs in to Apify the first time you use it:

```json
{"mcpServers": {"apify": {"url": "https://mcp.apify.com?tools=dataizi/telegram-channel-scraper"}}}
```

Prompts you can give the agent:

- "Get the latest 50 posts of the Telegram channel @telegram with their dates and links."
- "List the posts of @durov published between 2026-10-01 and 2026-10-31, with their views and reactions."
- "Find the posts in the Telegram channel @telegram that mention stories, searching inside that channel."

Beyond a single run:

- **Tasks:** save your input as a task to run it again with one click or one API call.
- **Schedules:** put the task on a schedule, with **New posts since the last run** switched on, to collect each new post.
- **Webhooks:** call your own URL when a run finishes or fails.
- **Integrations:** send the rows to Google Sheets, Make, Zapier or n8n through Apify's own integrations.

### 💸 Pricing

You pay per result. **$0.42 per 1,000 rows** on the Free plan and **from $0.22 per 1,000 rows** on higher plans: higher Apify plans pay less per row. One row is one post in **Posts** mode, or one channel in **Channels** mode. Platform usage is included in that price.

- You are billed for the rows saved, not for the pages read. A run that saves no rows costs nothing in results.
- A run that is stopped by your spending limit, your row limit or its timeout keeps and bills the rows it saved. A run that fails after saving rows keeps and bills them too, and its final message says so.
- Set **Maximum rows in total** or the run's spending limit to cap a run, especially with **Posts per channel** at `0`.

### ⚠️ Limitations

- **Public channels only.** Private channels, groups, chats, users and bots are not supported. A name that turns out to be one of them returns a `preview_disabled` channel row in **Channels** mode and nothing in **Posts** mode.
- **No comments.** The actor reads a channel's post feed and does not collect comments or discussion threads. You get reply links between posts, not the replies a post received.
- **No search across all of Telegram.** The text search works inside the channels you list. To find channels by keyword, look them up first and paste them in.
- **Views are rounded by Telegram.** Counts above a thousand are approximate, in `views`, reactions and the subscriber count on post rows.
- **Not in the preview, so not in the data:** the time of an edit, a pinned flag and per-option poll vote counts (you get percentages).
- **No voice messages or round videos.** The actor does not extract them.
- **Media are links, not files.** The actor does not download photos or video, and Telegram's media URLs expire soon after the run.
- **Channels with the preview switched off** return no posts in **Posts** mode. Use **Channels** mode to get their profile.
- **Post filters do not apply in Channels mode.** Dates, search and "new since the last run" are ignored there.
- **Long backfills need time.** With **Posts per channel** at `0`, a very large channel can take longer than the default one-hour run timeout. Raise the timeout, or split the job by date range. A run that hits the timeout ends successfully with the rows it saved.
- **Residential and Google SERP proxy groups are refused**, and so are custom proxy URLs, before any request is made.

### ❓ FAQ

**Do I need a Telegram account or API key?** No. The actor reads the public web preview, which needs neither.

**Can it scrape a private channel or a group?** No. Only channels that have a public preview at `t.me/s/<name>`.

**Can it get comments?** No. It reads the channel's posts, not the comments under them.

**Can I search Telegram by keyword?** Not across Telegram. You can search inside the channels you give it.

**Why do some posts have no text?** Many posts are only a photo, a video, a sticker or a poll. Their media and poll columns are filled instead, and `text` is empty.

**Why does a run return no rows?** The run summary says why: the channel has no posts, nothing matched your search or dates, nothing was new since the last run, the channel has no public preview, or the name does not exist.

**How do I get a channel's exact subscriber count?** Run in **Channels** mode.

**How do I stay inside a budget?** Set **Maximum rows in total**, or the run's maximum cost. The run stops cleanly and keeps what it saved.

### 🔒 Personal data

Channels and posts are public, and the actor outputs what the preview shows, including channel and author names, signatures, `@handles` and profile pictures. Post and channel text can contain names, phone numbers, e-mail addresses or links that their authors published.

**Include personal data** is on by default. Switch it off to set these 10 columns to empty (the columns stay): `authorName`, `signature`, `forwardedFromName`, `forwardedFromUrl`, `replyToAuthor`, `viaBot`, `userPhotoUrl`, `channelAvatarUrl`, `channelProfileTitle` and `channelProfileImage`. Post and description text stay in, because they can mention people anywhere, and so does `mentions`, the @usernames linked in that text.

You decide what to collect and why. If your data concerns people in the EU, you need a lawful basis under the GDPR for processing it, and you should delete it when you no longer need it. Telegram's Terms of Service and its content licensing terms restrict how its content may be scraped and used, including to train AI models. Read them, and use the data only in ways you are entitled to.

### Disclaimer

This is an unofficial tool. It is not affiliated with, endorsed by or sponsored by Telegram. "Telegram" and its icon belong to their owner and are used here only to identify the service the scraper reads. The actor reads public pages only and sends no data to Telegram.

# Changelog

This Actor's version history is a separate document: https://apify.com/dataizi-srl/telegram-channel-scraper/changelog.md

# Actor input Schema

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

Public Telegram channels to read, one per line. Write a username (`telegram`), an @handle (`@durov`) or a link (`https://t.me/telegram`). A link to one post (`https://t.me/telegram/123`) starts at that post and goes back in time. Public channels only: private channels, groups and users are not supported.

## `mode` (type: `string`):

Posts: one row per post, with the channel's title and counts on every row. Channels: one row per channel, with its exact subscriber count and profile details. The filters below are ignored in Channels mode. One run returns one kind of row.

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

How many of the newest posts to read from each channel. Enter 0 for no per-channel cap: the run then reads back to the channel's first post, or until a limit stops it (Maximum rows in total, your spending limit or the run timeout). Very large channels need a longer run timeout. Ignored in Channels mode, and when "New posts since the last run" has a saved starting point (the run then reads every newer post).

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

Stops the whole run after this many rows, across all channels. The default of 100 keeps a first run small; enter 0 for no total limit. Your spending limit still applies. Raise it, or enter 0, when you read many channels or many posts per channel.

## `oldestPostDate` (type: `string`):

Skip posts published before this date. Use a date such as `2026-10-01`, or a relative time such as `7 days`, `3 weeks`, `1 month` or `1 year`, counted back from the start of the run. Times are UTC. Ignored in Channels mode.

## `newestPostDate` (type: `string`):

Skip posts published after this date. A plain date includes that whole day, so `2026-10-01` to `2026-10-31` gives October. Relative times such as `3 weeks` work too. It must not be earlier than "Posts from this date". Ignored in Channels mode.

## `searchText` (type: `string`):

Return posts that match this word, phrase or hashtag (such as `#news`), using Telegram's own search inside each channel you listed. It searches those channels, not all of Telegram. Leave empty to read every post. Ignored in Channels mode.

## `onlyNewSinceLastRun` (type: `boolean`):

Remembers where each channel's last run stopped and returns just the newer posts next time. Use it in a saved task you run on a schedule: each task keeps its own starting points. The first run has no starting point, so it reads the latest posts up to "Posts per channel". The starting point moves forward only after a run has reached the previous one, so a run cut short does not make later runs skip posts. The date filters above still apply. A run with nothing new ends successfully with no rows. Ignored in Channels mode.

## `includePersonalData` (type: `boolean`):

On by default, because every field the preview shows is included. Untick it to set 10 person-level columns to empty (`null`): author and signature names, forwarded-from and replied-to names, the forwarded-from link, bot names, post authors' pictures, and channel pictures and profile titles. Post and description text stay in, since they can mention people. You are responsible for having a lawful basis (for example under the GDPR) for the data you collect.

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

Off by default. Switch on Apify Proxy if Telegram blocks your runs. Residential groups, Google SERP groups and custom proxy URLs are not supported: the run stops before reading anything.

## Actor input object example

```json
{
  "channels": [
    "telegram",
    "durov"
  ],
  "mode": "posts",
  "maxPostsPerChannel": 20,
  "maxItems": 100,
  "onlyNewSinceLastRun": false,
  "includePersonalData": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

## `overview` (type: `string`):

The posts, one row each.

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

Photos, video and link cards.

## `engagement` (type: `string`):

Views, reactions and polls.

## `threads` (type: `string`):

Reply and forward details.

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

Channel profiles (Channels mode).

## `all` (type: `string`):

Every column of every row.

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

What each channel returned, and what stopped the run.

# 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": [
        "telegram",
        "durov"
    ],
    "maxPostsPerChannel": 20,
    "maxItems": 100,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("dataizi-srl/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": [
        "telegram",
        "durov",
    ],
    "maxPostsPerChannel": 20,
    "maxItems": 100,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("dataizi-srl/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": [
    "telegram",
    "durov"
  ],
  "maxPostsPerChannel": 20,
  "maxItems": 100,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call dataizi-srl/telegram-channel-scraper --silent --output-dataset

```

## MCP server setup

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