# Telegram Channel Scraper & Monitor: Public Posts, No Login (`steady-scrape/telegram-channel-monitor`) Actor

Get posts from public Telegram channels without a login or API key: text, date, views, links, media type and channel stats. Monitor mode returns only posts newer than the last run. Channels only, no members or personal data.

- **URL**: https://apify.com/steady-scrape/telegram-channel-monitor.md
- **Developed by:** [SteadyScrape](https://apify.com/steady-scrape) (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.80 / 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 & Monitor: Public Posts, No Login

Collect posts from public Telegram channels without a Telegram account, phone number or API key. For each post you get the text, publish date, view count, links, link-preview title, media type, edited and forwarded flags, plus the channel's title and subscriber count. **Monitor mode** returns only posts published since the last run. **$0.0008 per post + $0.001 per channel + $0.0005 per run**: 20 recent posts from 10 channels cost about $0.17.

Built for news and market monitoring, crypto and OSINT research, brand tracking and LLM pipelines that need clean JSON from public channels.

### Use cases

- **News and alert feeds:** schedule monitor mode hourly on a list of news channels and push only new posts to Slack, email or a webhook.
- **Crypto and markets:** follow project announcement channels and catch listings, launches and updates as soon as they post.
- **Brand and competitor watch:** track what competitors and industry channels publish, with views as a reach signal.
- **Research datasets:** backfill up to 1,000 posts per channel with dates and views for analysis.
- **RAG and AI agents:** feed fresh channel posts into a vector store or let an agent read a channel on request.

### What it does and doesn't do

- Public **channels** with a web preview. Usernames, `@names` and `t.me` links all work.
- Newest posts first, up to 1,000 per channel, with an optional "posted after" date.
- Channel stats in the run summary: title, subscribers, verified badge, description.
- **Not supported:** private channels and invite links, group member lists, comments, user profiles, phone numbers, or media downloads. Author signatures and forwarded-from names are not collected.

### How to use it

1. List channels in **Public channels**.
2. Choose how many recent posts per channel, and optionally a "posted after" date.
3. Run. Posts go to the dataset; the `OUTPUT` record has each channel's status and stats.
4. For only-new posts, pick **Monitor** mode and schedule the Actor (hourly or daily).

#### Input example

```json
{"channels": ["telegram", "@durov", "https://t.me/bbcbreaking"], "maxPostsPerChannel": 20, "mode": "monitor", "monitorId": "news"}
```

#### Output example

```json
{"channel": "telegram", "postId": 412, "postUrl": "https://t.me/telegram/412", "date": "2026-11-12T14:00:05+00:00",
 "text": "Telegram's November update ...", "views": 2430000, "isEdited": false, "isForwarded": false,
 "mediaTypes": ["video"], "links": ["https://telegram.org/blog/..."], "linkPreviewUrl": null,
 "channelTitle": "Telegram News", "channelSubscribers": 9800000}
```

| channel | date | views | mediaTypes | text |
|---|---|---|---|---|
| telegram | 2026-11-12 14:00 | 2,430,000 | video | Telegram's November update ... |

### Pricing (pay per event)

| Event | Price | When |
|---|---|---|
| Actor start | $0.0005 per run | Charged by Apify when the run starts (up to 1 GB memory). |
| Channel checked | $0.001 | Each channel looked up, including checks with no new posts and names with no public channel. |
| Post | $0.0008 | Each post returned. In monitor mode, only new posts. |

**Cost examples**

- 10 channels × 20 recent posts: $0.0005 + $0.010 + $0.160 = **$0.1705**
- Hourly monitor of 10 channels, 5 new posts per run: $0.0005 + $0.010 + $0.004 = **$0.0145 per run**
- Backfill 1 channel × 1,000 posts: $0.0005 + $0.001 + $0.80 = **$0.8015**

Not charged: invalid names (never requested), lookups Telegram fails to answer after retries, already-seen posts, posts filtered by date, and mock runs. The default maximum charge per run is $1.00; the run stops before going over your limit.

**Free Apify plan:** up to 3 channels and 50 posts per channel per run.

### How it compares

- Versus the Telegram API (Telethon/Pyrogram): no account, phone number, API keys or session files, and no risk to a personal account.
- Versus browser scrapers: no headless browser, so runs are fast and cheap.
- Trade-off: public channels with a web preview only; no groups, comments or media files.

### Use it from an AI agent (Apify MCP)

```json
{"mcpServers": {"apify": {"url": "https://mcp.apify.com?tools=steady-scrape/telegram-channel-monitor"}}}
```

Then ask: *"Summarize the last 20 posts of @durov and t.me/telegram."* Prices above and your maximum charge apply.

### Integrations

Schedule it in Apify, call it via the Apify API, or send new posts to Make, Zapier, n8n, Slack, Google Sheets or a webhook with Apify integrations.

### Good to know

- Some channels disable the web preview; they show as `not_found`.
- View counts are rounded the way Telegram shows them (for example 1.2M).
- Requests are paced politely; very large backfills take a few minutes.

### FAQ

**Do I need a Telegram account?** No.

**Can I scrape groups or users?** No, only public channel posts.

**Why was a channel charged with zero posts?** It was checked: in monitor mode there were no new posts, or the name has no public channel. Invalid names are never requested and never charged.

**Can AI agents use it?** Yes, via the Apify API or MCP server; the input is small with safe defaults.

### More tools from SteadyScrape (steady-scrape)

- [Google News Monitor](https://apify.com/steady-scrape/google-news-monitor): brand and topic alerts with only new articles.
- [Polymarket Scraper & Odds API](https://apify.com/steady-scrape/prediction-markets): prediction-market odds and volumes.
- [YouTube Transcript Scraper & API](https://apify.com/steady-scrape/youtube-transcripts): subtitles and captions for any video.
- [AI Page to JSON](https://apify.com/steady-scrape/ai-page-to-json): turn linked pages into structured JSON.

Built and maintained by **SteadyScrape (steady-scrape)**. Not affiliated with Telegram. Questions? Open an issue on the Issues tab.

# Actor input Schema

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

Channel usernames or links: durov, @durov or https://t.me/durov. Public channels with a web preview only; private invite links are not supported.

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

Newest posts to return per channel (1-1000). In monitor mode: the most new posts per run.

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

Only posts published after this date (UTC).

## `mode` (type: `string`):

Monitor mode remembers the newest post per channel and Monitor ID. The first run returns the newest posts. Schedule it hourly or daily.

## `monitorId` (type: `string`):

Name for a monitor's memory (letters, digits, . \_ -).

## `mock` (type: `boolean`):

Returns bundled sample posts without contacting Telegram. Nothing is charged.

## Actor input object example

```json
{
  "channels": [
    "telegram"
  ],
  "maxPostsPerChannel": 20,
  "mode": "oneOff",
  "monitorId": "default",
  "mock": false
}
```

# 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": [
        "telegram"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("steady-scrape/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": ["telegram"] }

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

```

## MCP server setup

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