# Telegram Channel Scraper | Posts, Stats & New-Post Monitor (`zrk1212/telegram-channel-scraper-stats`) Actor

Scrape posts, views, reactions, media and comment counts from any public Telegram channel, plus exact subscriber counts and channel stats. Only-new-posts mode for schedules. No login or API key.

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

## Pricing

from $0.60 / 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.

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

Export posts, views, reactions, media and exact subscriber counts from any public Telegram channel, with an only-new-posts mode built for schedules. No login, no API key, no phone number.

### What does it do?

- **Posts with honest numbers.** Text, date, views, reactions (including paid Telegram Stars), media links, link previews, replies and forwards from public channels. Views and reactions come as integers plus the raw string Telegram shows and an "approximate" flag.
- **One stats row per channel.** Exact subscribers, posts per day, median and average views, view to subscriber ratio, median reactions, media share, top hashtags and domains, last post time.
- **Only-new-posts monitor.** Turn on one switch and every scheduled run returns just the posts published since the last run. The memory lives in your own Apify account, so there is no cursor to manage. Channels with nothing new cost nothing.
- **Crypto and link extraction.** Cashtags (`$BTC`), EVM contract addresses, Solana address candidates, outbound domains, Telegram links, hashtags and mentions on every post.
- **Filters that save money.** Date range, Telegram's own in-channel search, include and exclude keywords, media only. Posts that are filtered out are never charged.

### Who is it for?

- Crypto traders and signal aggregators who need cashtags and contract addresses from alpha and whale channels.
- Newsrooms and media monitors tracking public announcement channels.
- Brand and reputation teams searching channels for mentions.
- Telegram ad buyers vetting reach: exact subscribers, posts per day and view to subscriber ratio.
- Researchers and OSINT analysts archiving public channels.
- Agencies building n8n, Make or Zapier alert pipelines.

### What data do you get?

Subscribers are exact. Views and reactions are rounded by Telegram on its public pages (for example `4.44M`), so you get both the integer and the raw string, with a `viewsIsApproximate` flag.

#### Post rows (`type: "post"`)

| Field | Example |
|---|---|
| `id` | `whale_alert_io/105006` |
| `channelUsername`, `channelTitle` | `whale_alert_io`, `Whale Alert` |
| `channelId`, `botApiChatId` | `1006503122`, `-1001006503122` |
| `postId`, `url`, `date` | `105006`, `https://t.me/whale_alert_io/105006`, `2026-11-18T18:26:29.000Z` |
| `text`, `textHtml` (optional) | plain text of the post |
| `views`, `viewsRaw`, `viewsIsApproximate` | `1900`, `1.9K`, `true` |
| `reactions`, `reactionsTotal`, `paidStars` | emoji, custom emoji id, count per reaction |
| `media` | photo, video, document, poll and more, with CDN links, thumbnails and durations |
| `linkPreview`, `links`, `outboundDomains` | site name, title, description, image, domains |
| `cashtags`, `hashtags`, `mentions`, `telegramLinks` | `["USDT"]`, `["Bitfinex"]` |
| `evmAddresses`, `solanaAddresses` | contract address candidates found in text and links |
| `isForwarded`, `forwardedFromChannel`, `replyToPostId` | forward and reply context (public channels only) |
| `commentCount`, `comments` | optional, text and date only |

#### Channel rows (`type: "channel"`)

| Field | Example |
|---|---|
| `username`, `title`, `isVerified` | `durov`, `Pavel Durov`, `true` |
| `subscribers`, `subscribersRaw` | `9948688`, `9 948 688 subscribers` |
| `postsPerDay` | `0.3` |
| `medianViews`, `avgViews` | `4685000` |
| `viewSubscriberRatio` | `0.471` |
| `medianReactions`, `mediaShare` | share of posts with media |
| `topHashtags`, `topCashtags`, `topDomains` | most frequent in the sample |
| `latestPostId`, `lastPostAt` | `565`, `2026-11-18T17:42:19.000Z` |
| `photosCount`, `videosCount`, `linksCount`, `filesCount` | header counters |

Stats are computed from the posts fetched in the same run (views use posts at least 24 hours old when enough exist). Post ids are sequential, so `latestPostId` approximates the number of posts ever made, deleted ones included.

