# Telegram Channel Scraper (Posts, Views, Reactions) (`juliob.rangel/telegram-channel-scraper-fast`) Actor

Scrape posts from any public Telegram channel without login or API keys: text, date, views, reactions, photos, videos, links and forwards, plus channel title, subscribers and description. Full history with pagination. Export to Excel, CSV or JSON.

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

## Pricing

from $0.70 / 1,000 post scrapeds

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)

Telegram Channel Scraper collects posts from public Telegram channels with no login, no phone number and no API keys: text, date, views, reactions, photos, videos, links and forwards, plus the channel's title, subscriber count and description on every row. It is made for marketers, researchers, journalists, crypto and news watchers who need a Telegram channel scraper to export Telegram posts to Excel, CSV or JSON. It pages back through the channel history, so you can export thousands of posts per channel.

### What does Telegram Channel Scraper do?

You give it channel usernames or links. For each channel, the scraper reads the channel's public web preview (the page at `t.me/s/<channel>`) and pages back from the newest post until it reaches your limit, your start date or the first post of the channel.

It accepts:

- Usernames: `durov`
- Usernames with @: `@telegram`
- Channel links: `https://t.me/durov` or `https://t.me/s/durov`
- Post links: `https://t.me/durov/529` (the scraper reads the whole channel `durov`)

Each post becomes one row with the post text (line breaks kept), date, view count, reactions, media links and forward source. The channel's title, username, subscriber count, description and verified badge are repeated on every row, so the table is ready to filter and sort.

### What data can you extract?

| Field | What it means | Example |
|---|---|---|
| `channel` | Channel username you entered | `durov` |
| `channelTitle` | Channel name | `Pavel Durov` |
| `channelUsername` | Channel username as Telegram shows it | `durov` |
| `subscribers` | Subscriber count shown on the preview page | `10400000` |
| `channelDescription` | Channel description | `Founder of Telegram.` |
| `channelVerified` | `true` when the channel has the verified badge | `true` |
| `postId` | Post number inside the channel | `548` |
| `url` | Link to the post | `https://t.me/durov/548` |
| `text` | Post text with line breaks (empty for posts with no text) | `🤝 Telegram has become the sponsor of Codeforces…` |
| `date` | Post date and time (ISO 8601) | `2026-09-11T16:04:02+00:00` |
| `views` | View count | `2800000` |
| `author` | Signature of the author, when the channel signs posts | `Pavel Durov` |
| `forwardedFrom` | Name of the source when the post is a forward | `null` |
| `isEdited` | `true` when the post was edited | `false` |
| `photos` | Image URLs in the post | `[]` |
| `video` | Video URL in the post | `https://cdn4.telesco.pe/file/f4b10a0c75.mp4?token=…` |
| `hasDocument` | `true` when a file is attached | `false` |
| `links` | Web links inside the post text | `["https://codeforces.com/blog/entry/156620"]` |
| `reactions` | List of reactions with `emoji` and `count` | `[{"emoji": "paid-stars", "count": 21800}]` |
| `totalReactions` | Sum of all reaction counts | `77090` |
| `scrapedAt` | When the post was scraped (ISO 8601) | `2026-10-10T20:31:49.377Z` |
| `error` | Only on error rows: why no posts came back | `Channel not found or has no public preview` |

About `reactions`: each item has `emoji` and `count`. `emoji` is the emoji itself for standard reactions, `custom:<id>` for custom emoji reactions, and `paid-stars` for paid Telegram Stars reactions.

### How to use Telegram Channel Scraper

1. Open Telegram Channel Scraper in Apify Console.
2. Add channels to **Channels**, one per line (`durov`, `@telegram`, `https://t.me/durov`).
3. Set **Max posts per channel** (default 100). Use a high number for the full history.
4. Optional: pick a date in **Only posts newer than** to get only recent posts.
5. Click **Start** and wait for the run to finish.
6. Open the **Output** tab and export the posts as JSON, CSV, Excel or HTML.

To monitor channels, save the input as a task with a start date and schedule it daily.

### Input

