# Telegram Channel Scraper - Posts, Views, Reactions & Search (`nexuscortex/telegram-channel-scraper`) Actor

Scrape public Telegram channels without login or API keys: posts, views, reactions, media, polls, forwards, replies, links and hashtags, plus in-channel keyword search, date ranges and exact subscriber counts.

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

## Pricing

from $0.64 / 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, Reactions & In-Channel Search (No Login)

Scrape **public Telegram channels** without a Telegram account, phone number, API ID or bot token. Paste channel usernames or `t.me` links and get one clean row per post: text, date, **view count**, **reactions with counts**, photos, videos, documents, polls, forwards, replies, link previews, links and hashtags. Add keywords to run Telegram's own **search inside each channel**, or give a date range and the Actor jumps straight to that part of the channel's history.

It reads Telegram's official public web preview (`t.me/s/<channel>`), the same page anyone can open in a browser. Nothing private is accessed.

### What you can scrape

| Input | What you get |
|---|---|
| Channel username or link (`durov`, `@telegram`, `https://t.me/s/tginfo`) | The channel's posts, newest first, plus an optional channel summary |
| Channel + keywords | Only posts matching each keyword or #hashtag, using Telegram's in-channel search |
| Channel + date range | Only posts published in that window; the Actor skips ahead without paying for newer posts |
| Post link (`https://t.me/durov/300`) | That single post |

#### Data for each post

- `text` (plain text, emoji kept) and optional `textHtml` with formatting
- `date`, `isEdited`, `authorSignature`
- `views` (number) and `viewsText` as Telegram shows it (`5.89M`)
- `reactions`: emoji, custom emoji ID, paid Telegram Stars, count, and `reactionsTotal`
- `media`: photos (URL, size), videos and GIFs (MP4 URL, thumbnail, duration), round videos, voice messages, documents (file name and size), audio (title and performer), stickers, locations
- `isUnsupportedOnWeb`: `true` for stories, giveaways, paid media and other posts Telegram only shows in its app (you still get the date, views and reactions)
- `poll`: question, type, options with percentages, voter count
- `forwardedFrom`: source channel and post, or the original author's name
- `replyTo`: the post it replies to, with a text snippet and quote flag
- `linkPreview`: URL, site name, title, description, image
- `links`, `hashtags`, `@mentions` written in the text, `inlineButtons`
- `channel`, `channelTitle`, `channelId`, `id`, `url`

#### Channel summary item (optional, on by default)

Title, description, **exact subscriber count** (e.g. `10088659`, not just `10.1M`), photo/video/file/link counters, verified badge, profile photo, numeric channel ID, latest post ID and date.

### Why this Telegram scraper

- **No login, no phone, no API keys.** Works from Telegram's public web preview, so there is no account to get banned.
- **Pay per result.** Posts removed by your filters are not charged.
- **Date ranges without waste.** "Only posts older than" jumps to that date with a binary search on post IDs, so getting March 2025 from a channel with 80,000 posts takes about 15 requests instead of thousands.
- **Monitoring-ready.** Pass the `lastPostId` from your previous run as `minPostId` to get only new posts. Schedule it hourly or daily.
- **Exact subscriber counts** and the numeric channel ID for joining with other data.
- **Rich media and engagement**: albums in display order, round videos, polls, paid Star reactions, custom emoji reactions.

### How to use it

1. Add one or more public channels in **Channels**.
2. Optionally add **Search inside these channels** keywords, a date window, or **Only posts after this post ID**.
3. Set **Posts per channel** and **Maximum results**.
4. Run. Download the dataset as JSON, CSV, Excel or HTML, or read it through the Apify API.

#### Example input

```json
{
    "channels": ["telegram", "durov", "https://t.me/s/tginfo"],
    "searchQueries": ["update"],
    "postsNewerThan": "30 days",
    "maxPostsPerChannel": 200,
    "maxItems": 1000
}
```

#### Example output (one post)

```json
{
    "type": "post",
    "channel": "durov",
    "channelTitle": "Pavel Durov",
    "channelId": 1006503122,
    "id": 531,
    "url": "https://t.me/durov/531",
    "date": "2026-07-16T20:45:25+00:00",
    "isEdited": false,
    "text": "🩵 Telegram now has a Rich Text Editor.\n\nIt supports tables, headings, inline media, lists, AI content, formulas, and more.",
    "views": 5890000,
    "viewsText": "5.89M",
    "forwardedFrom": null,
    "replyTo": null,
    "media": [{ "type": "gif", "url": "https://cdn4.telesco.pe/file/....mp4?token=...", "thumbnailUrl": "https://cdn4.telesco.pe/file/...", "durationSecs": null, "width": 1920 }],
    "poll": null,
    "isUnsupportedOnWeb": false,
    "linkPreview": null,
    "links": [],
    "hashtags": [],
    "mentions": [],
    "reactions": [
        { "emoji": "⭐", "customEmojiId": null, "isPaid": true, "count": 6300, "countText": "6.3K" },
        { "emoji": null, "customEmojiId": "5265077361648368841", "isPaid": false, "count": 54700, "countText": "54.7K" }
    ],
    "reactionsTotal": 95230,
    "inlineButtons": [],
    "mediaCount": 1,
    "scrapedAt": "2026-11-08T04:26:31.791Z"
}
```

### Pricing