### How much does it cost?

You pay per result. The free plan's monthly credit lets you try it on thousands of posts.

| Item | Price per 1,000 | 100 | 1,000 | 10,000 |
|---|---|---|---|---|
| Post | $0.60 | $0.06 | $0.60 | $6.00 |
| Channel stats row | $1.50 | $0.15 | $1.50 | $15.00 |
| Comments add-on (per post that has comments) | $0.40 | $0.04 | $0.40 | $4.00 |

Example: a daily schedule watching 20 crypto channels that post 30 times a day costs about 600 posts x $0.0006 + 20 channel rows x $0.0015 = $0.39 per day.

Never charged: error rows, filtered-out posts, service messages, and in monitor mode channels with no new posts. In monitor mode a channel row is charged when the run returned at least one new post, and once on the first run for a monitor ID. For schedules more often than hourly, turn off `includeChannelStats` to pay for posts only.

### How to use it

1. Add channel usernames or links in **Channels** (`durov`, `@durov`, `https://t.me/durov`).
2. Choose **Max posts per channel**. Use 0 to get only the stats row.
3. Optional: set a date range, a search text, keywords or media only.
4. Click **Start** and open the **Output** tab. Views for posts, channels, crypto and errors are ready.

One-off export:

```json
{
  "channels": ["durov", "telegram", "whale_alert_io"],
  "maxPostsPerChannel": 50
}
```

Scheduled monitor (create an Apify Schedule, then connect a webhook, Slack or the Telegram integration):

```json
{
  "channels": ["whale_alert_io", "WatcherGuru"],
  "onlyNewPosts": true,
  "monitorId": "crypto-alerts",
  "maxPostsPerChannel": 100,
  "includeKeywords": ["bitcoin", "etf"]
}
```

The first run returns the latest posts and remembers where it stopped. Later runs return only newer posts, oldest first. Use a different `monitorId` for each schedule. To start over, change the `monitorId` or delete the key-value store named `telegram-channel-monitor` in your Apify account.

### Example output

A post:

```json
{
  "id": "whale_alert_io/105006",
  "type": "post",
  "channelUsername": "whale_alert_io",
  "postId": 105006,
  "url": "https://t.me/whale_alert_io/105006",
  "date": "2026-11-18T18:26:29.000Z",
  "text": "105,560,000 $USDT (105,483,877 USD) transferred from unknown wallet to #Bitfinex",
  "views": 1900,
  "viewsRaw": "1.9K",
  "viewsIsApproximate": true,
  "outboundDomains": ["whale-alert.io"],
  "hashtags": ["Bitfinex"],
  "cashtags": ["USDT"],
  "evmAddresses": [],
  "isServiceMessage": false
}
```

A channel row:

```json
{
  "id": "channel:durov",
  "type": "channel",
  "username": "durov",
  "title": "Pavel Durov",
  "isVerified": true,
  "subscribers": 9948688,
  "subscribersRaw": "9 948 688 subscribers",
  "postsPerDay": 0.3,
  "medianViews": 4685000,
  "viewSubscriberRatio": 0.471,
  "latestPostId": 565,
  "lastPostAt": "2026-11-18T17:42:19.000Z"
}
```

### Use it via API, MCP, n8n, Make, Zapier

```bash
curl -X POST "https://api.apify.com/v2/acts/Zrk1212~telegram-channel-scraper-stats/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"channels":["whale_alert_io"],"maxPostsPerChannel":20,"onlyNewPosts":true}'
```

The actor works with the Apify API, the Apify MCP server for AI agents, and the Apify integrations for n8n, Make and Zapier.

### Related actors