| Field | Type | Default | What it does |
|---|---|---|---|
| `channels` | list of text (required) | `["durov"]` | Public channel usernames or links, for example `durov`, `@telegram` or `https://t.me/durov`. |
| `maxPostsPerChannel` | integer | `100` | Maximum posts per channel, newest first. From 1 to 100,000. The scraper pages back through the history until this limit. |
| `onlyPostsNewerThan` | date (YYYY-MM-DD) | empty | Only returns posts from this date on. The scraper stops when it reaches older posts. |
| `proxy` | object | `{ "useApifyProxy": true }` | Apify Proxy settings. The default works for most runs. |

Example input:

```json
{
  "channels": ["durov", "@telegram", "https://t.me/contest"],
  "maxPostsPerChannel": 500,
  "onlyPostsNewerThan": "2026-01-01",
  "proxy": { "useApifyProxy": true }
}
```

### Output example

One real post from a recent run:

```json
{
  "channel": "durov",
  "channelTitle": "Pavel Durov",
  "channelUsername": "durov",
  "subscribers": 10400000,
  "channelDescription": "Founder of Telegram.",
  "channelVerified": true,
  "postId": 548,
  "url": "https://t.me/durov/548",
  "text": "🤝 Telegram has become the sponsor of Codeforces — the largest competitive programming platform in the world. \n\n ⚡CodeForces organizes over 100 coding contests every year and has 4 million contestants signed up.…",
  "date": "2026-09-11T16:04:02+00:00",
  "views": 2800000,
  "author": "Pavel Durov",
  "forwardedFrom": null,
  "isEdited": false,
  "photos": [],
  "video": null,
  "hasDocument": false,
  "links": ["https://codeforces.com/blog/entry/156620"],
  "reactions": [
    { "emoji": "paid-stars", "count": 21800 },
    { "emoji": "custom:5399847211989246390", "count": 35300 },
    { "emoji": "custom:5936157098181135162", "count": 10300 },
    { "emoji": "custom:5373223594484587136", "count": 9690 }
  ],
  "totalReactions": 77090,
  "scrapedAt": "2026-10-10T20:31:49.377Z"
}
```

### How much does it cost?

Telegram Channel Scraper uses pay-per-event pricing. You pay **$1.00 per 1,000 posts** ($0.001 per post) on the Free plan. Apify platform usage is included in the price.

| Plan | Price per 1,000 posts |
|---|---|
| Free | $1.00 |
| Bronze (-10%) | $0.90 |
| Silver (-20%) | $0.80 |
| Gold and higher (-30%) | $0.70 |

Worked examples on the Free plan:

- The latest 100 posts of one channel = **$0.10**
- 10 channels, 1,000 posts each = 10,000 posts = **$10.00**
- The full history of a channel with 50,000 posts = **$50.00**

What you are not charged for:

- Error rows: channels that do not exist, private channels, groups and user accounts with no public preview, and channels where no posts were found.
- Posts skipped by the **Only posts newer than** date.
- Duplicate posts: a post seen twice while paging the same channel is returned once.

### Use cases

- **News and crypto monitoring**: follow announcement channels every day and alert your team about new posts.
- **Engagement analysis**: compare views and reactions per post to see which content performs best.
- **Ad placement research**: check subscribers against real post views before you buy an ad in a channel.
- **Competitor tracking**: archive what competing brands post and how often.
- **Media and academic research**: export a channel's full history for content, sentiment or narrative analysis.
- **Link and source tracking**: use `links` and `forwardedFrom` to see what a channel shares and which channels it forwards from.
- **AI datasets**: feed post text to summaries, classifiers or a searchable archive.

### Tips and limits

- **Public channels only**: the scraper works for channels with a public web preview at `t.me/s/<channel>`. Private channels, groups and user accounts have no preview and return an error row.
- **Counts are rounded**: Telegram's web preview shows numbers like `2.8M` or `55.9K`, and the scraper turns them into `2800000` and `55900`. Views, subscribers and reaction counts are therefore approximate for large numbers.
- **Paid stars count in the total**: `totalReactions` adds up every reaction, including `paid-stars`.
- **Custom emoji**: custom emoji reactions come as `custom:<id>` because the preview does not show them as normal emoji.
- **Media links are temporary**: `video` and `photos` URLs point to Telegram's servers and can stop working after a while. Download the files soon if you need to keep them.
- **Date filter**: posts are read newest first and paging stops at the first post older than your date.
- **Links**: use usernames or `t.me` links. Other link formats are not recognized.
- **Enter each channel once**: duplicates are not merged, so `durov` and `https://t.me/durov` in the same run scrape (and charge) the channel twice.
- **Error rows**: `Channel not found or has no public preview` means the channel does not exist or is not public; `No posts found` means the channel loaded but no posts came back (for example, none newer than your date). Both are free.

