# Telegram Channel Scraper - Posts, Views and Media (`kamerozkan/telegram-channel-scraper`) Actor

Scrape posts from public Telegram channels without login or API key: text, views, date, links, media, forwards and post URL. Many channels per run, full history paging and a date filter for monitoring.

- **URL**: https://apify.com/kamerozkan/telegram-channel-scraper.md
- **Developed by:** [Kamer Ozkan](https://apify.com/kamerozkan) (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.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 - Posts, Views and Media

Scrape **posts from public Telegram channels** as clean JSON, CSV or Excel: text, date, views, reactions, photos, videos, links, link previews, forwards and the post URL, plus the channel title and subscriber count. Many channels in one run, the full channel history page by page, and a date filter for daily monitoring. No login, no phone number, no API key.

### What does Telegram Channel Scraper do?

Give it one or more public channels (`durov`, `@telegram` or `https://t.me/telegram`). The actor reads Telegram's own public web preview of each channel (`t.me/s/<channel>`), newest posts first, and pages back through the history until it has the number of posts you asked for or reaches your date filter. Every post becomes one flat row.

It works with plain HTTP requests to public pages: no Telegram account, no session file, no bot token and no proxy setup on your side. A run with 100 posts usually finishes in under 20 seconds.

### Who is it for?

- **Media monitoring and PR teams**: follow news, brand and industry channels every day and get new posts in a sheet, Slack or a webhook.
- **Crypto and market research**: collect announcements and signals channels with views and reactions to measure attention.
- **OSINT and researchers**: archive the history of public channels with dates, forwards and links for analysis.
- **Marketers and channel owners**: benchmark competitor channels (posting frequency, views, reactions, media mix).
- **AI and data teams**: build text datasets from public channels for classification, summaries or RAG.

### What data can you get?

| Field | Example |
|---|---|
| `channel`, `channelTitle` | durov, Pavel Durov |
| `channelSubscribers`, `channelVerified` | 10400000, true |
| `channelDescription` | Founder of Telegram. |
| `postId`, `url` | 551, https://t.me/durov/551 |
| `date` | 2026-10-10T14:22:43+00:00 (UTC) |
| `text` | full post text, plain text with line breaks and emoji |
| `views`, `viewsText` | 1030000, 1.03M (Telegram rounds large counts) |
| `reactionsCount` | 112900 (sum of all reactions shown) |
| `edited` | true when Telegram marks the post as edited |
| `forwardedFrom`, `forwardedFromUrl` | Telegram Designers, https://t.me/designers/266 |
| `mediaTypes` | photo, video, document, audio, voice, poll, sticker, location |
| `photos`, `videos`, `videoThumbnails`, `videoDuration` | media URLs shown in the preview, 1:15 |
| `links`, `hashtags` | links and hashtags in the post text |
| `linkPreview` | url, siteName, title and description of the link card |

Empty values are `null` or `[]`. Media URLs are Telegram CDN links; they work for a limited time, so download the files soon if you need them.

### How much does it cost?

You pay per delivered post: **$0.60 per 1,000 posts** ($0.0006 per post) on the Free plan, with Store discounts on paid Apify plans: Bronze $0.54, Silver $0.51, Gold and above $0.48 per 1,000 posts. Platform usage is included; there is nothing else to buy.

Worked example: monitoring 10 channels every day with up to 20 new posts each = at most 200 posts a day = 200 x $0.0006 = **$0.12 per day**, about $3.60 a month. A one-time archive of 5,000 posts costs $3.00.

Set "Max posts per channel", "Max posts in total" or a maximum cost per run to cap spending.

### How to use it

1. Click **Try for free**.
2. Enter one or more **Channels**: a username, @username or a t.me link, one per line.
3. Set **Max posts per channel** (newest first; the actor pages back through the history as far as you ask).
4. Optional: set **Only posts newer than** to `2026-10-01` or `1 day` for monitoring.
5. Click **Start**, then download the posts as JSON, CSV or Excel, or read them through the API.
6. For daily monitoring, save the input as a task and add a schedule (Schedules > Create new) with **Only posts newer than** set to `1 day`.

### Input example

```json
{
  "channels": ["durov", "https://t.me/telegram"],
  "maxPostsPerChannel": 50,
  "onlyNewerThan": "30 days",
  "maxItems": 1000
}
```

### Output example

A row from a QA run on 2026-10-12 (channel `durov`), media URLs shortened:

```json
{
  "channel": "durov",
  "channelTitle": "Pavel Durov",
  "channelSubscribers": 10400000,
  "channelDescription": "Founder of Telegram.",
  "channelVerified": true,
  "postId": 548,
  "url": "https://t.me/durov/548",
  "date": "2026-09-11T16:04:02+00:00",
  "text": "🤝 Telegram has become the sponsor of Codeforces, the largest competitive programming platform in the world. ...",
  "views": 3150000,
  "viewsText": "3.15M",
  "edited": false,
  "forwardedFrom": null,
  "forwardedFromUrl": null,
  "mediaTypes": [],
  "photos": [],
  "videos": [],
  "videoThumbnails": [],
  "videoDuration": null,
  "links": ["https://codeforces.com/blog/entry/156620"],
  "hashtags": [],
  "linkPreview": {
    "url": "https://codeforces.com/blog/entry/156620",
    "siteName": "Codeforces",
    "title": "Telegram Returns as Title Sponsor of Codeforces!",
    "description": "Hi, Codeforces!"
  },
  "reactionsCount": 77930
}
```

### Integrations and API

Run it from your code with the Apify API or the `apify-client` package, schedule it in Apify, or connect it to Make, n8n, Zapier, Google Sheets, Slack or a webhook.

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_APIFY_TOKEN>")
run = client.actor("kamerozkan/telegram-channel-scraper").call(run_input={
    "channels": ["durov", "telegram"],
    "maxPostsPerChannel": 50,
    "onlyNewerThan": "7 days",
})
for post in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(post["date"], post["channel"], post["views"], post["text"][:80])
```

### FAQ

**Which channels work?** Public broadcast channels that have a web preview at `t.me/s/<channel>`. Groups, private channels, bots and personal accounts have no public preview and are skipped with a note in the log. Most large public channels have the preview turned on.

**How far back can I go?** As far as the channel's public history goes: the actor pages back 20 posts at a time until it reaches your limit or date filter.

**Why are views rounded?** Telegram itself shows large numbers rounded (1.03M, 662K). `viewsText` keeps Telegram's text, `views` is the number.

**What does a monitoring run return when nothing is new?** It finishes successfully with zero posts and the status "No new posts since the date filter", so a schedule never shows a failed run just because a channel was quiet. You pay only for posts delivered.

**Do I need a Telegram account or API key?** No. The actor reads only the public web pages anyone can open in a browser.

**Does it collect members or private messages?** No. It reads public channel posts only, never member lists, comments of users or private chats. You are responsible for how you use the data, including privacy and copyright rules such as GDPR.

### Support and feedback

- Found a bug or missing a field? Open an issue on the **Issues** tab of this Actor. We reply within
  48 hours and ship most fixes within a few days.
- Have an idea for a feature? Issues are the fastest way to get it built.
- If the Actor saves you time, a short review on this page helps other users find it.

# Actor input Schema

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

Public Telegram channels, one per line: the username (durov), @username or a link (https://t.me/telegram). Only public broadcast channels with a web preview work; groups and private chats do not.

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

Newest posts first. The actor pages back through the channel history until this many posts (or the date filter) is reached.

## `onlyNewerThan` (type: `string`):

Optional date filter for monitoring: a date such as 2026-10-01, a date and time in UTC, or a relative period such as 7 days or 12 hours. Leave empty for no filter.

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

Stop the whole run after this many posts. You are charged per delivered post, so this also caps the cost of the run.

## Actor input object example

```json
{
  "channels": [
    "telegram",
    "durov"
  ],
  "maxPostsPerChannel": 20,
  "maxItems": 1000
}
```

# Actor output Schema

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

One row per result 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
};

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

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

```

## MCP server setup

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