# Telegram Channel Scraper ($0.74/1K): Posts, Views & Alerts (`tsutseisoftware/telegram-channel-scraper`) Actor

Scrape posts from public Telegram channels without login: text, views, reactions, photos, videos, polls, link previews, forwards. Search inside channels, date range (jumps years back), channel stats, monitoring of new, edited and deleted posts, alerts to Slack, Discord, Telegram.

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

## Pricing

from $0.55 / 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, Reactions & Alerts

Export posts from **public Telegram channels** as clean structured data, **without a Telegram account, phone number, bot or API key**. For every post you get the text, publication time, **views**, **reactions** (by emoji, paid star reactions separately), **photos and videos**, files, **polls with their results**, link previews, hashtags and links, forwards and replies. Read the newest posts, a whole channel history, or **any date range years back**; search inside channels; and schedule it to get **only new posts**, plus **edited and deleted posts**, sent to Slack, Discord, Telegram, WhatsApp or your webhook. Built for media monitoring, OSINT and research, crypto and market signals, brand tracking and AI pipelines.

**$0.74 per 1,000 posts** ($0.55 on Gold), no extra platform costs. A typical run of 100 posts costs **$0.08**.

### Why use this Telegram scraper?

- 📰 **Every part of a post:** text with emoji and line breaks, views, reactions by emoji, star reactions, photos, videos with their length, files with name and size, polls with each answer's percentage, link previews, hashtags, links, forwards, replies and the edited flag.
- 📅 **Any date range, fast:** a range years back costs about as much as yesterday: the actor goes straight to the period you ask for instead of paging through everything newer.
- 🔎 **Search inside channels:** Telegram's own search in each listed channel, so only matching posts are read and charged; plus free filters (must contain, must not contain, media type, minimum views).
- 🔔 **Monitoring with edits and deletions:** scheduled runs save only posts published since the previous run, and can re-check the latest known posts to report **edited** posts (with the earlier text) and **deleted** posts. Alerts to **Slack, Discord, Telegram, WhatsApp** or a **webhook** (Zapier, Make, n8n).
- 📊 **Channel statistics:** optional channel row with the **exact subscriber count**, description, verified badge and engagement of the saved posts: average and median views, views per subscriber, reactions per view, posts per day. The free SUMMARY record has the same per channel.
- 💸 **Predictable price:** $0.74 per 1,000 posts, $0.55 on Gold, no extra platform costs; posts left out by filters and posts already known in monitoring are not charged.
- 🔒 **Privacy first:** public channels only; no member lists, no comments by private people, no extraction of phone numbers or e-mails into separate fields; admin signatures only when you ask for them.

#### How it compares with other Telegram channel scrapers

An honest comparison with the Telegram channel scrapers in the Store that have users (their inputs and prices checked on 2026-11-15), without naming them:

| Capability | This actor | Other channel scrapers |
|---|---|---|
| Price per 1,000 posts | **$0.74** (Bronze $0.67, Silver $0.59, Gold $0.55), start $0.003 | $0.45–$5.00 for the ones most used (Gold $0.23–$2.50), start up to $0.01 |
| Text, views, reactions, media links, forwards, replies | yes | yes |
| Polls with results, files with size, video length, link previews | yes | some |
| Date range | yes, and a period years back costs about as much as a recent one | yes |
| Search inside channels | yes, several terms, only matches charged (Telegram shows the ~20 newest matches of a term) | some (one phrase, or a filter over all posts) |
| Only new posts in scheduled runs | yes, remembered for you | most, some only with post IDs you pass yourself |
| Edited and deleted posts | **yes** | none of the ones we checked |
| Alerts to Slack, Discord, Telegram, WhatsApp, webhook | **yes** | none of the ones we checked |
| Channel row with exact subscribers and engagement | yes, one result per channel | some (subscribers, sometimes engagement) |
| Comments under posts | no (written by private people) | some |
| Search across all of Telegram | no (needs a Telegram account) | one, through web search results (incomplete by its own README) |

### What data can you get?