- [TikTok Transcript Scraper](https://apify.com/zrk1212/tiktok-transcript-scraper): social video transcripts.
- [Google Ads Transparency Ad Copy](https://apify.com/zrk1212/google-ads-transparency-ad-copy): competitor ad monitoring.

### FAQ

**Do I need a Telegram account, API id or phone number?** No.

**How does only-new-posts work, and how do I reset it?** A key-value store named `telegram-channel-monitor` in your own Apify account keeps the last processed post id per `monitorId` and channel. Delete the store or change `monitorId` to start over. The first run for a monitor ID returns the latest posts. If more than your max arrive between runs, you get the newest ones and a log warning.

**Why are views like 453,000 and not exact?** Telegram's public pages round them. You get the integer, the raw string and a flag. Subscribers are exact.

**Can it scrape groups, members, private channels or search all of Telegram?** No. Those need a logged-in account, which this actor never uses. Public groups return a clear message, plus an info row (members, online) when channel stats are on. Search works inside each channel you list.

**Why don't comments show who wrote them?** Privacy by design. Only the comment text, date and count are returned, and only the latest comments that the public widget shows. Forwards from private users are not identified either.

**How far back can I go?** The full public history, 20 posts per page. Use `dateFrom` to stop early. Very old date ranges on large channels read many pages, so cost and time grow.

**Do media links expire?** Video links carry a token and can expire. Download files promptly.

**Are Solana addresses reliable?** They are candidates found by pattern. Treat them as leads, not proof.

**Is it legal?** The actor reads only public, logged-out pages that Telegram publishes for previews and embedding. Telegram's terms restrict scraping and forbid using its data to train AI models. Use the data for monitoring and research, and you are responsible for lawful use.

**Something broke?** Open an Issue on the actor page. Issues are answered within 24 hours.

# Changelog

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

# Actor input Schema

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

Public channel usernames or links. Accepted: durov, @durov, https://t.me/durov, t.me/s/durov, https://t.me/durov/565 (a post link selects its channel), telegram.me/durov. Private invite links (t.me/+..., t.me/joinchat/...) are not supported. Max 1,000 entries.

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

Max posts saved per channel (after filters). Set 0 to get the channel stats row only.

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

Returns only posts newer than the last run with the same monitor ID. The first run returns the latest posts (up to the max) and remembers where it stopped. Ideal for schedules.

## `monitorId` (type: `string`):

Name of the memory used by only-new-posts mode. Use different names for different schedules. Letters, digits and hyphens, max 40 characters.

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

Telegram's own in-channel search. Returns only posts matching this text in each channel. Fast because Telegram filters on its side.

## `includeKeywords` (type: `array`):

Keep only posts whose text contains at least one of these words (case-insensitive).

## `excludeKeywords` (type: `array`):

Drop posts whose text contains any of these words (case-insensitive).

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

Only posts published on or after this date, for example 2026-11-01 or 7 days. Paging stops once older posts are reached.

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

Only posts published on or before this date, for example 2026-11-15 or 1 day. A plain date includes the whole day (UTC).

## `onlyWithMedia` (type: `boolean`):

Keep only posts with a photo, video, document or other media.

## `includeChannelStats` (type: `boolean`):

Add one stats row per channel (exact subscribers, posts per day, median views, view to subscriber ratio). Charged per channel row.

## `includeComments` (type: `boolean`):

For channels with public comments: add the comment count and the latest comments (text and date only, never names or usernames). One extra request per post. Charged only for posts that have at least one comment.

## `includeServiceMessages` (type: `boolean`):

Include service posts such as 'pinned a video'. These rows are free.

## `includeTextHtml` (type: `boolean`):

Also return the post text as HTML (bold, links, emoji).

## `maxPagesPerChannel` (type: `integer`):

Safety cap on pages read per channel (up to 20 posts per page). Matters with narrow keyword filters or old date ranges. It never limits an unfiltered request: the actor always allows enough pages for the max posts.

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

Not needed normally. Turn on Apify Proxy if you see rate-limit errors.

## Actor input object example

```json
{
  "channels": [
    "durov",
    "telegram",
    "whale_alert_io"
  ],
  "maxPostsPerChannel": 50,
  "onlyNewPosts": false,
  "monitorId": "default",
  "onlyWithMedia": false,
  "includeChannelStats": true,
  "includeComments": false,
  "includeServiceMessages": false,
  "includeTextHtml": false,
  "maxPagesPerChannel": 300,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

No description

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

No description

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

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("zrk1212/telegram-channel-scraper-stats").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",
        "whale_alert_io",
    ],
    "maxPostsPerChannel": 50,
}

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,zrk1212/telegram-channel-scraper-stats"
        }
    }
}
```

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/OEb4tgMtgt3vlJuRH/builds/5Ga1oZGLp0fbR4KSm/openapi.json
