# Telegram Channel Scraper: Posts, Views & Subscribers (`forgedata/telegram-channel-scraper`) Actor

Scrape posts, views, reactions, media and subscriber counts from public Telegram channels. No login, account or API key. Search within channels, filter by date, and pay $0.30 per 1,000 posts with media included. Export JSON, CSV or Excel.

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

## Pricing

from $0.21 / 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

Scrape posts, views, reactions, media and subscriber counts from any **public Telegram channel**. No Telegram account, no phone number, no API keys and no login. Paste channel names or t.me links and get clean JSON, CSV or Excel in seconds.

**$0.30 per 1,000 posts**, with media, reactions and channel stats included at no extra cost.

### What you get

For every post:

| Field | Example |
|---|---|
| `channel`, `channelTitle`, `channelSubscribers` | `durov`, `Pavel Durov`, `10200000` |
| `postId`, `postUrl` | `552`, `https://t.me/durov/552` |
| `date`, `edited` | `2026-10-11T14:52:40+00:00`, `false` |
| `text` | Full post text, line breaks kept |
| `views` | `1710000` |
| `reactions`, `reactionsTotal` | `[{ "emoji": "👍", "count": 16500 }]`, `36570` |
| `links`, `hashtags`, `mentions` | Every link, #tag and @mention in the post |
| `photos`, `videos`, `documents` | Image URLs, video URLs, thumbnails and durations, file names |
| `linkPreview` | URL, site name, title and description of the preview card |
| `forwardedFrom`, `replyTo` | Original source of forwarded posts, the post being replied to |
| `poll` | Question and options with vote percentages |
| `mediaType` | `text`, `photo`, `video`, `document` or `poll` |

Choose **Channel info only** to get one row per channel instead: title, description, subscribers, verified badge, avatar and counts of photos, videos, links and files.

### Why this scraper

- **Cheapest full-featured Telegram scraper in the Store.** $0.30 per 1,000 posts, no extra charge for media or channel info, and a start fee of just $0.00005 per run (others charge $0.005 to $0.01). Business plan users pay $0.21.
- **Fast.** Pages of the same channel load in parallel. A full channel history of 426 posts takes about 15 seconds.
- **No account needed.** Reads the public web preview pages Telegram publishes at t.me/s/channel for anyone to view in a browser. Your Telegram account is never involved and can't be banned.
- **Search inside channels.** Find only the posts that mention a keyword, brand or ticker.
- **Date filters.** Get only posts from the last N days, or since a date. The run stops as soon as older posts are reached, so you don't pay for them.
- **You only pay for results.** Private channels, typos and channels with preview turned off are skipped and never charged.

### How to use it

1. Add one or more channels. Any format works: `durov`, `@durov`, `t.me/durov`, `https://t.me/s/durov` or a post link like `https://t.me/durov/552`.
2. Set **Max posts per channel**. Newest posts come first.
3. Optional: add a search word, or limit by date.
4. Click **Start**, then download the results as JSON, CSV, Excel or HTML, or read them with the Apify API.

#### Example input

```json
{
  "channels": ["durov", "telegram", "https://t.me/cointelegraph"],
  "maxPostsPerChannel": 500,
  "postedWithinDays": 30
}
```

#### Example output

```json
{
  "type": "post",
  "channel": "durov",
  "channelTitle": "Pavel Durov",
  "channelSubscribers": 10200000,
  "postId": 552,
  "postUrl": "https://t.me/durov/552",
  "date": "2026-10-11T14:52:40+00:00",
  "author": "Pavel Durov",
  "text": "Designers × AI ...",
  "views": 1710000,
  "reactions": [{ "emoji": "star", "count": 7510 }, { "emoji": "custom", "count": 16500, "customEmojiId": "5265077361648368841" }],
  "reactionsTotal": 36570,
  "videos": [{ "url": null, "thumbnailUrl": "https://cdn4.telesco.pe/file/...", "duration": "1:15" }],
  "mediaType": "video"
}
```

