# Telegram Channel Scraper & Analyzer: Posts, Views, Insights (`zaiq/telegram-channel-scraper`) Actor

Any public Telegram channel without login: subscribers, and every post with text, views, reactions, date, links, photos and video. Optional AI report per channel: what it publishes (news, opinion, promotion), themes and sentiment, with post frequency, median views and top posts counted.

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

## Pricing

from $0.48 / 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 & Analyzer: posts, views and what a channel publishes (no login)

Get **any public Telegram channel's posts** without an account or API key: each post's **text, views, reactions, date, links, photos and video**, plus the channel's **subscribers**, media counts and description. As many posts as you want, newest first, or only those after a date.

Turn on the **insights report** and each channel also gets **what it publishes**: posts counted as **news, opinion, promotion or question**, the **themes**, the **sentiment**, **posts per day**, **median views**, **views per subscriber**, the **top posts** and the **domains it links to most**. Built for **crypto and market research, media monitoring, competitor and brand tracking** and **AI agents**.

### What you get

| Field | What it holds |
|---|---|
| Post rows | `text`, `views`, `reactions`, `date`, `author`, `forwardedFrom`, `photos`, `hasVideo`, `videoLength`, `links`, `edited`, `id`, `url`, `channel` |
| Channel row | `title`, `verified`, `subscribers`, `photos`, `videos`, `links`, `files`, `description`, `photo`, `postsRead` |
| Insights row (optional) | `summary`, `kinds` (news, opinion, promotion, question: counted), `themes` with counts, `sentiment`, `postsPerDay`, `averageViews`, `medianViews`, `viewsPerSubscriber`, `mediaShare`, `linkShare`, `topDomains`, `topPosts`, and the main points of each kind with example posts |
| SUMMARY | what each channel returned, notes and what was charged |

### What people use it for

- **Crypto and market research:** what the big channels push, and how many people see it
- **Media monitoring:** every post of the channels you follow, as a table
- **Competitor tracking:** a rival's announcements and promotions
- **Engagement benchmarks:** median views and views per subscriber, channel by channel
- **Link research:** the sites a channel sends its readers to
- **AI agents:** Telegram channels in any workflow

### How to use it

1. Add **channels**: usernames, @handles or t.me links.
2. Set **Posts per channel** (and **Only posts after** if you want).
3. Keep **Insights report** on, click **Start**, then open the **Posts** or **Insights** table.

### Input

| Field | Example | Notes |
|---|---|---|
| Channels | `telegram` | Usernames, @handles or t.me links |
| Posts per channel | `50` | Up to 5,000 |
| Only posts after | `2026-09-01` | Optional |
| Insights report | on | One report per channel |

### Output

Each result is one row in the run's dataset (download it as JSON, CSV, Excel, XML or HTML, or read it through the API). An example row (values shortened):

```json
{
  "kind": "post",
  "channel": "example_channel",
  "id": 460,
  "url": "https://t.me/example_channel/460",
  "text": "For all the info from today's update and a look back at 13 years of Telegram features — ch…",
  "views": 1930000,
  "date": "2026-08-26T19:12:34+00:00",
  "links": [
    "https://telegram.org/blog/welcome-messages-buttons-TG-13"
  ],
  "hasVideo": false
}
```

With insights on, each channel also gets one `insights` row. From runs on 17 October 2026 (45 posts each of two large channels, names removed): one posted 0.29 times a day with a median of 4.67 million views (0.45 views per subscriber), 32 news posts, 6 opinions, 3 promotions, themes "Product updates" 10 and "Crypto" 8; the other 0.16 a day, median 1.93 million views, 35 news posts and 10 promotions. A record named `SUMMARY` in the run's key-value store says what each channel returned and what was charged.

### Pricing

