# Telegram Channel Scraper: New Posts Only (`stratasignalsystems/telegram-channel-monitor`) Actor

Track public Telegram channels on a schedule, search inside them by keyword, and pay only for new posts. No account, phone number or API key. Unofficial.

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

## Pricing

from $0.30 / 1,000 posts

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

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: New Posts Only

**Track public Telegram channels on a schedule, search inside them by keyword, and pay only for posts you haven't seen.** No Telegram account, phone number or API key.

Add your channels, add keywords if you only want matching posts, turn on **Only posts I haven't received**, and schedule it. Each run returns just what's new, with text, views, reactions, links and media.

### Who it's for

- **News and OSINT analysts:** follow official, regional and news channels as they post.
- **Brand and market researchers:** keep a running record of competitor and industry channels.
- **Crypto and finance watchers:** capture announcements from project and market channels.
- **Developers:** feed new posts into your own app, database or alerts through the Apify API.

### Quick start

```json
{
  "channels": ["telegram", "@durov", "https://t.me/s/telegram"],
  "max_posts_per_channel": 50,
  "only_new": true
}
```

Channel names, `@handles` and `t.me` links all work.

### Search inside channels

```json
{
  "channels": ["telegram", "durov"],
  "keywords": ["stories", "premium"],
  "only_new": true
}
```

Add **Keywords** to get only matching posts from your channels, using Telegram's own live search. A post that matches several keywords is returned, and charged, once. Each row lists what it matched in `matched_keywords`.

Telegram also matches word variants and text the preview doesn't show, so some results won't contain your exact word. `keyword_in_text` shows whether a keyword literally appears in the post's text, so you can filter on it.

**Search covers the channels you list. It doesn't search all of Telegram.**

**To get only new posts on a schedule:**

1. Add your channels and turn on **Only posts I haven't received**.
2. Save it as a task and click **Schedule**, for example hourly.
3. Connect the results with a webhook or integration, or download them.

The first run returns recent posts. Later runs return only what's new, tracked for each keyword if you use them. For several separate lists, give each a **Monitor name**.

### What you get

```json
{
  "channel": "telegram",
  "channel_name": "Telegram News",
  "channel_subscribers": 9200000,
  "post_id": 460,
  "post_url": "https://t.me/telegram/460",
  "posted_at": "2026-08-26T19:12:34Z",
  "text": "Example post text",
  "type": "photo",
  "views": 2260000,
  "edited": false,
  "links": ["https://example.com/page"],
  "photos": ["https://example.com/photo.jpg"],
  "videos": [],
  "reactions": [{ "emoji": "👍", "count": 54700 }],
  "forwarded_from": null,
  "reply_to_id": null,
  "matched_keywords": ["stories"],
  "keyword_in_text": true
}
```

`matched_keywords` and `keyword_in_text` appear when you use keywords.

The run's `OUTPUT` record lists each channel's status, so you can see what worked at a glance.

### What it costs

You pay **$0.30 per 1,000 posts** and **$0.0005 per run**, plus a small Apify platform charge for compute and storage.

| Example | Posts | Event charges |
|---|---|---|
| One-off: 20 channels, 50 posts each | 1,000 | About $0.30 |
| Hourly check that finds nothing new | 0 | $0.0005 per run |
| Hourly monitor collecting 100 new posts a day | 3,000 a month | About $1.26 a month |

Repeat posts aren't charged when **Only posts I haven't received** is on.

### Good to know

- **Posts per channel with keywords:** the limit applies to each keyword.
- **Public channels only:** it works where the channel's web preview is on. Others are reported as `no_preview`. Private channels, groups and invite links aren't supported.
- **Rounded numbers:** views and subscribers are rounded the way Telegram shows them, such as 1.2K.
- **Media links can expire:** download what you need.
- **Rate limits:** Telegram may limit fast readers. Affected channels are reported as `rate_limited`, and posts already read are kept.

### Terms and responsible use

This is an unofficial tool, not affiliated with or endorsed by Telegram. It reads the same public preview anyone can open in a browser. **You are responsible for your use of the data**, including under [Telegram's terms](https://telegram.org/tos/content-licensing), copyright and privacy law. Telegram prohibits using its data to train or develop AI models, so don't use this actor for that. Posts can contain personal data.

# Actor input Schema

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

Public channel names, @handles or t.me links. Text after # is ignored.

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

Optional. Return only posts matching these words inside the channels above, using Telegram's own search. Leave empty for all posts.

## `max_posts_per_channel` (type: `integer`):

Stop reading a channel after this many posts. With keywords, this applies to each keyword.

## `since` (type: `string`):

30m, 6h, 1d or 1w. Leave empty for no age limit.

## `only_new` (type: `boolean`):

Remembers the newest post per channel between your runs, so scheduled runs return only what is new.

## `monitor_name` (type: `string`):

With only new posts on, separate monitors keep separate memory. Leave empty if you run just one.

## `concurrency` (type: `integer`):

Raise with care: Telegram may limit fast readers.

## Actor input object example

```json
{
  "channels": [
    "telegram"
  ],
  "max_posts_per_channel": 50,
  "only_new": false,
  "concurrency": 4
}
```

# Actor output Schema

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

One item per post: channel, link, time, text, type, views, links, media URLs, reactions, forwarding source and replies.

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

Total posts and each channel's status: ok, no_preview, rate_limited, invalid or skipped.

# 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("stratasignalsystems/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("stratasignalsystems/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 stratasignalsystems/telegram-channel-monitor --silent --output-dataset

```

## MCP server setup

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