### Use it from the API, Python or JavaScript

You can run the scraper and read the posts with the official Apify clients. Replace `YOUR_TOKEN` with your Apify API token.

JavaScript (Node.js):

```javascript
const { ApifyClient } = require('apify-client');

const client = new ApifyClient({ token: 'YOUR_TOKEN' });
const input = { channels: ['durov'], maxPostsPerChannel: 200 };

const run = await client.actor('juliob.rangel/telegram-channel-scraper-fast').call(input);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

Python:

```python
from apify_client import ApifyClient

client = ApifyClient('YOUR_TOKEN')
input = {'channels': ['durov'], 'maxPostsPerChannel': 200}

run = client.actor('juliob.rangel/telegram-channel-scraper-fast').call(run_input=input)
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

The scraper also works with Make, Zapier and n8n, can export results to Google Sheets, can call your webhook when a run finishes, and can be used by AI agents through the Apify MCP server.

### FAQ

**Do I need a Telegram account, phone number or API key?**
No. The scraper reads the public web preview of each channel. You do not need a Telegram account or the Telegram API.

**Can I export Telegram posts to Excel or CSV?**
Yes. Open the Output tab after the run and download the dataset as Excel, CSV, JSON or HTML, or send it to Google Sheets.

**How many posts can I get?**
Up to 100,000 per channel in one run, limited by how many posts the channel has.

**Can I scrape Telegram groups or private channels?**
No. Only public channels with a web preview work. Groups, private channels and user accounts return an error row and are not charged.

**Can I get the comments under channel posts?**
No. The scraper returns the posts, their views and their reactions, not the comments.

**Is it legal to scrape Telegram channels?**
The scraper only collects publicly available data. You are responsible for complying with Telegram's terms and with privacy laws such as GDPR and LGPD. Posts can contain personal data, such as author signatures or names in the text, so you need a legitimate reason to collect and use it.

**Why did I get an error row?**
The channel does not exist, is not public, or no posts were found (for example, none after your start date). Error rows are not charged.

### Related scrapers

- [Threads Scraper (Profiles, Posts, Search)](https://apify.com/juliob.rangel/threads-scraper-fast)
- [Substack Scraper (Posts, Likes, Comments, Full Text)](https://apify.com/juliob.rangel/substack-scraper-fast)
- [Instagram Posts Scraper (Reels, Likes, Views, Captions)](https://apify.com/juliob.rangel/instagram-posts-scraper-fast)
- [YouTube Channel Videos Scraper (Fast & Cheap)](https://apify.com/juliob.rangel/youtube-channel-videos)
- [Google News Scraper (Real Article URLs)](https://apify.com/juliob.rangel/google-news-scraper-fast)

***

## Extrator de Canais do Telegram (PT-BR)

Colete posts de canais públicos do Telegram sem login nem chave de API: texto, data, visualizações, reações, fotos, vídeos e links, além do nome do canal e número de inscritos. Você paga só por post retornado.

# Actor input Schema

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

Public channel usernames or links, e.g. durov, @telegram or https://t.me/durov.

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

Newest posts first. The scraper pages back through the channel history until this limit.

## `onlyPostsNewerThan` (type: `string`):

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

## `proxy` (type: `object`):

Apify Proxy settings.

## Actor input object example

```json
{
  "channels": [
    "durov"
  ],
  "maxPostsPerChannel": 100,
  "proxy": {
    "useApifyProxy": true
  }
}
```

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

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

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

```

## MCP server setup

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

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/0lVaQHzdzte5qXg3H/builds/4AxSV2wLyfTcikMLx/openapi.json