Pay per result: **$0.80 per 1,000 results** ($0.0008 each). A result is one post or one channel summary saved to the dataset. Posts filtered out by your date window are not charged. Set a maximum cost per run in Apify Console and the Actor stops cleanly when it is reached. Each run also has Apify's standard start fee of $0.00005 ($0.05 per 1,000 runs), which covers the first seconds of compute. Apify subscribers pay less per result: 10% off on Bronze, 15% on Silver and 20% on Gold and higher plans.

### Use cases

- **Crypto and trading intelligence**: track token announcements, signal channels and project updates.
- **News and media monitoring**: archive breaking-news channels and measure reach with view counts.
- **Brand monitoring**: search for your brand or product inside the channels where your audience talks.
- **Competitor and influencer research**: compare posting frequency, views and reactions across channels.
- **Academic research and OSINT**: collect public discourse with timestamps and engagement.
- **AI and LLM pipelines**: feed clean post text into summarization, sentiment or RAG.

### Limits and notes

- Only **public channels** with Telegram's web preview enabled. Groups, private channels, invite links (`t.me/+...`), bots and user profiles have no public post history and are reported in the run's `SUMMARY` record instead of failing the run.
- Telegram has **no public search across all channels**. Keyword search runs inside the channels you list, using Telegram's own matching (it also matches word forms and link previews).
- `views` and reaction counts are rounded the way Telegram displays them (`5.89M`, `54.7K`).
- Media URLs are signed Telegram CDN links that expire after a while. Download files soon after the run if you need them. Videos over Telegram's web-preview size limit have no `url`; open the post in Telegram for those.
- Comments in linked discussion groups are not collected.

### Is it legal to scrape Telegram?

This Actor only reads pages Telegram publishes for anyone to view without logging in, and it does not collect phone numbers or other private contact details. Posts can still contain personal data, so make sure your use complies with the GDPR and other laws that apply to you. If unsure, ask a lawyer.

### FAQ

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

**How many posts can I get from one channel?** The full public history is available through the web preview. Large runs are limited only by your `maxItems` and budget.

**How fast is it?** About 1,300 posts per minute on the platform with several channels in parallel (2,000 posts from 8 channels took 93 seconds in our test).

**Can I get only new posts every day?** Yes. Use `postsNewerThan: "1 day"`, or store `lastPostId` from the channel summary and pass it as `minPostId` next time.

**Why did a channel fail?** See the `SUMMARY` record in the run's key-value store. Common reasons: the username is a group or user, the channel is private, or its owner turned off the web preview.

### Feedback

Found a bug or need a field? Open an issue in the Issues tab and we will look at it. If this Actor saved you time, a short review on this page helps other users find it.

### More scrapers from NexusCortex

- [Threads Search Scraper](https://apify.com/nexuscortex/threads-search-scraper): Threads posts and profiles by keyword, back in time
- [Threads Scraper](https://apify.com/nexuscortex/threads-scraper): posts, profiles and replies of Threads accounts
- [Google News Scraper](https://apify.com/nexuscortex/google-news-scraper): news articles by keyword or topic with publisher URLs
- [Pinterest Scraper](https://apify.com/nexuscortex/pinterest-scraper): pins, boards and profiles by keyword or URL

# Actor input Schema

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

Public Telegram channels, e.g. `durov`, `@telegram` or `https://t.me/s/tginfo`. Returns the newest posts of each channel first. Groups, private channels and invite links have no public web preview and are not supported.

## `searchQueries` (type: `array`):

Optional. Keywords or #hashtags to search for inside each channel above, using Telegram's built-in channel search. When set, only matching posts are returned. Telegram has no public search across all channels; this searches the channels you list.

## `postUrls` (type: `array`):

Optional. Links to individual posts, e.g. `https://t.me/durov/300`.

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

Maximum posts collected for each channel (for each channel and keyword in search mode).

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

Hard cap on the number of results (posts plus channel summaries) saved and charged in this run.

## `postsNewerThan` (type: `string`):

Optional. A date such as `2026-10-01` or a relative age such as `7 days` or `12 hours`. Paging stops as soon as older posts appear, so you only pay for the window you want.

## `postsOlderThan` (type: `string`):

Optional. A date such as `2025-12-31` or a relative age such as `30 days`. The Actor jumps straight to that point in the channel's history (binary search on post IDs) instead of paging through newer posts. Combine with "Only posts newer than" for a date range.

## `minPostId` (type: `integer`):

Optional, for monitoring. Stops when it reaches this post ID. Use the `lastPostId` from the channel summary of your previous run to get only new posts.

## `includeChannelInfo` (type: `boolean`):

Add one `channel` item per channel: title, description, exact subscriber count, photo/video/file/link counters, verified badge, channel ID and latest post ID. Counts as one result.

## `includeHtml` (type: `boolean`):

Also return the formatted post text as HTML (`textHtml`), keeping bold, italic, links and custom emoji.

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

Include service messages such as "Channel photo updated" or "Channel name was changed".

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

Apify Proxy spreads requests across IP addresses. The default datacenter proxy works for Telegram's web preview.

## Actor input object example

```json
{
  "channels": [
    "telegram",
    "durov"
  ],
  "maxPostsPerChannel": 20,
  "maxItems": 50,
  "includeChannelInfo": true,
  "includeHtml": false,
  "includeServiceMessages": false,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

All scraped posts and channel summaries in the default dataset.

# 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,
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

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

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

```

## MCP server setup

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