### Use cases

- **Crypto and markets:** track announcement and signal channels, measure views and reactions per post, catch tickers and contract links as they appear.
- **News and media monitoring:** archive what news channels publish and when, with links back to every post.
- **Brand and competitor tracking:** search channels for your brand, product or competitor names.
- **Research:** build datasets of public posts for media studies, disinformation research or trend analysis.
- **Influencer and channel vetting:** compare subscribers, views per post and engagement before buying an ad placement.
- **AI and RAG pipelines:** feed fresh channel posts into your LLM or vector database through the API or MCP.

### Pricing

Pay per result. Prices per 1,000 posts (or channels in Channel info mode):

| Apify plan | Price per 1,000 |
|---|---|
| Free | $0.30 |
| Starter | $0.27 |
| Scale | $0.24 |
| Business | $0.21 |

Each run also has a tiny $0.00005 start fee. There's no charge for media, reactions or channel stats. Example: the last 100 posts from 10 channels cost about $0.30 on the Free plan.

### FAQ

**Do I need a Telegram account or API key?**
No. The scraper only reads Telegram's public web preview pages, the same pages anyone can open at `https://t.me/s/channelname` without logging in.

**Which channels can it read?**
Any public channel that has web preview turned on, which is the default for public channels. It can't read private channels, private groups, chats or direct messages, and it never tries to.

**Can it scrape group members or phone numbers?**
No. This scraper collects public channel posts and channel stats only. It doesn't collect member lists, phone numbers or any private data.

**How far back can it go?**
All the way to the first post, as long as the channel shows it publicly. Use the date filters to stop early.

**Why is a video URL sometimes empty?**
Telegram doesn't put large videos on the web preview page. You still get the thumbnail, duration and post link.

**How do I run it on a schedule?**
Save your input as a task, then add a schedule in Apify Console (for example every hour). Pair it with **Posted in the last N days** = 1 to only collect new posts.

**Can I use it from code or AI tools?**
Yes. Call it from the Apify API, the JavaScript or Python client, Make, Zapier, n8n, or as an MCP tool in Claude, Cursor and other AI agents.

### Is it legal to scrape Telegram?

This scraper reads only content that channel owners chose to publish publicly on the open web through Telegram's own preview pages. It doesn't log in, doesn't use Telegram accounts and doesn't collect personal data beyond what appears in public posts. You're responsible for how you use the data: respect copyright and applicable laws such as the GDPR, and don't use it for spam. If in doubt, ask a lawyer.

### More from Data Forge

- [Jobs Database](https://apify.com/forgedata/jobs-database): 1.2M+ jobs from 15,700+ employer career sites
- [Substack Scraper](https://apify.com/forgedata/substack-scraper): posts and newsletter stats from Substack
- [App Store Reviews Scraper](https://apify.com/forgedata/app-store-reviews-scraper): iOS app reviews in 100+ countries
- [Luma Events Scraper](https://apify.com/forgedata/luma-events-scraper): events, tickets and hosts by city

Questions or a feature request? Open an issue on the Issues tab and we'll get back to you fast.

# Actor input Schema

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

Public channel usernames or links, for example durov, @telegram or https://t.me/s/durov. Private channels and groups can't be read.

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

Posts: one row per post, with channel title and subscriber count on each row. Channel info only: one row per channel with subscribers, description and media counts.

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

Newest posts first. Telegram shows about 20 posts per page.

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

Optional. Only posts matching this word or phrase, using Telegram's own channel search.

## `postedWithinDays` (type: `integer`):

Optional. 0 means no date limit.

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

Optional. YYYY-MM-DD. Stops when older posts are reached.

## Actor input object example

```json
{
  "channels": [
    "durov",
    "telegram"
  ],
  "mode": "posts",
  "maxPostsPerChannel": 100,
  "postedWithinDays": 0
}
```

# Actor output Schema

## `results` (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"
    ],
    "maxPostsPerChannel": 100
};

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

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

```

## MCP server setup

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