# Telegram Channel Scraper: Monitor Posts & Keyword Search (`fetchwright/telegram-channel-scraper`) Actor

Monitor public Telegram channels for new posts, or find channels by keyword through a web search: text, date, views, reactions, media, cashtags, Slack or Discord alerts. Input: channel names or keywords. No login. $0.30 per 1,000 posts on Free, $0.22 on Business.

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

## Pricing

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

### What does Telegram Channel Scraper do?

**Telegram Channel Scraper** reads the public Telegram channels you name and can watch them for new posts, or finds channels and posts by keyword through a web search (not Telegram's own search), **with no Telegram account, phone number or session to set up or lose**, for **$0.30 per 1,000 posts** on the Free plan ($0.22 to $0.27 on paid plans; keyword results are free for now). You give it channel names or links, or keywords. Get one row per post with its **text, date, views, photos, videos, files, polls, link cards and reactions**, where it was forwarded from and which post it replies to, plus **cashtags** ($BTC) and **engagement rates**, normally newest first within each channel (a watch catching up returns its pending older posts first), and one free row per channel with its **exact subscriber count** where Telegram shows it and its numeric channel ID where the page encodes it. For the channels you list, a named watch (one run at a time, settings unchanged) skips posts it has already returned, unless saving its memory failed, and can report subscriber, title and description changes. Hourly monitoring of 20 channels with about 200 new posts a day costs about **$1.84 a month** on the Free plan. Try the prefilled example: it returns the latest 20 posts of Telegram's own news channel.

**Built for** crypto and news desks that watch channels around the clock, traders and analysts tracking tickers and keywords, market researchers comparing channels in a niche, and developers and AI agents that need Telegram posts through an API.

[![Telegram Channel Scraper: posts from public Telegram channels as clean data, $0.30 per 1,000 posts on the Free plan](https://api.apify.com/v2/key-value-stores/CZmVHcscvBfufR57w/records/fw-tg-hero-v4.png)](https://console.apify.com/actors/SnsRmhv8v6cFTcLe4)

| What you get | Details |
| --- | --- |
| 📣 Read any public channel | `durov`, `@durov`, `https://t.me/durov` or a post link, all in one list |
| 🔎 Search inside channels | Only posts that contain a word, phrase or hashtag, or any of up to 20 keywords at once, each post returned once with the keywords it matched |
| 📈 Engagement and cashtags | Reactions per 1,000 views, views per subscriber, total reactions, and cashtags such as `$BTC` on every post; keep only posts about the tickers you follow, and get a per-channel count of every ticker mentioned |
| 📅 Limit by date | Posts newer than a date, from the last N days, or older than a date: any exact window such as "October only" |
| 🚫 Exclude noise | Skip posts that mention a giveaway, an ad or any word you list, and pay nothing for them |
| 🎬 Filter by content | Photos, videos, round video messages, files and audio, stickers, polls, links or text-only posts |
| 🆕 Get only new posts | For the channels you list, with one run of a watch at a time and its settings unchanged, a named watch skips posts it has already returned; a failed or interrupted save of its memory can repeat some, and a watch catching up returns its older posts first |
| 🔍 Find channels by keyword | Each keyword returns the public channels and posts web search has found for it, and the matching posts of the first channels found are read; a subscriber range keeps only channels and public groups of the size you want |
| 👁️ Minimum views | Leave out posts with fewer views or no view count; they are counted in the run summary and not charged, and an only-new watch does not look at them again when their views grow |
| 📈 Channel changes | With **Report channel changes** and **Include one row per channel** on a named watch: subscriber growth or loss, a new title or description, and a name now used by another channel, for the channels you list, at no charge |
| 🆔 Stable channel ID | The channel's numeric Telegram ID where the public page encodes it reliably, on post and channel rows; it stays the same when a channel renames itself |
| 🔔 Get an alert in Slack or Discord | Paste a webhook address and each run posts what it saved: posts per channel, the first three with text and link. With a keyword or cashtag filter this is a keyword alert. |
| 📊 Channel details | Title, description, subscribers, photo, video, file and link counts, verified badge, avatar |
| 🔗 Chain runs | Read channel names from another run's dataset |
| 💾 Export anywhere | JSON, CSV, Excel, or through the API |

No Telegram account, phone number or login is needed. The Actor reads only what Telegram shows to anyone on the web. Because it runs on Apify you can also **schedule** it, call it through the **API**, send results to Google Sheets or Slack, and use it from AI agents through **MCP**.

### Why choose Telegram Channel Scraper?

- **No Telegram account or session required.** Scrapers that sign in with a Telegram account can stop on session and rate-limit errors. This Actor signs in to nothing; a scheduled run depends only on Telegram continuing to show the channel and its posts on the web. The trade-off is scope: it reads public channels only, where an account-based tool can also reach private chats and comments the account is allowed to see.
- **Low price per post and per schedule.** $0.30 per 1,000 posts on the Free plan ($0.22 to $0.27 on paid plans) with platform usage included, less per post on the Free plan than the four channel scrapers compared below (Free-plan prices read 10 November 2026), and a scheduled run with no new posts costs only its start event of $0.00005 per GB of run memory (rounded up, at least one GB).
- **Cashtags and engagement rates** (reactions per 1,000 views, views per subscriber) on every post, which none of the compared listings offer.
- **Exact subscriber counts** in a free channel row, where Telegram shows them.
- **A new-posts-only mode for monitoring.** With one run of a watch at a time and its settings unchanged, it returns only posts the watch has not recorded as returned, and catches up on its own after a run that stopped early.
- **You pay per post saved, plus a start event of $0.00005 per GB of run memory per run.** Channels that cannot be read, filtered posts and failed requests are never charged.

### Find Telegram channels and posts by keyword

Don't know which channels to read? Add keywords under **Find channels by keyword**. For each keyword the Actor returns the public Telegram channels and posts that web search has found for it, one row per page with its **title, snippet, link, rank and the date shown**, and then, unless you turn it off, reads the **matching posts** of the first channels found (10 per keyword by default), with views, reactions, media and cashtags. Only public channels and their posts are returned, plus one free row for each public group found (its title, description and member count, never its members or messages); users, bots and channels without a public preview are listed in the run summary, not returned. Channels and keywords work together or alone.

| What you set | What you get |
| --- | --- |
| Find channels by keyword: `bitcoin etf`, `remote jobs` or `"chatgpt"` | One row per public Telegram channel or post found, ranked as the search ranked it |
| Search country and language, for example `US` and `en`, or `DE` and `de` | Results as searched from that country, favouring that language |
| Found pages from: any time, past day, week, month or year | The search engine's own time filter: results it dates to that period |
| Also read the matching posts (on by default) | For up to 10 channels per keyword, the posts that match the keyword in the channel's own search, as ordinary post rows marked with the keyword |
| Minimum / maximum subscribers, for example `1000` to `50000` | Only channels and public groups found inside that audience size; the others give no rows, cost nothing and are listed per keyword in the run summary |

**What it costs:** found pages are free for now. Posts read from the channels found are charged as posts, $0.30 per 1,000 on the Free plan. A channel found by keyword has its matching posts read once per run, and no channel gives more than **Maximum posts per channel** posts in the whole run. With the default settings one keyword can read up to 10 channels × 100 posts = 1,000 posts, at most $0.30 on the Free plan, and each further keyword can add as much again; turn off **Also read the matching posts** to get only the pages found, with no post charges. Keywords that find nothing and keywords that cannot be searched are listed in the results and never charged.

**About personal data:** a found page's title and snippet come from the web search and can contain names or other personal data, as posts can.

**What it covers:** web search shows only the Telegram pages a search engine has indexed. It is not a complete search of Telegram: a channel or post the search engine has not indexed is not found, and the same keyword can give different pages on another day or from another country. The `SUMMARY` record says this too, and lists per keyword the result pages read, results, channels found and read, posts saved and what stopped it.

### How much does it cost to scrape Telegram channels?

**$0.30 per 1,000 posts on the Free plan, $0.22 to $0.27 on paid plans.** You pay per post saved, platform usage is included, and there is no monthly rental.

| Your Apify plan | Price per 1,000 posts |
| --- | --- |
| Free | $0.30 |
| Starter (Bronze) | $0.27 |
| Scale (Silver) | $0.25 |
| Business (Gold) and above | $0.22 |

A run also costs a start event of $0.00005 per GB of run memory (rounded up, at least one GB). A scheduled run that finds no new posts costs only that start fee: measured on 10 November 2026, a new-posts-only run on 2 channels with nothing new was charged $0.00005 in total.

Keyword search: the Telegram pages found by keyword are free for now; the posts read from the channels found are charged as posts at the prices above.

**Never charged:** channel rows, rows for channels that could not be read (missing, private or not shown on the web), posts Telegram does not show on the web, channel events such as "Channel created", posts skipped by the content filter, posts outside your dates, with one run of a new-posts watch at a time, posts it has recorded as returned (two overlapping runs of the same watch, or a run killed before it saved its memory, can return and charge a post again), anything after a platform restart of the run, a row whose save could not be confirmed, failed requests, keywords that find nothing or cannot be searched, and Telegram pages found by keyword (free for now).

What typical jobs cost:

| Job | Posts | Cost on Free | Cost on Gold |
| --- | --- | --- | --- |
| Latest 100 posts of one channel | 100 | $0.03 | $0.022 |
| Ten channels, 1,000 posts each | 10,000 | $3.00 | $2.20 |
| Full archive of a busy channel | 50,000 | $15.00 | $11.00 |
| Hourly monitoring of 20 news channels, about 200 new posts a day (720 runs) | 6,000 a month | $1.84 a month ($1.80 posts + $0.04 start fees) | $1.36 a month |
| Hourly check of quiet channels, no new posts (720 runs) | 0 | $0.04 a month | $0.04 a month |
| 5 keywords, 20 found pages each, matching posts of 10 channels per keyword, at most 20 posts per channel | up to 1,000 (100 found pages free) | up to $0.30 | up to $0.22 |
| 1 keyword, 50 found pages, matching posts off | 0 (50 found pages free) | $0.00005 | $0.00005 |

Apify's free plan includes $5 of credit each month, which is about **16,000 posts** with this Actor.

Set **Maximum posts per channel** to cap a run. If you set a maximum charge for the run in Apify, the Actor stops when it is reached, keeps every saved post and never charges past it. The post that reaches your maximum is still delivered, without charge, and the `SUMMARY` record names it.

### How do I scrape a Telegram channel?

[![How to scrape a Telegram channel in three steps: name the channels, run or schedule, export to CSV, Excel, JSON or API](https://api.apify.com/v2/key-value-stores/CZmVHcscvBfufR57w/records/fw-tg-how-v2.png)](https://console.apify.com/actors/SnsRmhv8v6cFTcLe4)

1. [Create a free Apify account](https://console.apify.com/sign-up).
2. Open the Actor and add one or more channel names or links.
3. Optionally set a maximum, a search word, a date window, content types or words to exclude.
4. Click **Start**.
5. Download the results as CSV, Excel or JSON, or fetch them through the API.

**Run it on a schedule.** For monitoring, run it hourly or daily, with only new posts. Apify's short video shows how to set up a schedule:

https://www.youtube.com/watch?v=1jI7WcVQmwM

### ⬇️ Input for Telegram Channel Scraper

| Field | What it does |
| --- | --- |
| Channels | Names, @names, channel links or post links. Duplicates are removed. |
| Maximum posts per channel | Caps results and cost. Default 100, up to 100,000. |
| Only posts containing | Search text, applied inside each channel. |
| Only posts containing any of | Up to 20 keywords at once, such as `TON`, `Bitcoin ETF` and `#airdrop`. A post that matches several is returned and charged once, and `matchedKeywords` lists the ones it matched. |
| Posts newer than / Only the last N days | Start of the date window. Older posts are never returned or charged. |
| Posts older than | End of the date window, for example `2026-10-31` (that whole day is included). Newer posts are never returned or charged. |
| Content types | Photo, video, round video message, document or audio, sticker, poll, link, text-only. |
| Minimum views | Keep only posts with at least this many views as Telegram shows them; posts with fewer views or no view count are left out, counted as `belowMinViews` (per channel, and per keyword for channels found by keyword) and not charged. On an only-new watch a post left out is not returned later, even when its views grow. |
| Only the channel's own posts | Leave out posts forwarded from another channel or user (Telegram marks them "Forwarded from"); they are not saved or charged and are counted as `forwardedLeftOut` in the run summary. On an only-new watch a forwarded post left out is not returned later. |
| Only posts mentioning these cashtags | Tickers such as `BTC` and `NVDA`, with or without the `$`. Posts without them are skipped, never charged, and counted in the `SUMMARY` record. |
| Exclude posts containing | Words or phrases to skip, such as `giveaway` or `sponsored post`. Not case-sensitive; single words match whole words only. Skipped posts are never charged and are counted in the `SUMMARY` record. |
| Only posts not returned in earlier runs | New-posts-only mode for scheduled monitoring. Each saved task keeps its own memory. |
| Monitor name | Gives a watch its own memory. Set it for runs started through the API, which otherwise share one memory per channel, search text and content filter. A named monitor is shared by every task that uses the same name, so give each task its own name, or leave it empty in a saved task. |
| Report channel changes | With a **Monitor name** or in a saved task: each run compares every listed channel with the copy the watch kept at its last run, and reports subscriber growth or loss (number and percent), a new title or description (with the old text) and a name that now belongs to another channel. The changes are on the free channel row, in the run summary (`channelChanges`) and in the alert. In new-posts-only mode a channel that changed gets its channel row even when no post is new. Needs channel rows on; no extra charge. |
| Include one row per channel | One free row per channel with its details. On by default. |
| Post text format | Plain text only (default), or also each post's text with its formatting as HTML (`textHtml`) or Markdown (`textMarkdown`). No extra request or charge. |
| Read channels from a dataset | Take channel names or links from another run's dataset. |
| Channels read at once | How many channels are read in parallel. Default 5, up to 10. Each channel's posts stay newest first. |
| Find channels by keyword | Words or phrases to find Telegram channels and posts by, such as `bitcoin etf` or `"chatgpt"` (quotes keep a phrase together). Up to 100. Channels are optional when you set them. In the API the field is `findByKeyword`; an input field `keywords` given with no channel and no channel dataset is read the same way, while `keywords` given with channels keeps meaning words to search inside those channels. |
| Maximum results per keyword | Found pages per keyword. Default 20, up to 200; at most 50 while found pages are free. |
| Search country / Search language | Where the search is made from and the language it favours, for example `US` and `en`. `UK` is accepted for `GB`. |
| Found pages from | Any time (default), past day, week, month or year. |
| Also read the matching posts of each channel found | On by default. Searches each found channel for the keyword and saves the matching posts, charged as posts; once per run for each channel. Off: only the pages found, no post charges. |
| Channels read per keyword | Default 10, up to 50, in the order the search found them. |
| Minimum subscribers / Maximum subscribers | Keep only channels found by keyword with an audience inside this range (for public groups, their member count). A channel outside it gives no found page, post or channel row and is not charged; the run summary lists it under `outsideSubscriberRange` for the keyword. The range is compared with the exact count while channel rows are on, otherwise with the figure the channel's page shows (rounded above 1,000, as in 632K). A channel whose count is not shown is left out. Channels you list by name are always read. |

```json
{
    "channels": ["durov", "https://t.me/telegram"],
    "maxPostsPerChannel": 500,
    "lastDays": 30,
    "mediaTypes": ["video", "photo"],
    "excludeKeywords": ["giveaway", "sponsored post"],
    "onlyNewPosts": true
}
```

A keyword search, with or without channels:

```json
{
    "findByKeyword": ["bitcoin etf", "remote jobs"],
    "keywordCountry": "US",
    "keywordLanguage": "en",
    "keywordFreshness": "month",
    "maxResultsPerKeyword": 20,
    "maxChannelsPerKeyword": 5,
    "maxPostsPerChannel": 20
}
```

### ⬆️ Output from Telegram Channel Scraper

[![Telegram Channel Scraper output table: post number, date, text, media type and views](https://api.apify.com/v2/key-value-stores/CZmVHcscvBfufR57w/records/fw-tg-output-v2.png)](https://console.apify.com/actors/SnsRmhv8v6cFTcLe4)

Rows come newest first and are saved as they are read, so a stopped run keeps everything collected so far. A real post row (from Telegram's news channel, collected on 10 November 2026; long file links shortened here):

```json
{
    "type": "post",
    "channel": "telegram",
    "postId": 441,
    "postUrl": "https://t.me/telegram/441",
    "date": "2026-05-14T16:08:31.000Z",
    "text": "Bot-to-Bot Communication. Bots are now able to respond to other bots, not just users.\n\nAI enthusiasts can utilize this to create custom workflows with autonomous agents.\n\nMay Features\n1 • 2 • 3 • 4 • 5 • More",
    "views": 1670000,
    "viewsApproximate": true,
    "isForwarded": false,
    "forwardedFrom": null,
    "forwardedFromUrl": null,
    "replyToPostId": null,
    "replyToUrl": null,
    "edited": false,
    "authorSignature": null,
    "media": [
        {
            "type": "video",
            "url": "https://cdn1.telesco.pe/file/c01503a63e.mp4?token=...",
            "thumbnailUrl": "https://cdn1.telesco.pe/file/AF30yUOlVcEZ...",
            "durationSeconds": 6,
            "postUrl": "https://t.me/telegram/441",
            "fileFormat": "mp4",
            "previewWidth": 1920,
            "previewHeight": 1920,
            "notOnWebReason": null
        }
    ],
    "poll": null,
    "linkPreview": null,
    "links": ["https://t.me/telegram/440", "https://t.me/telegram/442", "https://t.me/telegram/443", "https://t.me/telegram/444", "https://t.me/telegram/445"],
    "hashtags": [],
    "mentions": [],
    "cashtags": [],
    "reactions": [],
    "reactionsTotal": 0,
    "reactionsPer1000Views": 0,
    "subscriberCount": 9149950,
    "subscriberCountApproximate": false,
    "viewsPerSubscriberPercent": 18.3,
    "notViewableOnWeb": false,
    "status": "ok",
    "searchTarget": "telegram",
    "url": "https://t.me/telegram/441",
    "charged": true,
    "scrapedAt": "2026-11-10T01:00:00.000Z"
}
```

A post with a cashtag (from a crypto news channel, collected on 10 November 2026; other fields left out):

```json
{
    "postId": 5673,
    "date": "2024-01-12T14:13:43.000Z",
    "text": "JUST IN: BlackRock now holds 2,620 $BTC worth over $120 million for their spot Bitcoin ETF.\n\n📰 Full Story & Details\n\n@WatcherGuru",
    "views": 136000,
    "viewsApproximate": true,
    "cashtags": ["BTC"],
    "reactionsTotal": 1211,
    "paidStars": 0,
    "reactionsWithoutPaidStars": 1211,
    "reactionsPer1000Views": 8.9,
    "viewsPerSubscriberPercent": 21.5
}
```

Other posts carry the parts they have. A poll (from the Telegram Info channel):

```json
{
    "poll": {
        "question": "Какие клиенты вы используете на ПК?\n\n(Прошлый опрос был случайно завершён)",
        "type": "Anonymous Poll",
        "multipleChoice": true,
        "options": [
            { "text": "Windows: Telegram Desktop", "percent": 71 },
            { "text": "Windows: Unigram", "percent": 5 }
        ],
        "voters": 4270
    },
    "reactions": [
        { "emoji": "🤡", "type": "emoji", "count": 94 },
        { "emoji": "👍", "type": "emoji", "count": 49 }
    ]
}
```

A channel row (free):

```json
{
    "type": "channel",
    "status": "ok",
    "searchTarget": "telegram",
    "username": "telegram",
    "title": "Telegram News",
    "description": "The official Telegram on Telegram. Much recursion. Very Telegram. Wow.",
    "subscribers": 9149950,
    "subscribersApproximate": false,
    "photosCount": 16,
    "videosCount": 228,
    "filesCount": null,
    "linksCount": 378,
    "verified": true,
    "avatarUrl": "https://cdn1.telesco.pe/file/...",
    "lastPostAt": "2026-08-26T19:12:34.000Z",
    "channelUrl": "https://t.me/telegram",
    "url": "https://t.me/telegram",
    "charged": false,
    "scrapedAt": "2026-11-10T01:00:00.000Z"
}
```

A channel that cannot be read gives one free diagnostic row, and the run still succeeds:

```json
{
    "type": "diagnostic",
    "status": "not_found",
    "reason": "No public channel with this name. It may be a user or bot, a private channel, or the name may not exist.",
    "searchTarget": "some_missing_channel",
    "channel": "some_missing_channel",
    "url": "https://t.me/some_missing_channel",
    "charged": false,
    "scrapedAt": "2026-11-10T01:00:00.000Z"
}
```

A Telegram page found by keyword (from a search for `bitcoin etf`, results page saved on 11 November 2026):

```json
{
    "type": "search_result",
    "status": "ok",
    "keyword": "bitcoin etf",
    "searchTarget": "bitcoin etf",
    "country": "US",
    "language": "en",
    "freshness": "any",
    "channel": "exmo_official",
    "postId": 2194,
    "link": "https://t.me/exmo_official/2194",
    "url": "https://t.me/exmo_official/2194",
    "channelUrl": "https://t.me/exmo_official",
    "title": "EXMO.com Official",
    "snippet": "ETFs aim to replicate BTC price movements using futures contracts. Bitcoin's ETF potential: a 74% upswing ahead. 74% increase within a year of ...",
    "dateShown": "Oct 30, 2023",
    "position": 7,
    "pageNumber": 1,
    "charged": false,
    "foundAt": "2026-11-11T22:51:00.000Z"
}
```

`postId` is `null` when the page found is the channel itself, for example `https://t.me/glassnode`. When a result names its channel but not the exact post, the row links to the channel's page, `postId` is `null` and `linkFromBreadcrumb` is `true`. Posts read from a channel found by keyword are ordinary post rows with one more field, `foundByKeyword`. A keyword that finds nothing gives one free diagnostic row with `status: "no_results"` and the `keyword`.

- `status` on diagnostic rows is `not_found`, `preview_unavailable` (the channel exists but Telegram does not show its posts on the web), `not_a_channel` (a group), `private` (an invite link) or `failed`.
- A public group, listed or found by keyword, also gives one free row with `type: "group"`: `username`, `title`, `description`, `members` (the member count its public page shows, such as 26885, with `membersApproximate`), `avatarUrl`, `url` and, when found by keyword, `foundByKeyword`. Its members, messages and online count are not read. Group rows come with channel rows (on by default).
- `channelId` is Telegram's numeric ID of the channel, on post and channel rows, as the public page encodes it (`null` when it does not; on the channel row also when the page's posts carry another name than the channel's header, such as an older alias, since such a page could show another channel's posts); it stays the same when a channel changes its username. The public page does not mark pinned posts, so no pinned flag is returned.
- `lastPostAt` on the channel row is when the channel's newest post was published, read from the channel's newest page at no extra request. It is `null` when the page read was a search inside the channel (a run with **Only posts containing**, or a channel found by keyword whose matching posts are read), or when that page shows no post. On a later run of an only-new watch that first reads older posts still owed from an earlier run, it can also be `null` for that run. Channel rows of channels found by keyword carry `foundByKeyword`.
- `views` and reaction counts are as precise as Telegram shows them: large numbers are rounded (1.67M becomes 1670000), and `viewsApproximate` says when.
- `reactionsTotal` is the sum of all reactions, paid stars included. `paidStars` is the paid stars alone (money spent on the post, not ordinary reactions) and `reactionsWithoutPaidStars` is the rest; use that one to compare engagement between channels. `reactionsPer1000Views` is `reactionsTotal` divided by views times 1,000. All counts are as Telegram showed them at `scrapedAt`, and the subscriber count is the one shown at that moment. `viewsPerSubscriberPercent` is views divided by the subscriber count, as a percentage with one decimal. It uses the exact subscriber count when the run has read it for that channel, otherwise the rounded figure on the channel's page (Telegram rounds above 1,000, as in 12.3K). Views are rounded by Telegram above 1,000 as well, so treat all three as close estimates; older posts have had longer to collect views. Values above 100% are normal: a post that is forwarded widely is seen by many people who do not subscribe.
- `textHtml` and `textMarkdown` (with **Post text format**) give the post's text with its bold, italic, strikethrough, code, quotes, links and line breaks, and in HTML also underline (Markdown has no underline, so underlined text is plain there). They are written anew from the post, never copied as markup: every piece of text is escaped, only those few tags (or Markdown marks) are written, and links keep an http(s) address only (hashtag and search links become plain text). In Markdown the post's own Markdown characters are escaped, so they read as written. Spoilers and emoji are given as their plain text. `text` is unchanged and shows the same words.
- `cashtags` lists tickers written as `$BTC` or `$TON`, without the `$`. Dollar amounts such as `$120` are not included. The `SUMMARY` record also has `cashtagCounts` for every channel: each ticker and how many of the saved posts mention it, most mentioned first.
- `matchedKeywords` lists the search keywords a post matched, when you searched inside channels.
- Round video messages appear in `media` with type `round_video`, a thumbnail and their duration, and in `videoUrls`.
- A post Telegram does not show on the web arrives as a free row with `status: "not_viewable_on_web"` and `notViewableOnWeb: true`, so you know it exists; open its link in Telegram. Channel events such as "Channel created" are skipped.
- `subscribers` on the channel row is the exact count (9149950, with `subscribersApproximate: false`) when Telegram's public page for the channel shows the full figure; otherwise it is the rounded count from the channel's page (9.15M becomes 9150000) with `subscribersApproximate: true`. Reading it takes one page per channel at no extra price, and only while the channel row is on.
- `subscriberCount` on every post row is its channel's subscriber count, so posts from many channels can be compared without joining the channel rows. It is the exact figure when the run read it for that channel (`subscriberCountApproximate: false`, channel rows on), otherwise the rounded figure shown with the posts (`subscriberCountApproximate: true`), and `null` when Telegram showed none.
- `media` lists every photo of an album (checked on albums of 2 and 10 photos), videos, stickers, files and audio. Videos too large for the web have a thumbnail and duration but no file link, and `notOnWebReason` gives Telegram's reason as the page states it ("Media is too big").
- File details come free from the same page, with no extra request: `fileFormat` (the file type the link names: `jpg`, `mp4`, `webp`, `ogg`), `durationSeconds` for videos and voice messages, and `previewWidth` and `previewHeight` for single photos and videos. These are the size at which Telegram's web page shows the item, which can be smaller than the original; album tiles have none. For a file, `sizeText` is Telegram's own size text when the page states one. No size is given for photos, videos, voice messages or stickers: the page states none, and the Actor does not request the files to find one.
- **Media links expire, and files are not stored.** The `url` of a photo, video, voice message or sticker is Telegram's own link. It works for a short time only: Telegram serves it with a cache lifetime of 3 hours, fresh links still worked after an hour, and links saved on 10 November 2026 answered "not found" on 12 November. Save a file promptly from its link if you have the right to. This Actor stores no copies of media. Telegram's [content licensing terms](https://telegram.org/tos/content-licensing) prohibit access to user content outside ordinary use of Telegram, and they leave compliance with the owners' copyright to whoever uses the content, so copies are left to you and your rights.
- A run summary (posts per channel, why each channel stopped, request count) is stored under the key `SUMMARY` in the run's key-value store. For each channel, `coverage` says how much of what you asked for was read: `complete` (read to the end of the channel, your date bound or the last run's newest post), `source_search` (the same for a keyword search: the matches are the ones Telegram's own channel search returns), `capped` (stopped at your maximum; more may exist), `scan_limit` (a filter matched too few posts before the scan allowance ended), `partial` (stopped by your maximum charge, the timeout, an error, a save that could not be confirmed or a charge that reported an error) or `unavailable`. Only `complete` means nothing was left out. With an alert address, `notification.deliveryStatus` is `sent`, `failed` or `nothing_to_send`, with the number of tries. If a run reaches your maximum charge or its timeout, it stops cleanly, keeps every saved row and lists the channels it did not complete under `unfinishedChannels`. If Apify restarts a run or moves it to another server while it runs, the restarted run reads nothing more from Telegram, saves and charges nothing more, and ends with "Partial" in its status message; the run summary says `restartedByPlatform` and how many rows were saved before (`rowsSavedBeforeRestart`). The rows already saved are kept. Start the run again for what is missing; a new-posts watch carries on from what it recorded, and a post saved after its last record can be returned again. This is tested, but has not yet been observed on the platform. If saving one row fails, the run checks its dataset: when the row is there, it counts once (a post is charged once). Otherwise the row is not charged and not written a second time, and the run stops with `stoppedBy` `uncertain_write`: no new row is written after that, though saves already under way on other channels finish and count normally. `uncertainWrite` in the run summary names that row. If the row did land although the run could not confirm it, it stays in the dataset, uncharged although its `charged` field says `true`. In new-posts-only mode that post is not recorded as returned, so the next run of the watch returns it and charges it; if it had landed, it then appears in both runs' datasets, charged once in all. If a row is saved but charging it reports an error, it may or may not have been charged: it counts as saved (a watch does not return it again), it is listed under `chargeErrors` in the run summary, and the run starts no new work (`stoppedBy` `charge_error`).

### How does Telegram Channel Scraper compare with other Telegram scrapers?

Against four Telegram channel scrapers on the Apify Store, as offered in their own listings (input and output fields, README and price) read on 10 November 2026: the one with the nearest price, two others that read channels, and the most-used Telegram actor. "Offered" means the listing has the field or option; we did not test whether the rivals fill it. "-" means we did not find it in that listing.

| | This Actor | Nearest price (102 monthly users) | Channel scraper (91 users) | Channel scraper (224 users) | Most-used (564 users) |
| --- | --- | --- | --- | --- | --- |
| Price per 1,000 posts, Free plan | **$0.30** | $0.35 | $0.447 | $1.00 | $2.50 |
| Start fee per run, at 1 GB of run memory | **$0.00005** | $0.01 | $0.005 | $0.005 | $0.00005 |
| Several channels in one run | Yes | One channel per run | Yes | Yes | Yes |
| Hourly monitor of 20 channels, about 200 new posts a day, per month (from listed prices) | **$1.84** | about $146 | about $6.28 | $9.60 to $38.40 | - |
| Search across all of Telegram | By keyword, among the pages web search has indexed | - | - | - | Yes |
| Keyword inside a channel | Yes | - | Yes | Yes | - |
| Several keywords in one run | Yes, up to 20 | - | One keyword | Yes | - |
| Exclude keywords | Yes | - | Yes | Yes | - |
| Posts newer than a date / last N days | Yes | Yes | Yes | Yes | Yes |
| Posts older than a date | Yes | - | Yes | Yes | Yes |
| Content-type filter | Yes | - | Yes | Yes | - |
| Only new posts on schedule | Yes, automatic, resumes after an early stop | - | Per-channel post ID you supply | Per-channel post ID you supply | - |
| Exact view counts | Rounded above 1,000 | Yes | Rounded | Rounded | Offered |
| Total reactions per post | Yes | - | Yes | Yes | - |
| Reactions per 1,000 views, views per subscriber | **Yes** | - | - | - | - |
| Cashtags ($BTC) | **Yes** | - | - | - | - |
| Filter and count posts by cashtag | **Yes** | - | - | - | - |
| Comment text | No, by design | - | Yes | Yes | - |
| Comment or reply counts | - | Yes | Yes | Yes | - |
| Forward counts | - | Yes | Yes | - | - |
| Polls with percentages | Yes | Yes | - | Yes | - |
| Exact subscriber count | Yes, free | Yes | Yes | Yes, $2 per 1,000 | Offered |
| Free row for a channel that cannot be read | Yes | - | In its run summary | A profile row | - |
| Groups and forums | Group profile only (title, description, member count), free | Yes | - | Profile only | - |
| Read channels from another run's dataset | **Yes** | - | - | - | - |

The monthly figures multiply each listing's prices for 720 hourly runs and 6,000 posts; the 224-user rival's range depends on whether its channel-info charge applies on every run. This table compares what listings offer and cost. It is not a measured test of speed, reliability or completeness.

### Limits of Telegram Channel Scraper

- **Public channels only.** Channels whose posts Telegram shows on the web without login. Of a public group only what its public page shows is returned (title, description, member count); private channels, group messages, users, bots, comments and member lists are not available, by design.
- **Some channels hide their posts from the web.** Their owners turned this off, or Telegram restricts them in some countries. In a test on 10 November 2026 one large news channel that exists was not shown this way. These channels return a free diagnostic row.
- **Rounded numbers.** Views and reactions are rounded by Telegram above 1,000; engagement rates inherit that rounding. Subscriber counts, on channel rows and in `subscriberCount` on post rows, are exact where Telegram shows the full figure and the channel row is on; views per subscriber uses the exact count when the run has read it for that channel, otherwise the rounded figure.
- **Posts Telegram does not show on the web.** Some posts are visible only in the Telegram app. They arrive as free rows with a link and no content.
- **Shared monitor memory outside tasks.** Each saved task keeps its own new-posts memory. Runs started outside a task, for example through the API, share one memory per channel, search text and content filter unless you set a **Monitor name**.
- **Media links expire.** Photo and video links point to Telegram's file servers and carry an access key; download files soon if you need them.
- **Search is Telegram's own.** Results for **Only posts containing** are what Telegram's channel search returns for that text, up to your maximum per channel. An empty result means Telegram's search returned nothing for that text; it is not proof that the channel never mentioned it. The run summary marks these channels `source_search`, or `capped` when your maximum stopped the search.
- **Alerts are best effort.** The Slack, Discord or webhook message is tried up to three times when the receiver is unreachable or busy; when the receiver does not answer in time it is not sent again, so you do not get the same alert twice. If it fails, the run succeeds, the posts stay in the run's dataset, and the run summary and log say the alert was not delivered. In new-posts-only mode those posts count as returned, so the next run does not send them again: open the run's dataset to see them.
- **Keyword search covers what web search has indexed.** It is not a complete search of Telegram. Channels and posts the search engine has not indexed are not found, results change from day to day and by country, and a run returns at most 200 pages per keyword. On three saved result pages the results pages listed about 9 to 10 distinct Telegram pages each.
- **Keyword search can be refused.** If the web search refuses the run or asks for a verification, it is not answered: that keyword is listed as `blocked`, the remaining keywords are listed as `not_searched`, nothing is charged for them, and the run keeps everything already saved. Run them again later.
- **Subscriber range.** It applies to channels and groups found by keyword, not to channels you list. With channel rows off it is compared with the rounded figure on the channel's page, so a channel close to a bound can fall on the wrong side of it.
- **Channel changes need a watch.** Subscriber, title and description changes are reported only with **Report channel changes** and a **Monitor name** or saved task, for the channels you list (not for channels found by keyword), with one run of the watch at a time. Two names that lead to the same channel share one stored copy. The channel photo is not compared.
- **Keyword reading limits.** Matching posts are read for at most **Channels read per keyword** channels (10 by default) per keyword. A channel found by keyword has its matching posts read once per run, and **Maximum posts per channel** holds for the whole run, across keywords and the channels you list, also after a restart. If Telegram asks the run for a verification, it is not answered: the run stops reading Telegram, the keyword is marked `partial`, and the channels not read are listed in the run summary. New-posts-only mode and alerts apply to the channels you list, not to channels found by keyword.
- **Content filter scan limit.** With a content filter, the Actor examines at most 20 times your maximum (at least 1,000 posts) per channel, so a filter that rarely matches cannot run for hours. The `SUMMARY` record says when this limit was reached.
- **Changing a watch starts a new one.** In new-posts-only mode, a different search text or keyword list, content types, cashtags, excluded words or end date starts a new watch. Its first run returns only the newest posts (up to your maximum per channel), and the run log says so.
- **Very short run timeouts.** The Actor keeps the last part of each run free to stop cleanly and save its summary. A run whose timeout is too short to read even one page (about 15 seconds or less) stops at once with a clear message instead of returning an empty result. Give runs at least 60 seconds.
- **New-posts-only mode and large backlogs.** If a channel published more new posts than one run returns (your maximum, maximum charge or timeout), the next run returns the rest before anything newer. With the watch's settings unchanged and one run of it at a time, a post it has recorded as returned is not returned again; a run killed before it saved its memory can return a post again. Clearing a large backlog can therefore take several scheduled runs; the status message says when posts are still pending.

### Who uses Telegram Channel Scraper, and for what?

#### 📰 Crypto and news desks: hourly monitoring of new posts

1. Add the channels you follow.
2. Turn on **Only posts not returned in earlier runs**.
3. Schedule the Actor every hour.
4. Send new rows to Slack, email or Google Sheets with an Apify integration.

After the watch's first run, which returns and charges the newest posts up to your maximum per channel, each run costs its start fee plus the posts the watch has not recorded as returned, with one run of the watch at a time and its settings unchanged; two overlapping runs of the same watch, or a run killed before it saved its memory, can return and charge a post again, and a different search text or keyword list, content types, cashtags, excluded words or end date starts a new watch.

#### 🔎 Traders and analysts: track tickers and keywords across channels

Add a list of channels and your tickers under **Only posts mentioning these cashtags**, for example `BTC`, `ETH` and `NVDA`, or several words under **Only posts containing any of**. Combine it with **Only the last N days** for a weekly report. Every run's `SUMMARY` record counts the tickers each channel mentioned, so you see at a glance which coins and stocks a channel talks about.

#### 📊 Market researchers: find the channels that matter in a niche

Turn on channel rows and add a list of channels: compare subscribers, posting volume, views per post and reactions to find the channels that matter in a niche.

#### 🎬 Media teams: collect photos and videos

Set **Content types** to **Video** or **Photo** to collect only posts with media, with file links, thumbnails and durations.

#### 🧩 Developers: chain runs from a channel list

1. Run any Actor that produces Telegram channel names or links.
2. Start this Actor and pick that run's dataset under **Read channels from a dataset**.
3. Every channel in the first run's results is read. No export or code is needed.

#### 🤖 AI-agent builders: use it in Claude, ChatGPT or Cursor through MCP

Add this address as a custom connector (MCP server) in your AI app, sign in to Apify when the browser opens, and the Actor appears as a tool the assistant can call:

```
https://mcp.apify.com?tools=fetchwright/telegram-channel-scraper
```

The input is small and the output is flat, so the Actor works well as a tool for Claude, ChatGPT, Cursor and other agents through the [Apify MCP server](https://mcp.apify.com). Ask the agent to "summarise what the durov Telegram channel posted this month" and it can call this Actor directly.

### Use it in a pipeline: new Telegram posts to Slack with n8n

Runs are billed to your own Apify account at your plan's prices, wherever you start them.

Two ready-made n8n workflows run this Actor every hour in new-posts-only mode and post each new Telegram post to a Slack channel; the files and what they were checked against are under "Is there a ready-made n8n workflow?" in the FAQ below. The flow, if you prefer to build it yourself:

1. **Schedule Trigger** every hour.
2. Apify node (`@apify/n8n-nodes-apify`), operation **Run an Actor and get dataset**, Actor `fetchwright/telegram-channel-scraper`, custom input:
   ```json
   { "channels": ["telegram", "durov"], "onlyNewPosts": true, "monitorName": "slack-alerts", "maxPostsPerChannel": 20 }
   ```
3. A **Filter** step that keeps rows whose `type` is `post` (the other rows are channel, group, search-result and diagnostic rows).
4. **Slack**: one message per post with its `channel`, `text` and `url`.

With one run of the watch at a time, the Actor does not return a post the watch has recorded as returned; two overlapping runs, or a run stopped before it saved its memory, can return one twice. What reaches Slack then depends on your workflow.

### ❓ FAQ about Telegram Channel Scraper

#### How fresh is the data?

Every run reads Telegram live, so posts published before the run starts are included, with their view and reaction counts at that moment. `scrapedAt` is when the row was collected.

#### How much does a run cost?

$0.30 per 1,000 posts on the Free plan, less on paid plans, plus a start event of $0.00005 per GB of run memory per run. See the tables above for worked examples.

#### How fast is it?

In two tests on 10 November 2026 with 3 channels read at the same time, 180 posts took 10 seconds and 360 posts took 46 seconds, so between 8 and 18 posts per second. Several channels are read at once (5 by default, set by **Channels read at once**).

#### Can I get comments, members or user profiles?

No. The Actor reads public channel posts only, and for public groups only what their public page shows about the group (title, description, member count). Comments, member lists, user profiles and phone numbers are out of scope on purpose.

#### Why does a channel return a diagnostic row instead of posts?

The name may not exist, belong to a user, bot or group, or be a private channel. A channel can also exist but hide its posts from the web; the `reason` field says which case applies.

#### Can I track channel growth and title or description changes?

Yes. Turn on **Report channel changes** with a **Monitor name** (or in a saved task) and schedule the run. With one run of the watch at a time, each run compares every listed channel with the copy kept at its last run:

- `subscriberChange` and `subscriberChangePercent` give the change against `subscribersBefore`, and `previousCheckAt` says when that count was taken. `subscriberChangeApproximate` is `true` when either count is a rounded figure.
- `titleChanged` and `descriptionChanged` give the old text in `titleBefore` and `descriptionBefore`; spacing alone is not a change.
- `channelIdChanged` means the name now leads to another channel. `lastPostAtBefore` is the last post the watch had seen.

On a channel's first check these fields are `null`. The run summary lists the changed channels under `channelChanges`, and the alert names them. In new-posts-only mode, a run with no new post still saves the channel row, free, when something changed. The stored copy is replaced after the row is saved, so a run stopped in between can report the same change again; a change is never lost. The channel photo is not compared: Telegram's address for the same channel's photo changed between our recordings of 10 and 12 November 2026, so a new address does not mean a new photo. No extra request is made beyond the one channel page and one profile page per channel that channel rows already use.

#### What does new-posts-only mode return?

With one run of a watch at a time, it returns the posts it has not recorded as returned. Two overlapping runs, or a run killed before it saved its memory, can return a post again. If a run stopped early, the next run first returns the posts it did not reach, then the newer ones. Each saved task has its own watch; for runs started through the API, give each watch a **Monitor name**. A watch with a content filter never uses up posts for a watch without one. Changing a watch's search text or keyword list, content types, cashtags, excluded words or end date starts a new watch, whose first run returns only the newest posts. To start over, use a new **Monitor name**.

#### Can I find Telegram channels by keyword?

Yes. Add words or phrases under **Find channels by keyword**, for example `bitcoin etf` or `remote jobs`, with or without channels. Each keyword returns the public Telegram channels and posts that web search has found for it, ranked, with title, snippet and link, and by default the matching posts of up to 10 channels it found, with views and reactions. Choose the search country, language and how recent the pages should be. Found pages are free for now; posts are charged as posts. Web search shows only what a search engine has indexed, so this is not a complete search of Telegram.

#### Can I get posts from one month only?

Yes. Set **Posts newer than** to the first day and **Posts older than** to the last day, for example `2026-10-01` and `2026-10-31`. Both days are included, and posts outside the window are never returned or charged.

#### Can I leave out giveaways, ads and other noise?

Yes. List the words or phrases under **Exclude posts containing**, for example `giveaway`, `promo` or `sponsored post`. Matching ignores upper and lower case, and a single word must appear as a whole word, so `ad` skips "New ad" but not "added". Excluded posts are never charged, and the `SUMMARY` record shows how many were skipped per channel.

#### Can I search for several keywords at once?

Yes. List up to 20 words or phrases under **Only posts containing any of**, for example `TON`, `Bitcoin ETF` and `#airdrop`. Each keyword is searched in every channel, and the results come back newest first in one list. A post that matches several keywords is returned and charged once, and its `matchedKeywords` field lists every keyword it matched.

#### Can I get only posts about the tickers I follow?

Yes. List them under **Only posts mentioning these cashtags**, for example `BTC`, `ETH` or `$NVDA`. Only posts that mention at least one of them are returned; the rest are skipped, never charged, and counted in the `SUMMARY` record. Every run also stores `cashtagCounts` per channel in the `SUMMARY` record: each ticker and how many saved posts mention it.

#### Can I get comment, reply or forward counts?

Not yet. Telegram does not show these numbers publicly on the web, and the Actor returns only what Telegram shows to anyone, without a login.

#### Can I download the results as CSV, or open them in Excel or Google Sheets?

Yes. Besides the full `media` list, every post has flat columns made for spreadsheets: `mediaCount`, `firstPhotoUrl`, `photoUrls`, `videoUrls` and `documentUrls`. The Overview table shows the first photo of each post.

#### A run reports that Telegram is limiting requests. What should I do?

Nothing, normally. The Actor slows down for the rest of the run and carries on. If Telegram keeps limiting it, the channels it could not read are reported with the reason and are not charged, so you can run them again later.

#### Is it legal to scrape Telegram channels? Is this allowed?

The Actor collects only posts that channel owners publish openly and that Telegram shows to anyone on the web, with no login and no account. Apify's overview of the topic is in [Is web scraping legal?](https://blog.apify.com/is-web-scraping-legal/) Posts can contain personal data such as names, author signatures and usernames, so data protection law such as the GDPR may apply to how you store and use them. Telegram's [content licensing terms](https://telegram.org/tos/content-licensing) restrict how content from its platform may be collected and used. They cover more than training AI models: they also address collecting and aggregating content and using it in AI systems without the consent of the users concerned. Linking to the terms here does not give you permission. Use the Actor where you have a basis for it, such as your own channels, content you hold rights to, or permission from the channel owner, and check that your use fits those terms. You are responsible for how you use the results and for complying with Telegram's terms and the laws that apply to you. This is not legal advice.

#### Can I use it with the API or other tools?

Yes. Like every Apify Actor it can be run through the Apify API, scheduled, and connected to Zapier, Make, n8n, Slack and Google Sheets. See the API tab on this page for code samples.

#### Is there a ready-made n8n workflow?

Yes, two files you can import into n8n (Workflows, Import from file). Both run this Actor on a schedule in new-posts-only mode and send each new Telegram post to a Slack channel. With one run of the watch at a time and its settings unchanged, the Actor does not return a post the watch has recorded as returned; two overlapping runs, or a run killed before it saved its memory, can return one twice. What reaches Slack then depends on your n8n workflow.

- [With the Apify node for n8n](https://api.apify.com/v2/key-value-stores/CZmVHcscvBfufR57w/records/fw-n8n-telegram-new-posts-to-slack-apify-node-v2.json)
- [With n8n's built-in nodes only](https://api.apify.com/v2/key-value-stores/CZmVHcscvBfufR57w/records/fw-n8n-telegram-new-posts-to-slack-core-nodes-v2.json)
- Both, with setup notes, on GitHub: [github.com/Fetchwright/n8n-telegram-to-slack](https://github.com/Fetchwright/n8n-telegram-to-slack)

The workflows escape `&`, `<` and `>` in post text, so a post cannot ping `@channel` or mention people in your Slack (updated 15 November 2026).

After importing, add your Apify credential, your Slack credential and channel, and your list of Telegram channels. Each run is capped at $0.10 by the workflow. Checked on 11 November 2026: the files' node types and field names match the current n8n and Apify node packages, and the input matches this Actor. Not checked: an import into a running n8n, so tell us on the Issues tab if a step fails.

#### Something is wrong or a field is missing. Where do I report it?

Open an issue on the Issues tab of this page.

### Start monitoring Telegram channels

[Open Telegram Channel Scraper](https://console.apify.com/actors/SnsRmhv8v6cFTcLe4) and click **Start** on the prefilled example, then add your own channels and turn on **Only posts not returned in earlier runs** for a schedule. Apify's free plan credit covers about **16,000 posts** a month. Missing a field you need? Ask for it on the Issues tab.

This Actor is not affiliated with, endorsed by or sponsored by Telegram.

### More from Fetchwright

- [Google Ads Transparency Scraper](https://apify.com/fetchwright/google-ads-transparency-scraper): the ads Google publishes for the advertisers you choose, with ad text, dates and impressions, and a new-ads-only mode for competitor monitoring.
- [Google AI Overview Tracker](https://apify.com/fetchwright/google-ai-overviews-ai-mode-scraper): what Google's AI answers for a query, the pages it cites, and whether your brand is mentioned.

# Changelog

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

# Actor input Schema

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

Required, unless you search by keyword below or read channels from a dataset. Public Telegram channels, one per line. Any form works, for example **durov**, **@durov**, **https://t.me/durov** or a post link such as **t.me/durov/123** (the whole channel is read). Duplicates are removed. Invite links to private channels are reported as unavailable and never charged.

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

Stop after this many posts from each channel, for example **20** for a quick look or **5000** for a full archive. You pay $0.30 per 1,000 posts saved, so this caps the cost of a run. Default: 100. Up to 100,000.

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

Optional. Return only posts that match this word or phrase, searched inside each channel, for example **bitcoin** or a hashtag such as **#update**. Leave empty for all posts.

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

Optional. Several words or phrases at once, for example **TON**, **Bitcoin ETF** and **#airdrop**: each is searched inside every channel, and a post that matches several is returned and charged once, with the ones it matched in matchedKeywords. Works together with the field above. Up to 20. In new-posts-only mode, changing this starts a new watch whose first run returns only the newest posts.

## `findByKeyword` (type: `array`):

Optional. Find public Telegram channels and posts about these words or phrases, for example **bitcoin etf** or **remote jobs**; put a phrase in quotes, such as **"chatgpt"**, to keep its words together. Each keyword returns the public Telegram channels and posts that web search has indexed for it, one row each, once the channel is confirmed public. Found pages are free for now; matching posts read from the channels found are charged as posts at the normal price. Works with or without channels above. Keywords that find nothing or cannot be searched are listed and never charged. Up to 100.

## `maxResultsPerKeyword` (type: `integer`):

Stop after this many Telegram pages (channels and posts) for each keyword, for example **20** for a quick look or **50** for a wide sweep. Fewer come back when web search has fewer. While found pages are free, at most 50 per keyword are returned. Default: 20. Up to 200.

## `keywordCountry` (type: `string`):

Two-letter country code the keyword search is made from, for example **US**, **GB** (or **UK**), **DE**, **IN** or **RU**. Results differ by country. Default: US.

## `keywordLanguage` (type: `string`):

Language code of the keyword search, for example **en**, **ru**, **es** or **pt-br**. It favours pages in that language; it does not translate your keywords. Default: en.

## `keywordFreshness` (type: `string`):

Apply the search engine's own time filter to keyword results: past day, week, month or year, for example **Past week** to see what is being posted now. Default: any time.

## `readMatchingPosts` (type: `boolean`):

For every channel a keyword finds (up to **Channels read per keyword**), search that channel for the keyword and save the matching posts as ordinary post rows, with views, reactions, media and cashtags, each marked with the keyword that found it. Posts cost $0.30 per 1,000, as in channel mode. A found channel's matching posts are read once per run, and **Maximum posts per channel** holds for the whole run. Your date, content, cashtag and exclude filters apply. Turn it off to get only the channels and posts found, with no post charges. Default: on.

## `maxChannelsPerKeyword` (type: `integer`):

Read the matching posts of at most this many channels per keyword, in the order the search found them, for example **10** (the default) or **3** to keep runs small. The other channels found are still listed, as far as the run's time and maximum charge allow. From 1 to 50.

## `minSubscribers` (type: `integer`):

Optional. Keep only channels found by keyword with at least this many subscribers (public groups: members), for example **1000**. Channels outside the range give no rows and are not charged; the run summary lists them per keyword. Compared with the exact count while channel rows are on, otherwise with the figure the channel's page shows (rounded above 1,000). Channels you list by name are always read.

## `maxSubscribers` (type: `integer`):

Optional. Keep only channels found by keyword with at most this many subscribers (public groups: members), for example **50000**, to find smaller channels. Channels outside the range give no rows and are not charged. Channels you list by name are always read.

## `newerThan` (type: `string`):

Optional. Keep only posts published on or after this date, for example **2026-10-01**. Older posts are never returned or charged. Leave empty for no date limit.

## `lastDays` (type: `integer`):

Optional. Keep only posts from the last N days, for example **7** for the past week. If you also set a date above, the later of the two applies. Leave empty for no limit.

## `untilDate` (type: `string`):

Optional. Keep only posts published on or before this date, for example **2026-10-31** for an archive that ends in October. Combine it with **Posts newer than** for an exact window. Newer posts are skipped and never charged. Leave empty for no end date. In new-posts-only mode, changing this starts a new watch whose first run returns only the newest posts.

## `mediaTypes` (type: `array`):

Optional. Keep only posts with at least one of these, for example **Video** and **Photo**. Text-only means posts with no media, poll or link card. Posts that do not match are skipped and never charged. Leave empty for all posts. In new-posts-only mode, changing this starts a new watch whose first run returns only the newest posts.

## `minViews` (type: `integer`):

Keep only posts with at least this many views (as Telegram shows them). Posts with fewer views, or without a view count, are left out and not charged. On an only-new watch a post left out is not returned later, even when its views grow.

## `originalPostsOnly` (type: `boolean`):

Leave out posts forwarded from another channel or user (Telegram marks them "Forwarded from"). Left-out posts are not saved and not charged, and the run summary counts them. On an only-new watch a forwarded post left out is not returned later.

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

Optional. Skip posts that contain any of these words or phrases, for example **giveaway** or **sponsored post**. Not case-sensitive; a single word must appear as a whole word, so **ad** does not skip a post that says "added". Skipped posts are never charged. Leave empty to keep all posts. In new-posts-only mode, changing this starts a new watch whose first run returns only the newest posts.

## `cashtags` (type: `array`):

Optional. Keep only posts that mention at least one of these tickers, for example **BTC** and **NVDA** (with or without the $). Other posts are skipped and never charged, and the SUMMARY record counts them. Leave empty for all posts. In new-posts-only mode, changing this starts a new watch whose first run returns only the newest posts.

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

For scheduled monitoring, for example a run every hour on news channels. The Actor records, per channel, which posts it returned. With one run of a watch at a time, the next run returns and charges only posts it has not recorded; if a run stops early, the next run returns the rest first. Two overlapping runs of the same watch, or a run killed before it saved its memory, can return a post again. Each saved task keeps its own memory. Runs started outside a task (for example through the API) share one memory per channel, search text and content filter unless you set a Monitor name. Default: off.

## `monitorName` (type: `string`):

Optional. Give a watch its own memory, for example **crypto-news**. Use it for runs started through the API, which otherwise share one memory per channel, search text and content filter across your account. The same name in two tasks means one shared watch. Leave empty in a saved task: each task already has its own memory.

## `trackChannelChanges` (type: `boolean`):

For a named watch (a Monitor name, or a saved task): each run compares every listed channel with the copy the watch kept from its last run and reports subscriber growth or loss (number and percent), a new title and a new description, with the old text, on the free channel row, in the run summary and in the alert. A channel that changed gets its channel row even when no post is new. With one run of a watch at a time. Needs channel rows on. No extra charge. Default: off.

## `notifyWebhookUrl` (type: `string`):

Optional. Paste a Slack or Discord incoming-webhook address, or any https:// address that accepts JSON. When the run saves posts, a short message is posted there: how many posts per channel, the first three with the start of their text and their link, and a link to all rows. With **Only new posts** on a schedule and a keyword or cashtag filter, this is a keyword alert for Telegram channels. No extra charge.

## `notifyWhenNothingFound` (type: `boolean`):

Also post a message when the run saved no posts. Off by default, so a quiet run sends nothing.

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

Adds one free row per channel with its title, description, exact subscriber count where Telegram shows it, photo, video and link counts, verified badge, avatar and the date of its last post, for example to rank channels by audience. A public group, listed or found by keyword, gives one free group row with its title, description and member count (never its members or messages). Reading the exact count takes one more page per channel; posts of that channel then work out views per subscriber from it. Default: on.

## `textFormat` (type: `string`):

Also returns each post's text with its formatting: bold, italic, strikethrough, code, quotes, links and line breaks, as **HTML** (textHtml, also with underline) or **Markdown** (textMarkdown; Markdown has no underline). Built from the page already read: no extra request or charge. Spoilers and emoji appear as their plain text. The plain text field stays as it is. Default: plain text only.

## `channelsDatasetId` (type: `string`):

Optional. Pick a dataset from another run, for example a list of channel links or this Actor's own channel rows, and its channels are added to the list above. Use it to chain Actors without exporting anything.

## `channelsDatasetField` (type: `string`):

Name of the field that holds channel names or links, for example **channel** or **url**. Leave empty to detect it automatically (channel, username, channelUrl, telegram, url, searchTarget, link, name).

## `maxConcurrency` (type: `integer`):

How many channels are read in parallel, for example **5** (the default). Each channel's posts still come newest first. Higher values finish long channel lists sooner. From 1 to 10.

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

Usually not needed: the Actor handles Telegram's rate limits by itself. Set a proxy only if you have a specific reason to, for example a channel that is shown only in some countries.

## Actor input object example

```json
{
  "channels": [
    "telegram"
  ],
  "maxPostsPerChannel": 20,
  "maxResultsPerKeyword": 20,
  "keywordCountry": "US",
  "keywordLanguage": "en",
  "keywordFreshness": "any",
  "readMatchingPosts": true,
  "maxChannelsPerKeyword": 10,
  "originalPostsOnly": false,
  "onlyNewPosts": false,
  "trackChannelChanges": false,
  "notifyWhenNothingFound": false,
  "includeChannelInfo": true,
  "textFormat": "text",
  "maxConcurrency": 5,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}
```

# Actor output Schema

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

One item per post (text, date, views, media, poll, link card, reactions), plus one free row per channel, one row per Telegram page found by keyword, and a free row for each channel or keyword that gave nothing.

## `keywordResults` (type: `string`):

Telegram channels and posts found by keyword: title, snippet, link, rank and the date shown.

## `summary` (type: `string`):

Posts saved per channel, why each channel stopped, results and posts per keyword with what stopped each keyword, and anything left unfinished at your maximum charge or the run timeout.

# 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"
    ],
    "maxPostsPerChannel": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

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

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

```

## MCP server setup

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