| Field | Example |
|---|---|
| `url`, `postId`, `channelUsername`, `channelTitle`, `channelSubscribers` | https://t.me/durov/540, 540, durov, Pavel Durov, 9990000 |
| `postedAt`, `isEdited` | 2026-08-10T09:29:58Z, false |
| `text`, `hashtags`, `links` | the post's text with emoji, its hashtags and web links |
| `views`, `viewsText` | 5180000, 5.18M |
| `reactionsTotal`, `paidReactions`, `reactions` | 78240, 9140, \[{"emoji": "👍", "count": 43100}, …] |
| `mediaType`, `mediaTypes`, `mediaCount` | photo, \["photo", "linkPreview"], 1 |
| `photoUrls`, `videoUrls`, `videoThumbnailUrls`, `videoDurations` | links to the media, "0:33" |
| `files` | \[{"name": "TON.pdf", "size": "10.9 MB"}] |
| `pollQuestion`, `pollType`, `pollOptions` | the question, "Anonymous Poll", \[{"text": "…", "percent": 71.0}] |
| `linkPreviewUrl`, `linkPreviewTitle`, `linkPreviewDescription`, `linkPreviewSiteName`, `linkPreviewImageUrl` | the link preview under the post |
| `isForwarded`, `forwardedFrom`, `forwardedFromUrl`, `replyToPostId`, `replyToUrl` | forwards and replies |
| `searchTerm`, `changeType`, `previousText` | with search and monitoring |
| channel row: `channelSubscribers` (exact), `channelDescription`, `isVerified`, `averageViews`, `medianViews`, `viewsPerSubscriberPercent`, `reactionsPerViewPercent`, `postsPerDay` | with **Add a channel row** |

Measured on Apify (1,000 posts of 10 channels, 15 November 2026): text 99 % (the rest are media-only posts), time and views 100 %, reactions 80 % (channels that turned reactions off have none), photos 54 %, videos 18 %; in a smaller sample a playable video link came for 19 of 22 videos (big videos are shown only in the Telegram app, their thumbnail and length still come).

### How to scrape Telegram channels

1. Open the actor and add one or more **Channels**: a name (`durov`), `@durov` or a link (`https://t.me/durov`). A link to one post (`https://t.me/durov/540`) reads just that post.
2. Set **Max posts per channel** (0 = the whole history), and optionally a **date range**, **search terms** or **filters**.
3. Click **Start**. Download the posts as JSON, CSV, Excel or HTML, or read them through the Apify API.
4. For alerts, turn on **Monitoring: only new posts**, add a Slack, Discord, Telegram, WhatsApp or webhook target and **schedule** the actor (for example every hour).

### Use cases

#### Latest posts of a few channels

```json
{ "channels": ["durov", "telegram", "https://t.me/nexta_live"], "maxPostsPerChannel": 100 }
```

#### Everything a channel posted in March 2025

```json
{ "channels": ["nexta_live"], "maxPostsPerChannel": 0, "postedAfter": "2025-03-01", "postedBefore": "2025-03-31" }
```

#### Crypto signals: posts mentioning a coin, with photos only

```json
{ "channels": ["cointelegraph", "binance_announcements"], "searchTerms": ["bitcoin", "ETF"], "mediaTypes": ["photo"], "maxPostsPerChannel": 20 }
```

#### Hourly alerts of new, edited and deleted posts to Slack

```json
{
  "channels": ["durov", "telegram"],
  "onlyNewPosts": true,
  "recheckRecentPosts": 20,
  "slackWebhookUrl": "https://hooks.slack.com/services/…",
  "maxPostsPerChannel": 50
}
```

#### Channel statistics for a media list

```json
{ "channels": ["durov", "telegram", "nexta_live", "tginfo"], "maxPostsPerChannel": 50, "includeChannelInfo": true }
```

The channel rows (`rowType: "channel"`) give the exact subscribers and the engagement of the last 50 posts of each channel.

### How it works

#### Date range

**Posted after** and **Posted before** take a date (`2026-11-01`), a date and time in UTC or a relative time (`7 days`, `24 hours`). Reading a channel stops at the first post older than **Posted after**. With **Posted before**, the actor first finds where that period starts in the channel, so a month years ago costs a few cents, not a read of the whole history.

#### Search inside channels

