# Telegram Channel Scraper & Keyword Monitor (`signalscope-data/telegram-channel-monitor`) Actor

Scrape posts, views, reactions, comments & media from public Telegram channels, with virality scores, channel analytics (ERR), subscriber growth tracking and a similar-channel finder. No login. $1 / 1,000 posts.

- **URL**: https://apify.com/signalscope-data/telegram-channel-monitor.md
- **Developed by:** [Bin](https://apify.com/signalscope-data) (community)
- **Categories:** Social media, News, Automation
- **Stats:** 2 total users, 1 monthly users, 23.1% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 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.

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 & Keyword Monitor

Scrape **posts, views, reactions, links and media from any public Telegram channel** — no Telegram account, no API key, no phone number. Turn on **keyword alerts** and **new-posts-only mode** to monitor crypto, news, OSINT, brand mentions or competitors on a schedule — or get **TGStat-style channel analytics** (ERR, average views, posting frequency, best time to post, forward sources) for any public channel — and **find similar Telegram channels** in a niche from a few seed channels.

### Why use it

- 🔓 **No login or API keys** — reads Telegram's public web preview (`t.me/s/channel`).
- 📈 **Rich data** — text, date, author signature, views, reactions (per emoji + total), **engagement rate**, outbound links, link previews (title + description), forwarded-from, reply-to link, edited flag.
- 🖼️ **Media URLs** — direct photo and video URLs, video thumbnails and durations.
- \#️⃣ **Hashtags & @mentions** extracted from every post, plus **polls** (question, options, % per option) and file names.
- 🔥 **Popular-posts filter** — `minViews` keeps only posts above a view threshold (you don't pay for skipped posts).
- 🚀 **Virality score (new)** — every post gets `viralityScore` = its views ÷ the median views of the ~20 own posts published around it (age-matched, because Telegram views keep growing for weeks), plus `isViral` (2×+), `viewsPerSubscriberPct` and `viewsStillGrowing`. `minViralityScore: 2` outputs only the posts that beat the channel's normal reach — works across channels of any size, unlike a fixed view threshold. Analytics rows add `viralPosts`, `viralShare` and `maxViralityScore`.
- 🔔 **Monitoring** — `onlyNewPosts` remembers the last post per channel, so scheduled runs return only fresh posts. You never pay twice for the same post.
- 🎯 **Keyword alerts** — output only posts mentioning your brand, tickers, CVEs, cities…
- 🔎 **Full-history keyword search** — `searchFullHistory` uses Telegram's own in-channel search, so a keyword finds matching posts from **years back**, not just among the latest posts. No need to download a whole channel to find 20 mentions.
- 💬 **Comments** — `includeComments` adds `commentCount` and the latest comments (text, date, reply-to, reactions; up to 100 per post) for channels with a public discussion group — audience reaction and sentiment, not just views. Commenter identities are not collected.
- 🔗 **Direct post links** — paste `https://t.me/durov/300` to get exactly that post (views, reactions, media).
- 📉 **Channel analytics** — `includeAnalytics` adds one row per channel: posts per week, average/median views, **ERR** (views per subscriber %), engagement rate, views trend, **best weekday & hour to post**, content mix with average views per type (photo/video/text/link/poll), top 5 posts, top hashtags, mentioned channels, **forward sources** (the channels it reposts from — great for finding related channels) and linked domains. `analyticsOnly` skips post rows to compare many channels cheaply.
- 🧭 **Similar / related channel finder** — `discoverRelatedChannels` turns the channels your seeds forward from, link to (`t.me/...`) or @mention into ranked `related-channel` rows: title, description, subscribers, **relevance score**, which seeds reference it, last post date, recent average views and ERR. Every candidate is checked to be a public channel — users, bots and groups are never output. `relatedChannelsOnly` skips post rows. No login or subscriber-overlap data needed.
- 📊 **Channel stats** — title, description, **exact subscriber count** (10,480,121 — not the rounded "10.5M" of the preview page), photo/video/link counts.
- 📈 **Subscriber growth tracking (new)** — every run saves a snapshot per channel (subscribers + median views of recent posts). Schedule it daily and each channel row gets `subscribersChange` since the last run, **`subscribersChange7d` / `subscribersChange30d` (count and %)**, `avgDailySubscriberGrowth`, `growthTrend` (growing / flat / shrinking), `recentMedianViewsChange7dPct` (is reach rising or falling?) and a `subscriberHistory` of the last 14 snapshots. With 2+ channels a `GROWTH` record ranks them by growth. TGStat-style growth charts for your own watchlist, without an account.
- 📚 **History** — paginates back through older posts (set `maxPostsPerChannel`).

### Use cases

- **Crypto & trading signals** — track announcement and alpha channels, get new posts within minutes.
- **News & OSINT** — monitor breaking-news and conflict channels by keyword.
- **Brand monitoring** — find mentions of your product or company.
- **Market research / influencer analysis** — compare engagement (views, reactions) across channels.
- **Content research** — find what actually overperforms in a niche: `minViralityScore: 2` over 10 competitor channels returns only their breakout posts (topic, format, hour), ready to copy the pattern.
- **Competitor & channel growth tracking** — a daily schedule over your and your competitors' channels shows who gains subscribers, who loses them, and whether reach keeps up (`trackGrowth`, on by default).
- **Telegram ad buying** — vet a channel before paying for a post: real reach (ERR), views trend, posting frequency and whether it mostly reposts others (`includeAnalytics`).
- **Niche mapping & ad-placement lists** — start from 3–5 channels you know, get the 20–100 related channels with subscribers and real reach (ERR), and spot active vs abandoned ones (`relatedChannelsOnly`).
- **Audience sentiment** — read what subscribers say under announcements, launches or news (`includeComments`).
- **AI datasets** — collect channel content for summarization, sentiment or RAG.

### Input example

```json
{
  "channels": ["durov", "@telegram", "https://t.me/s/bbcnews"],
  "maxPostsPerChannel": 100,
  "keywords": ["airdrop", "listing"],
  "minViews": 5000,
  "onlyNewPosts": true,
  "stateKey": "crypto-alerts"
}
```

Find every post that ever mentioned a topic, across the whole channel history:

```json
{
  "channels": ["durov", "tginfo"],
  "keywords": ["privacy"],
  "searchFullHistory": true,
  "maxPostsPerChannel": 200
}
```

Posts with their comment threads (comment count + latest 30 comments):

```json
{
  "channels": ["tginfo"],
  "maxPostsPerChannel": 20,
  "includeComments": true,
  "maxCommentsPerPost": 30
}
```

Channel analytics only — compare channels before buying ads (no post rows, one analytics row each):

```json
{
  "channels": ["durov", "tginfo", "cointelegraph"],
  "maxPostsPerChannel": 150,
  "analyticsOnly": true
}
```

Find related channels in a niche — one row per related public channel, best first:

```json
{
  "channels": ["meduzalive", "readovkanews", "tginfo", "durov"],
  "maxPostsPerChannel": 200,
  "relatedChannelsOnly": true,
  "maxRelatedChannels": 20,
  "minRelatedSubscribers": 5000
}
```

### Output example

```json
{
  "type": "post",
  "channel": "durov",
  "postId": 548,
  "url": "https://t.me/durov/548",
  "date": "2026-09-11T16:04:02.000Z",
  "text": "Telegram has become the sponsor of Codeforces ... #contest @codeforces_official",
  "author": "Pavel Durov",
  "views": 1990000,
  "reactions": [{ "emoji": "👍", "count": 51000 }],
  "reactionsTotal": 70360,
  "engagementRate": 0.0354,
  "media": ["video"],
  "mediaItems": [{ "type": "video", "url": "https://cdn4.telesco.pe/file/....mp4", "thumbnail": "https://cdn4.telesco.pe/file/....jpg", "duration": "0:20" }],
  "links": ["https://codeforces.com/blog/entry/156620"],
  "hashtags": ["#contest"],
  "mentions": ["@codeforces_official"],
  "linkPreview": "https://codeforces.com/blog/entry/156620",
  "linkPreviewTitle": "Telegram Returns as Title Sponsor of Codeforces!",
  "poll": null,
  "document": null,
  "forwardedFrom": null,
  "replyToUrl": null,
  "matchedKeywords": []
}
```

Every post also carries virality fields (real values for @durov post 527, the $200,000 contest announcement, June 2026):

```json
{
  "views": 24300000,
  "channelMedianViews": 7040000,
  "viralityScore": 3.45,
  "isViral": true,
  "viewsPerSubscriberPct": 231.4,
  "viewsStillGrowing": false
}
```

With `includeComments` each post also has:

```json
{
  "commentsEnabled": true,
  "commentCount": 137,
  "comments": [
    { "commentId": 1810549, "date": "2026-04-14T03:45:22.000Z", "text": "Great idea, finally ...", "replyToCommentId": null, "hasMedia": false, "reactions": [], "reactionsTotal": 0 }
  ]
}
```

Channel analytics row (`type: "channel-analytics"`, real numbers from the latest 150 posts of @cointelegraph, shortened):

```json
{
  "type": "channel-analytics",
  "channel": "cointelegraph",
  "subscribers": 332000,
  "basis": "latest-posts",
  "postsAnalyzed": 150,
  "periodStart": "2026-09-22T19:25:01.000Z",
  "periodEnd": "2026-10-06T13:30:03.000Z",
  "postsPerWeek": 76.3,
  "avgViews": 9681,
  "medianViews": 9630,
  "errPct": 2.9,
  "engagementRate": 0.0075,
  "viewsTrendPct": -9.7,
  "bestWeekdayUtc": "Wednesday",
  "bestHourUtc": 11,
  "byWeekday": [{ "weekday": "Wednesday", "posts": 26, "avgViews": 10080 }],
  "contentMix": [{ "kind": "photo", "posts": 123, "avgViews": 9699, "share": 0.885 }],
  "forwardedShare": 0,
  "withLinksShare": 0.987,
  "topLinkDomains": [{ "domain": "cointelegraph.com", "count": 148 }],
  "forwardSources": [],
  "topPosts": [{ "url": "https://t.me/cointelegraph/72272", "views": 15500, "kind": "photo" }]
}
```

For a news aggregator like @meduzalive, `forwardSources` lists the channels it reposts: `meduza_news` (11 posts), `plottwist_m` (3), `meduza_books` (2).

Related channel row (`type: "related-channel"`, real result from the run above, shortened):

```json
{
  "type": "related-channel",
  "channel": "betainfo",
  "url": "https://t.me/betainfo",
  "title": "Beta Info",
  "subscribers": 25600,
  "relevanceScore": 58,
  "seedChannels": ["tginfo"],
  "seedCount": 1,
  "forwardsFromSeeds": 0,
  "linksFromSeeds": 29,
  "mentionsBySeeds": 0,
  "examplePostUrl": "https://t.me/tginfo/4435",
  "lastPostAt": "2026-10-06T21:14:00.000Z",
  "daysSinceLastPost": 0.4,
  "recentAvgViews": 7154,
  "recentPostsMeasured": 17,
  "errPct": 27.9
}
```

Other related channels found from those 4 seeds: `meduza_news` (122K subscribers, 15 forwards), `tandroidapk` (258K), `uranews` (220K), `contest` (referenced by both tginfo and durov), `plottwist_m`, `alfabank`…

Channel record (`type: "channel"`): `title`, `description`, `subscribers`, `photos`, `videos`, `links`, `verified`, `image`.

### Pricing

- **$1 per 1,000 posts**
- **$2 per 1,000 channel-info records**
- **$0.01 per channel-analytics row** (only with `includeAnalytics` / `analyticsOnly`; with `analyticsOnly` posts are not charged)
- **$0.003 per related-channel row** (only with `discoverRelatedChannels` / `relatedChannelsOnly`; with `relatedChannelsOnly` posts and channel info are not charged)

No subscription. In monitoring mode, already-seen posts are never charged again.

### Scheduling alerts

1. Set `onlyNewPosts: true`, add keywords (optional), name the monitor.
2. Create a Schedule in Apify Console (e.g. every 15 minutes or hourly).
3. Connect Slack, Telegram bot, email, Google Sheets, webhook, Zapier or Make to receive new posts automatically.

### Limits

Works for **public channels** that have web preview enabled. Private channels, groups and bots are not supported. Only publicly visible data is collected. Subscriber growth starts with your first run — past growth before that is not available from Telegram.

### FAQ

**Do I need a Telegram account, bot token or API ID?** No. The Actor reads the public web preview at `t.me/s/<channel>`.

**How long are media URLs valid?** Photo/video URLs point to Telegram's CDN and contain a temporary token — download files soon after the run if you need copies.

**How do I get only viral posts?** Set `minViralityScore` to `2`: only posts with at least twice the views of the posts published around them in the same channel are output (skipped posts are not charged). Unlike `minViews`, this works for a 5K-subscriber channel and a 10M one in the same run. In our test over the latest 100 posts, @telegram had 1 viral post, @tginfo 2 and @durov 12 (his June 2026 contest and UK-ban posts at 3–3.5× his usual reach). You can still use `minViews` (e.g. 50000) for an absolute threshold, and `sinceDate` for "top posts this week".

**How is `viralityScore` calculated?** Post views ÷ `channelMedianViews`, the median views of up to 10 own posts published just before and 10 just after it (at least 5 needed). Comparing posts of a similar age matters because Telegram views keep growing for weeks: against the channel's overall average, old posts would always look viral. Forwarded posts show the original post's views, so they get no score. The very newest posts are compared mostly with older posts and score lower until their views catch up (`viewsStillGrowing` marks posts younger than 24 h), so for alerts on fresh posts use 1.5 instead of 2. With `onlyNewPosts` the channel's latest page is used as context, so even 1–3 new posts get a score.

**What is `engagementRate`?** Total reactions ÷ views for the post — handy for comparing channels of different sizes.

**How is "Search full channel history" different from keywords alone?** Without it, the Actor reads the latest `maxPostsPerChannel` posts and keeps those that contain a keyword. With it, Telegram's own search finds matches anywhere in the channel's history (e.g. Durov's posts about "privacy" back to 2022), and `maxPostsPerChannel` limits the number of matches. It also works with `onlyNewPosts` for alerts.

**Can I scrape specific posts?** Yes — add post links like `https://t.me/durov/300` to `channels`. Each returns one post record.

**Can it scrape comments?** Yes — turn on `includeComments`. Works for channels that have a public discussion group (comments under posts); you get `commentCount` plus the latest comments (up to 100 per post, set `maxCommentsPerPost`; 0 = count only). For channels without comments `commentsEnabled` is `false` and, after 3 posts, the Actor stops checking that channel so runs stay fast. Comment rows contain text, date, reply-to and reactions only — no commenter names or usernames. There is no extra charge for comments.

**What is ERR and how are the analytics calculated?** ERR = average views per post ÷ subscribers (the standard Telegram reach metric; above ~20% is typical of a healthy channel, low single digits often means inactive or bought subscribers). All analytics are computed from the posts the run scanned (`maxPostsPerChannel`; with `searchFullHistory` — the matching posts, see `basis`). View metrics skip posts younger than 24 hours because their views are still growing. Weekdays and hours are in UTC. No AI is used, so numbers are reproducible.

**How do I find similar / related Telegram channels?** Turn on `relatedChannelsOnly` and give 3–5 seed channels from the niche. The Actor scans their latest posts (`maxPostsPerChannel`, 200+ recommended), collects every channel they forward from (weight 3), link to with `t.me/...` (weight 2) or @mention (weight 1), adds +5 for each extra seed referencing the same channel, checks that each candidate is a public channel and outputs the best `maxRelatedChannels` with subscribers and ERR. Feed the results back in as seeds to go one level deeper.

**How is this different from "similar channels" by subscriber overlap?** Subscriber-overlap tools need a logged-in Telegram account. This Actor uses only public posts: a related channel is one your seeds actually repost, promote or link to — which is exactly how Telegram cross-promotion and ad placements work. Channels that never interact with your seeds won't appear; use more seeds or more posts for wider coverage.

**How does subscriber growth tracking work?** Telegram does not publish a channel's subscriber history, so the Actor builds it: each run stores one snapshot per channel (exact subscribers and the median views of recent own posts older than a day) under your `stateKey`. The first run starts the history; from the second run on you get `subscribersChange`, and once the history covers about a week / a month, `subscribersChange7d` / `subscribersChange30d` (the snapshot closest to 7 days ago, ±2 days; 30 days ±6). Runs less than an hour apart replace the last snapshot instead of adding one. Up to 120 snapshots are kept per channel. Use a different `stateKey` per schedule, or the same one to share a history. Set `trackGrowth: false` to turn it off.

**Does growth tracking cost extra?** No. It adds one request per channel (the channel page with the exact subscriber count) and no extra rows.

**Can it scrape private groups?** No — only public channels that Telegram shows on its web preview.

### More tools from the same developer

- [Company Jobs Scraper](https://apify.com/signalscope-data/ats-jobs-scraper) — every open job from Workday, Greenhouse, Lever, Ashby, Personio & more, with salaries and new-job alerts.
- [Workday Jobs Scraper](https://apify.com/signalscope-data/workday-jobs-scraper) — any myworkdayjobs.com careers site.
- [App Store & Google Play Reviews Scraper](https://apify.com/signalscope-data/app-reviews-scraper) — reviews, ratings and new-review monitoring.
- [Shopify Products Scraper & Price Change Monitor](https://apify.com/signalscope-data/shopify-store-monitor) — catalogs plus price-drop / restock alerts.
- [Hacker News "Who is Hiring" Parser](https://apify.com/signalscope-data/hn-hiring-parser) — monthly HN hiring threads as structured jobs.

# Actor input Schema

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

Public channel usernames or links: "durov", "@telegram", "https://t.me/s/bbcnews". Direct post links ("https://t.me/durov/300") return just that post.

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

How many latest posts to scan per channel (newest first).

## `keywords` (type: `array`):

Output only posts containing ANY of these words (case-insensitive). Leave empty for all posts.

## `searchFullHistory` (type: `boolean`):

Use Telegram's built-in channel search to find posts matching your keywords across the ENTIRE channel history (years back), instead of only filtering the latest posts. "Max posts per channel" then limits the number of matching posts. Telegram search also matches word forms (e.g. "wallet" finds "wallets").

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

Output only posts with at least this many views (e.g. 10000 to keep only popular posts). 0 = no limit. Skipped posts are not charged.

## `minViralityScore` (type: `string`):

Output only posts that beat the channel's normal reach: viralityScore = post views ÷ median views of the channel's latest own posts. 2 = at least twice the usual views (a viral post), 1.5 = clearly above average. Empty or 0 = no limit. Forwarded posts have no score (they show the original post's views) and are skipped when this is set. Skipped posts are not charged. Combine with "Only new posts" for a daily viral-post alert.

## `sinceDate` (type: `string`):

Optional ISO date, e.g. 2026-09-01. Older posts are skipped.

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

Remember the last post seen per channel and output only newer ones. Ideal for scheduled monitoring and alerts.

## `stateKey` (type: `string`):

Used with 'Only new posts'. Use a different name for each separate monitor/schedule.

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

One record per channel with title, description, subscriber count and media counts.

## `trackGrowth` (type: `boolean`):

Save a snapshot of each channel's exact subscriber count and typical reach on every run (under 'State key'), and add growth fields to channel rows: subscribersChange since the last run, 7-day and 30-day change (count and %), average daily growth, growth trend and the last 14 snapshots. Schedule the Actor daily to build the history. No extra charge.

## `includeComments` (type: `boolean`):

For channels with a public discussion group: add commentCount and the latest comments (text, date, reply-to, reactions) to each post. Commenter names/usernames are NOT included. Adds one request per post; channels without comments are detected after 3 posts and skipped.

## `maxCommentsPerPost` (type: `integer`):

How many comments to include per post (Telegram's public widget returns up to 100). 0 = only the comment count.

## `includeAnalytics` (type: `boolean`):

Add one 'channel-analytics' row per channel computed from the scanned posts: posting frequency, average/median views, ERR (views per subscriber %), engagement rate, views trend, best weekday/hour (UTC), content mix with views per type, top posts, top hashtags, mentioned channels, forward sources and linked domains. Scan more posts (e.g. 200–500) for stable numbers.

## `analyticsOnly` (type: `boolean`):

Scan the posts but output only channel info + the analytics row (posts are not output or charged). Cheapest way to compare many channels.

## `discoverRelatedChannels` (type: `boolean`):

Find similar / related public channels from the scanned posts: channels your seed channels forward from, link to (t.me/...) or @mention. Candidates are ranked by relevance (forward = 3, link = 2, mention = 1, +5 per extra seed that references them), verified as public channels and output as 'related-channel' rows with title, description, subscribers, last post date, recent average views and ERR. Users, bots and groups are never output. Use several seed channels from one niche for the best results.

## `relatedChannelsOnly` (type: `boolean`):

Scan the seed channels' posts but output only the related-channel rows (no posts, no channel info). Cheapest way to build a list of channels in a niche.

## `maxRelatedChannels` (type: `integer`):

How many related channels to output in total (best-ranked first).

## `minRelatedSubscribers` (type: `integer`):

Skip related channels with fewer subscribers than this. 0 = no limit.

## Actor input object example

```json
{
  "channels": [
    "durov",
    "telegram"
  ],
  "maxPostsPerChannel": 100,
  "searchFullHistory": false,
  "minViews": 0,
  "minViralityScore": "",
  "onlyNewPosts": false,
  "stateKey": "default",
  "includeChannelInfo": true,
  "trackGrowth": true,
  "includeComments": false,
  "maxCommentsPerPost": 20,
  "includeAnalytics": false,
  "analyticsOnly": false,
  "discoverRelatedChannels": false,
  "relatedChannelsOnly": false,
  "maxRelatedChannels": 20,
  "minRelatedSubscribers": 0
}
```

# Actor output Schema

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

No description

# API

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

## JavaScript example

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

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

// Prepare Actor input
const input = {
    "channels": [
        "durov",
        "telegram"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("signalscope-data/telegram-channel-monitor").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",
        "telegram",
    ] }

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,signalscope-data/telegram-channel-monitor"
        }
    }
}
```

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/bqGq879ZlrXymIgpE/builds/6wQfXgADHlQhttQqf/openapi.json