- **$0.0006 per post** ($0.60 per 1,000)
- **$0.03 per insights report** (one per channel, only when asked for; failed reports are free)
- Channel rows are free; private channels and groups (no web preview) cost nothing
- The AI model that writes the report (Google's Gemini Flash) is billed by Apify at its exact cost: about $0.01 a report on 50 to 150 posts (measured 17 October 2026); Apify charges free-plan accounts 10 times that

What typical jobs cost at the list price:

| Job | Cost |
|---|---|
| 100 posts of one channel | $0.06 |
| 100 posts with the insights report | $0.09 |
| 10 channels, 200 posts each, with reports | $1.50 |
| 1,000 posts | $0.60 |

On Apify's Scale and Business plans the per-event prices are lower (Store discounts). Set **Maximum cost per run** and the Actor stops cleanly when it is reached: you never pay more than that.

### Tips

- Use Only posts after for a daily or weekly schedule: you pay only for the new posts.
- Compare `viewsPerSubscriber` across channels: it shows which audiences are real.
- Read `topDomains` to see where a channel sends its readers.

### Use it through the API

**Python**

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("zaiq/telegram-channel-scraper").call(run_input={"channels": ["telegram"], "maxPostsPerChannel": 200})
for row in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(row)
```

**JavaScript**

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

const client = new ApifyClient({ token: '<YOUR_APIFY_TOKEN>' });
const run = await client.actor('zaiq/telegram-channel-scraper').call({"channels": ["telegram"], "maxPostsPerChannel": 200});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
```

**HTTP (one call, results back)**

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

### Integrations and schedules

- **Schedules:** run it every hour, day or week from the Apify Console (Schedules) and keep a history of results.
- **Make, Zapier, n8n, Google Sheets, Slack, Airtable:** connect it through Apify's integrations, or send each finished run to a **webhook**.
- **Datasets:** results stay in the run's dataset; export them or read them by API whenever you need them.

### Use it with AI agents (MCP)

Add Apify's MCP server (`https://mcp.apify.com`) to Claude, ChatGPT, Cursor, VS Code or any MCP client. The agent can find this Actor and run it for you: ask it for "get the last 200 posts of these Telegram channels and tell me what each one promotes". AI agents can also pay for runs directly through Apify's agentic payments.

### Limits

- Public channels only: private channels, groups and chats have no web preview and are not read.
- Comments under posts are not shown in Telegram's web preview.
- Reaction counts are summed (the emoji themselves are not listed).
- The report's counts come from the AI's label for each post: close, not perfect.

### FAQ

**Do I need a Telegram account or API key?**

No. The Actor reads Telegram's own public web preview (t.me/s/...), which anyone can open.

**How far back can I go?**

As far as the channel's history goes; set Posts per channel or Only posts after.

**Can it read groups?**

No, only public channels: groups have no web preview.

**Can I skip the report?**

Yes: turn Insights report off and pay only per post.

### Related Actors from Zaiq

- [wechat-articles-scraper](https://apify.com/zaiq/wechat-articles-scraper): WeChat Official Account articles with full text
- [threads-scraper](https://apify.com/zaiq/threads-scraper): Threads posts and replies with insights
- [youtube-comments-scraper](https://apify.com/zaiq/youtube-comments-scraper): YouTube comments with insights
- [google-news-scraper](https://apify.com/zaiq/google-news-scraper): Google News articles for any search

### Support

Questions, a site that changed, or a field you need? Open an issue on this Actor's **Issues** tab: we answer there, usually within a day.

***

Also found as: telegram scraper, telegram channel scraper, telegram posts scraper, telegram channel analytics, telegram views, telegram monitoring, crypto telegram channels, telegram api alternative.

# Actor input Schema

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

Public Telegram channel usernames, @handles or t.me links, one per line.

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

How many of each channel's latest posts ($0.0006 each).

## `postedAfter` (type: `string`):

Optional: stop at posts older than this date (YYYY-MM-DD).

## `insights` (type: `boolean`):

Add one report per channel: news, opinion and promotion counted from every post, themes, sentiment, posts a day, median views and top posts ($0.03 a channel; the AI model's own cost is billed by Apify, a fraction of a cent).

## `analysisLanguage` (type: `string`):

Posts are always kept as written.

## Actor input object example

```json
{
  "channels": [
    "telegram"
  ],
  "maxPostsPerChannel": 50,
  "insights": true,
  "analysisLanguage": "English"
}
```

# Actor output Schema

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

Dataset: the results.

## `summary` (type: `string`):

What each input returned, and notes.

# 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"
    ]
};

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

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

```

## MCP server setup

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