Each term of **Search inside the channels** is searched in each channel with Telegram's own search (the same as the search box of the channel), so only matching posts are read and charged. A post found by two terms is saved once. Telegram's search shows only about the **20 newest matches** of a term in a channel (the status message says when a term reached it); for older matching posts use **Post must contain** with a date range, which reads every post of the period and keeps the matching ones. Telegram can't be searched as a whole without an account: list the channels you care about.

#### Monitoring explained

With **Monitoring: only new posts**, the first run saves the newest posts (up to **Max posts per channel** or your date range) and remembers them under the **Monitoring key**. Every later run saves only posts published since then; posts it already knows are not saved and not charged. Each channel page checked costs $0.0001, so a check without news costs almost nothing. **Re-check the latest known posts** (for example 20) compares that many of the latest known posts of each channel with the earlier run and saves the ones that were **edited** (`changeType: "edited"`, with `previousText`) or **deleted** (`changeType: "deleted"`, with the beginning of their text). Posts are remembered for 30 days.

#### Notifications

After each run the saved posts (with monitoring the new, edited and deleted ones) go to **Slack**, **Discord**, **Telegram** (your own bot), **WhatsApp** (your Meta business account) or a **webhook**: the beginning of the text, the channel, the time and the link, at most **Max posts per message** (the rest as "…and N more"). With **Only when something was saved** (default) quiet runs send nothing.

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

**$0.74 per 1,000 posts.** The actor uses pay-per-event pricing: a price per saved row (the $0.74 shown in the Store) and small fees charged only for what was done. Prices per 1,000 on the free plan (the **Pricing** tab has the current ones and the plan discounts):

| Event | Price | When |
|---|---|---|
| Post (or channel row) saved | $0.74 per 1,000 (Bronze $0.67, Silver $0.59, Gold and up $0.55) | every saved row |
| Monitoring page | $0.10 per 1,000 pages | monitoring mode: every channel page checked (20 posts each) |
| Extra page | $0.10 per 1,000 pages | a page that saved nothing (all its posts left out by your filters or outside your date range, the pages read to find the start of an old date range, a search with no results, a name that is not a public channel, a post link that no longer exists); if the saved posts don't cover a run's cost, the difference is charged as extra pages too; with a **RESIDENTIAL** proxy (your choice, not needed) each page also pays its traffic as 5 extra pages; a normal run pays nothing here |
| Notification | $0.001 per run | once per run that delivered its notification (all channels together) |
| Actor start | $0.003 per run | the start of the run |

| Typical run | Price (free plan) | Gold | Typical time |
|---|---|---|---|
| 20 posts of one channel | $0.018 | $0.014 | a few seconds |
| 100 posts of each of 10 channels | $0.74 | $0.55 | about 1 minute |
| One day of a channel two years ago (~40 posts) | $0.03 | $0.03 | under 30 seconds |
| Hourly check of 10 channels, 3 new posts, Slack alert | $0.0072 per run, about $5.20 a month | $0.0067 | under 20 seconds |

You pay no extra platform costs (compute, traffic) on top of these prices. The channel statistics in SUMMARY are free. Filtered-out, duplicate and (in monitoring mode) already known posts are not charged. You can set a maximum cost per run; the actor stops when it is reached.

### Input example

```json
{
  "channels": ["durov", "https://t.me/telegram"],
  "maxPostsPerChannel": 50,
  "postedAfter": "30 days",
  "excludeKeywords": ["giveaway"],
  "includeChannelInfo": true
}
```

### Output example

```json
{
  "id": "durov/540",
  "rowType": "post",
  "source": "t.me",
  "url": "https://t.me/durov/540",
  "postId": 540,
  "channelUsername": "durov",
  "channelTitle": "Pavel Durov",
  "channelUrl": "https://t.me/durov",
  "channelSubscribers": 9990000,
  "postedAt": "2026-08-10T09:29:58Z",
  "isEdited": false,
  "text": "🇺🇿 The 2026 International Olympiad in Informatics starts today in Tashkent.\n\n🏆 The IOI is the ultimate coding competition for high-school students. …",
  "views": 5180000,
  "viewsText": "5.18M",
  "reactionsTotal": 78240,
  "paidReactions": 9140,
  "reactions": [
    { "emoji": "⭐", "customEmojiId": null, "count": 9140, "isPaid": true },
    { "emoji": null, "customEmojiId": "5373223594484587136", "count": 43100, "isPaid": false }
  ],
  "mediaType": "photo",
  "mediaTypes": ["photo"],
  "mediaCount": 1,
  "photoUrls": ["https://cdn4.telesco.pe/file/nhlSfEQPRaSIT37N41Q….jpg"],
  "videoUrls": [],
  "files": [],
  "pollQuestion": null,
  "pollOptions": [],
  "linkPreviewUrl": null,
  "links": [],
  "hashtags": [],
  "isForwarded": false,
  "forwardedFrom": null,
  "replyToPostId": null,
  "authorSignature": null,
  "searchTerm": null,
  "changeType": null,
  "previousText": null,
  "scrapedAt": "2026-11-15T09:20:11Z"
}
```

Every row has all fields (empty ones as `null` or `[]`); the channel row fields are `null` on posts.

### Limitations

- **Public channels only.** Groups, users, bots and private channels have no public preview and are skipped with a note in the status message (the run fails only when nothing could be read). Comments under posts and member lists are not available.
- **Views, reactions and the subscribers on post rows are rounded** for big numbers the way Telegram shows them (5.18M); the channel row has the exact subscriber count.
- **Media links expire** after some time: download the photos and videos you need soon after the run. Big videos are shown only in the Telegram app; their thumbnail and length still come. Custom emoji reactions have the emoji's ID instead of the character.
- **Monitoring and Max posts per channel:** when a channel published more new posts since the previous run than **Max posts per channel**, the older of them are skipped (the status message says so); use 0 or a higher limit for busy channels.
- **Edits and deletions** are found only among posts saved by earlier monitoring runs in the last 30 days, and only within the number of latest posts you ask to re-check. Not with search terms.
- Telegram sometimes doesn't show channels that a country's law blocks to IP addresses of that country; the actor runs from Apify's servers, so this rarely matters.
- No proxy needed. A page Telegram rejects is retried once a little later, never from another IP address; if rejections continue, the run stops with what it has saved and says so. It never solves captchas or other challenges.

### For AI agents and API users

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("tsutseisoftware/telegram-channel-scraper").call(run_input={
    "channels": ["durov", "telegram"], "maxPostsPerChannel": 50,
})
for post in client.dataset(run.default_dataset_id).iterate_items():
    print(post["postedAt"], post["channelUsername"], post["views"], (post["text"] or "")[:80])
```

### Troubleshooting

- **"not a public channel, or no such name"**: check the name in the channel's link (the part after `t.me/`).
- **"a group: only channels have a public preview"**: groups can't be read without joining them; this actor reads channels only.
- **"the channel has no public preview"**: the channel turned its web preview off; it can't be read without an account.
- **"post not found (deleted or not public)"**: the post of the link no longer exists.
- **"Telegram refused the requests"**: try again later; if it keeps happening, set **Proxy configuration** to Apify Proxy.

### Integrations

Connect the results to the tools you already use with the built-in integrations of Apify (the **Integrations** tab of the actor or of a saved task), with no code:

- **Google Sheets or Google Drive:** the results of every run in a spreadsheet or a file.
- **Zapier, Make and n8n:** start a workflow when a run finishes, or start the actor from one.
- **Slack or e-mail:** a message from Apify when a run finishes or fails.
- **Webhooks:** your own address gets the details of each run.
- **API and MCP:** run the actor from your code, or let an AI assistant run it through the Apify MCP server.

The results also download as Excel, CSV, JSON or XML from the **Output** tab.

### Privacy and error reports

When a run fails, the actor sends its developer a short error report: the error, the run ID and your input with secrets left out (tokens, webhooks, e-mails and similar values are hidden). Your results are never sent. Reports are deleted after at most 120 hours (5 days). To send nothing, turn off **Send error reports** (`sendErrorReports: false`). Questions about your data: open an issue in the **Issues** tab of this actor.

### More news and trend scrapers

The same clean output and alerts for another news or trend source:

- [Google Trends Scraper](https://apify.com/tsutseisoftware/google-trends-scraper): interest over time, by region and city, related queries, Trending now, keyword alerts and more than 5 terms on one scale
- [Google News Scraper](https://apify.com/tsutseisoftware/google-news-scraper): articles for any search, topic or country with the real publisher URL, full text and new article alerts

### WhatsApp notifications: setup

The actor sends the message from your own WhatsApp business number through the WhatsApp Cloud API of your Meta business account. You need a Meta business account; the actor uses only the values you enter in the **Notifications** section (the token and the numbers are stored encrypted and never written to the log).

1. **Create an app.** In Meta for Developers open **My Apps → Create app** and choose the use case **Connect with customers through WhatsApp**.
2. **Get a sending number.** In the app open **WhatsApp → API Setup**. You can start with the test number Meta gives you and add your own business number there later. Copy the **Phone number ID** (not the number itself) into **WhatsApp phone number ID**.
3. **Confirm the recipients (test number only).** A test number sends only to numbers on its list: in **API Setup**, under **To**, add each recipient's number and confirm it with the code WhatsApp sends to it.
4. **Create a permanent access token.** The token shown in API Setup expires within hours. In **Business settings → System users** add a system user, use **Assign assets** to give it your app (and your WhatsApp account), then **Generate token** for the app with the permissions `whatsapp_business_messaging` and `whatsapp_business_management` and the expiry you want. Paste it into **WhatsApp access token**.
5. **Create a message template (recommended).** In **WhatsApp Manager → Message templates → Create template** choose the category **Utility**, a name (e.g. `apify_results`) and a language, and write a body with two variables, for example: `New results of your Apify task: {{1}} Open the dataset: {{2}} (sent automatically after each run).` Meta does not accept a body that starts or ends with a variable and asks for sample values (e.g. `3 new jobs` and a dataset link); keep the text factual, a promotional text is moved to the Marketing category. Approval can take up to 24 hours. Enter the name in **WhatsApp template name** and its language code (e.g. `en_US`, `cs`, `pl`, `de`, as WhatsApp Manager shows it) in **WhatsApp template language**.
6. **Enter the recipients.** **WhatsApp recipient number** takes up to 5 numbers with the country code (e.g. `+420601234567`), separated by commas or new lines. Each number gets its own message.

**What the message contains.** With a template: `{{1}}` is the run summary with the first results on one line (title, company or price, place; never descriptions or contacts) and `{{2}}` the link to the dataset. A template with only `{{1}}` works too, it then gets the link at the end. Without a template the actor sends a text message with one link per result, like in Slack or Telegram.

**Without a template** WhatsApp delivers the message only when the recipient wrote to your business number in the last 24 hours (the customer service window), so a daily or hourly schedule needs a template. The run log says so once per run.

**What it costs.** Meta bills your business account, not this actor: per delivered message, by the message category (a template of the Utility category, or a service message for text in the 24-hour window, with a monthly free allowance per business number) and by the recipient's country. The current rates are in Meta's pricing of the WhatsApp Business Platform. The actor's own notification charge (see the **Pricing** tab) is once per run that delivered its notification, whatever the number of channels and recipients.

**Checked at the start.** When the run starts, the actor checks the token, the phone number ID and, when the token shows its WhatsApp account, the template (name, language, approval), without sending anything. Settings that can't work stop the run with a message that says what to fix, before anything is read from the website.

**When nothing arrives**, the run log names the WhatsApp error and what to do: a template that does not exist in that language or is not approved yet, a template with another number of variables, a recipient missing from the test number's list, an expired token, or the 24-hour window. A failed notification never fails the run and is not charged. Meta can accept a message and still not deliver it later (for example when the recipient's phone is not on WhatsApp); such a run counts as notified.

### FAQ

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

It reads only publicly available data (the public web preview of public channels), without logging in, at most 80 requests per minute, slows down when the website asks, never changes IP address to get around a limit and never solves captchas or other challenges. It reads no groups, private chats, member lists or comments, extracts no contacts, and leaves out admin signatures unless you ask for them. Channel posts can still name people: you are responsible for how you use the data (copyright of the posts and media, GDPR and Telegram's terms). If in doubt, consult a lawyer. This actor is not affiliated with Telegram.

#### Do I need a Telegram account, phone number or API key?

No. Nothing to log in to and no session to keep alive.

#### Can it search all of Telegram for a keyword?

No. Searching all public channels needs a logged-in Telegram account (tools that offer it go through web search results, which cover only a part of Telegram). List the channels you want and use **Search inside the channels**; to find channels, start from a few known ones and their forwards (`forwardedFromUrl`).

#### How many posts can I get?

All posts of a channel that its public preview shows, from the first one (use **Max posts per channel** 0). A long history of a busy channel can have tens of thousands of posts: set a date range or a limit to control the cost.

#### Can I download the photos and videos?

The rows have links to the photos and videos; download them with your own script soon after the run, since the links expire.

#### Can I use it from an AI agent or through MCP?

Yes. Apify's MCP server (mcp.apify.com) exposes every actor in the Store as a tool; the rows are flat JSON that a model reads easily.

***

Also known as a Telegram API alternative, Telegram channel parser, Telegram post exporter, t.me scraper, Telegram monitoring and Telegram alert tool, "парсер Telegram каналов".

# Changelog

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

# Actor input Schema

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

Public channels: a name (durov), @name or a link (https://t.me/durov, https://t.me/s/durov). A link to one post (https://t.me/durov/540) reads just that post. Groups, users, bots and private channels can't be read (they have no public preview).

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

Newest posts saved from each channel (with search terms: for each term). 0 = the whole history (or everything in your date range). You pay per saved post.

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

Most rows saved in the whole run (posts and channel rows). 0 = no limit.

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

Only posts published at or after this time: a date (2026-11-01), a date and time in UTC (2026-11-01T08:00:00Z) or a relative time (7 days, 24 hours, 2 weeks). Reading of a channel stops at the first older post.

## `postedBefore` (type: `string`):

Only posts published at or before this time: a date (2026-06-30, the whole day counts), a date and time in UTC or a relative time (30 days).

## `searchTerms` (type: `array`):

Words or phrases searched inside each channel with Telegram's own search (each term separately; a post found by two terms is saved once, with the first term in "searchTerm"). Telegram shows only about the 20 newest matches of a term; for older ones use "Post must contain" with a date range. Searching across all of Telegram is not possible without a Telegram account, so list the channels to search in.

## `includeKeywords` (type: `array`):

Keep only posts whose text, poll or link preview contains at least one of these words or phrases (case and accents ignored).

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

Leave out posts containing any of these words or phrases (case and accents ignored).

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

Keep only posts with at least one of these kinds of content. Empty = all posts.

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

Keep only posts with at least this many views (big numbers are rounded by Telegram, e.g. 5.18M).

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

One extra row per channel ("rowType": "channel", charged as one result): exact subscriber count, title, description, verified badge, photo, counts of photos, videos, files and links, and engagement from the posts saved in the run (average and median views, reactions per view, views per subscriber, posts per day).

## `includeAuthorSignatures` (type: `boolean`):

Some channels sign each post with the name of the admin who wrote it. It is a person's name, so it is left out unless you turn this on (you are responsible for processing it lawfully).

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

Save only posts published since the previous run with the same Monitoring key (the first run saves the newest posts up to "Max posts per channel"). Known posts are not saved and not charged; every channel page checked costs the small "Monitoring page" fee (see Pricing).

## `recheckRecentPosts` (type: `integer`):

With monitoring: also re-check this many of the latest known posts of each channel and save the ones that were edited ("changeType": "edited" with "previousText") or deleted ("changeType": "deleted"). 20 = one more page per channel. Only posts saved by earlier runs (within 30 days) are compared.

## `monitoringKey` (type: `string`):

Name of the saved state. Use a different key for each watched list of channels. Empty = "default". The value is stored encrypted.

## `slackWebhookUrl` (type: `string`):

Incoming webhook of your Slack channel (https://hooks.slack.com/services/...). Stored encrypted.

## `discordWebhookUrl` (type: `string`):

Webhook of your Discord channel (https://discord.com/api/webhooks/...). In Discord: channel settings → Integrations → Webhooks → Copy Webhook URL. Stored encrypted.

## `telegramBotToken` (type: `string`):

Token of your Telegram bot (from @BotFather). Used with "Telegram chat ID". Stored encrypted.

## `telegramChatId` (type: `string`):

Chat, group or channel ID the bot writes to (e.g. -1001234567890).

## `webhookUrl` (type: `string`):

Any HTTPS URL (Zapier, Make, n8n, your server): gets a POST with JSON {title, summary, totalSaved, runUrl, datasetUrl, items}.

## `whatsappAccessToken` (type: `string`):

Access token of the WhatsApp Cloud API of your Meta business account, used with "WhatsApp phone number ID" and "WhatsApp recipient number" (step by step in the README, section "WhatsApp notifications: setup"). For scheduled runs use a permanent token of a system user: Business settings → System users → Generate token, with the permissions whatsapp_business_messaging and whatsapp_business_management; the token of WhatsApp → API Setup expires within hours. Stored encrypted.

## `whatsappPhoneNumberId` (type: `string`):

ID of your WhatsApp business number that sends the message (not the number itself), e.g. 106540352242922. In your Meta app: WhatsApp → API Setup → Phone number ID.

## `whatsappTo` (type: `string`):

Phone number that gets the message, in international format with the country code (e.g. +420601234567); up to 5 numbers separated by commas or new lines, each gets its own message and the notification is charged once per run. A test number of Meta sends only to numbers you added and confirmed under API Setup → To. Stored encrypted.

## `whatsappTemplateName` (type: `string`):

Name of your approved message template (WhatsApp Manager → Message templates, e.g. apify_results), recommended: WhatsApp delivers a template message at any time. Its body gets the run summary with the first results in {{1}} and the dataset link in {{2}} (a template with only {{1}} gets both in {{1}}). Empty: a plain text message, which WhatsApp delivers only when the recipient wrote to your business number in the last 24 hours, so a scheduled run usually needs a template. Meta charges your business account for template messages (step by step in the README, section "WhatsApp notifications: setup").

## `whatsappTemplateLanguage` (type: `string`):

Language code of the template exactly as WhatsApp Manager → Message templates shows it next to the template, e.g. en_US, en_GB, cs, sk, pl or de. Used only with "WhatsApp template name".

## `notificationLimit` (type: `integer`):

How many posts are listed in one notification (the rest as "…and N more").

## `notifyOnlyChanges` (type: `boolean`):

Send nothing when the run saved no post (e.g. a monitoring run without news).

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

No proxy by default: Telegram answers the Apify servers directly. Use Apify Proxy (automatic group) only if Telegram starts refusing requests. A RESIDENTIAL proxy works too: its traffic is added as "Extra page" charges ($0.0005 per page of up to 20 posts).

## `sendErrorReports` (type: `boolean`):

When a run fails, send the developer a short error report: the error and your input with secrets left out (tokens, webhooks and e-mails are hidden). Your results are never sent. Reports are deleted after at most 120 hours. Turn off to send nothing.

## Actor input object example

```json
{
  "channels": [
    "durov",
    "telegram"
  ],
  "maxPostsPerChannel": 20,
  "maxItems": 0,
  "includeChannelInfo": false,
  "includeAuthorSignatures": false,
  "onlyNewPosts": false,
  "recheckRecentPosts": 0,
  "whatsappTemplateLanguage": "en_US",
  "notificationLimit": 10,
  "notifyOnlyChanges": true,
  "proxyConfiguration": {
    "useApifyProxy": false
  },
  "sendErrorReports": true
}
```

# Actor output Schema

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

No description

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

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {
    "channels": [
        "durov"
    ],
    "maxPostsPerChannel": 20,
    "proxyConfiguration": {
        "useApifyProxy": false
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("tsutseisoftware/telegram-channel-scraper").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {
    "channels": ["durov"],
    "maxPostsPerChannel": 20,
    "proxyConfiguration": { "useApifyProxy": False },
}

# Run the Actor and wait for it to finish
run = client.actor("tsutseisoftware/telegram-channel-scraper").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print(f"💾 Check your data here: https://console.apify.com/storage/datasets/{run.default_dataset_id}")
for item in client.dataset(run.default_dataset_id).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{
  "channels": [
    "durov"
  ],
  "maxPostsPerChannel": 20,
  "proxyConfiguration": {
    "useApifyProxy": false
  }
}' |
apify call tsutseisoftware/telegram-channel-scraper --silent --output-dataset

```

## MCP server setup

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