# Telegram New Posts Monitor & Channel Discovery (`monkey.d.scraping/telegram-new-posts-monitor-channel-discovery`) Actor

Monitor public Telegram channels for new posts, detect changes without duplicates, and optionally discover relevant channels by topic or keyword. No Telegram login required.

- **URL**: https://apify.com/monkey.d.scraping/telegram-new-posts-monitor-channel-discovery.md
- **Developed by:** [Monkey D. Scraping](https://apify.com/monkey.d.scraping) (community)
- **Categories:** Social media, Automation, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.80 / 1,000 new telegram results

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/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
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.
Actors are written with capital "A".

## 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.
The best way to integrate Actors is as follows.

- **AI agents and MCP clients** — the [Apify MCP server](https://docs.apify.com/integrations/mcp.md) at `https://mcp.apify.com` (remote, streamable HTTP, OAuth on first use).
- **Agentic workflows and local Actor development** — [Agent Skills](https://apify.com/.well-known/agent-skills/index.json) with the [Apify CLI](https://docs.apify.com/cli/docs.md): `npm install -g apify-cli`, then `apify login`.
- **JavaScript/TypeScript projects** — the official [JS/TS client](https://docs.apify.com/api/client/js/docs.md): `npm install apify-client`.
- **Python projects** — the official [Python client](https://docs.apify.com/api/client/python/docs.md): `pip install apify-client`.
- **Any other language** — the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).

# README

## Telegram New Posts Monitor & Channel Discovery

Stateful Telegram monitoring for recurring workflows. Track public Telegram channels, detect and export only newly published posts, preserve checkpoints between runs, and optionally discover relevant public channels by keyword or topic — with no Telegram login or user credentials required.

Built for crypto intelligence, brand monitoring, competitor research, news tracking, community analytics, and lead-generation workflows that need reliable Telegram data over time. Private, invite-only, deleted, and login-protected content is not collected.

### What it returns

Each dataset row is one canonical public post and can include its public URL, channel information, timestamp, text, displayed views, structured reactions, media references, links, hashtags, mentions, and forward label. Values that are not publicly available are `null`; the Actor does not invent engagement, author, date, or reply data. Media download is not performed.

### Start in three steps

1. Add one or more public channel usernames or URLs.
2. Leave **Create a baseline** selected for the first run.
3. Create an Apify schedule. Future successful runs write only new posts to the dataset.

For a topic-led starting point, add **Discovery topics**. Discovery is optional and may return different public candidates over time, so keep important sources in **Public channels** for stable coverage.

### First run versus later runs

| First-run setting | Dataset on first run | Later runs |
| --- | --- | --- |
| Create a baseline | Empty by design | Only posts newer than the saved checkpoint |
| Return recent posts now | Recent public posts, up to your cap | Only newer posts afterward |

An empty dataset is therefore often the expected result: either the Actor has just created a baseline or no monitored channel has posted something new.

### Reliable incremental monitoring

The Actor stores a private checkpoint for the current Apify user. Checkpoints are separate from the run dataset, so scheduled runs can compare the latest public posts with the prior position. If a channel has a larger backlog than the selected per-run cap, the Actor reports it in `SUMMARY` and continues safely on a later run instead of silently skipping messages.

### Example input

```json
{
  "channels": ["cointelegraph", "the_block_crypto"],
  "initialRun": "baseline",
  "maxPostsPerChannel": 20,
  "maxPagesPerChannel": 5
}
```

### Practical use cases

- Track crypto, finance, energy, regulatory, or brand-news channels.
- Feed new public Telegram posts into Make, n8n, Zapier, webhooks, spreadsheets, or a data warehouse.
- Build a review queue for analysts without retaining the same historical posts every day.
- Discover candidate public channels by topic, then promote useful sources into a stable monitoring list.

### Choose the right Telegram workflow

| Need | This Actor: New Posts Monitor | Keyword Search & Channel Scraper | Best fit |
| --- | --- | --- | --- |
| One-time historical extraction | Not the main purpose; baseline is silent by default | Yes, with keyword, channel, or hybrid collection | Research and export |
| Receive only future public posts | Yes, with persistent checkpoint per task | No; each run is stateless | Alerts and recurring feeds |
| Discover channels by a topic | Optional, via public SERP discovery | Yes, with verified keyword matches | Source discovery |
| Monitor known channels reliably | Yes, recommended path | Yes, but each run repeats extraction | Scheduled monitoring |
| Avoid duplicate posts across runs | Yes, checkpoint plus canonical post identity | Yes, within each run | Stateful monitoring: this Actor |

For a one-time dataset, use **Telegram Keyword Search & Channel Scraper**. For recurring “what changed since the last run?” workflows, use this monitor. Both Actors collect public content only, require no Telegram credentials, and return `null` when a public field is unavailable.

#### SEO/GEO use-case examples

- **Crypto Telegram monitoring:** track new public posts from selected crypto news channels every hour.
- **Brand and competitor alerts:** monitor public channels for fresh company announcements and market mentions.
- **Energy and policy intelligence:** maintain a rolling feed of new public posts in a selected country/language discovery context.
- **Multilingual research operations:** combine known channels with optional topic discovery using country and language preferences.

### Limits and responsible use

Results depend on what Telegram exposes publicly and may be affected by source changes, availability, rate limits, or indexing coverage. This Actor is for public data only. Respect applicable law, platform terms, and the expectations of the communities you monitor.

# Actor input Schema

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

Public usernames, @usernames, or public Telegram URLs. Private and invite-only channels are not supported.

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

Safety cap for one monitoring cycle. Larger backlogs continue safely in later runs.

## `maxPagesPerChannel` (type: `integer`):

Increase for very active channels or longer gaps between schedules.

## `discoveryKeywords` (type: `array`):

Words or phrases used to find publicly indexed Telegram channels. Leave empty to monitor only the channels above.

## `countryCode` (type: `string`):

Optional discovery preference, not a channel-location filter. Example: IT.

## `languageCode` (type: `string`):

Optional discovery preference, not automatic language classification. Example: it.

## `maxDiscoveredChannels` (type: `integer`):

Safety cap for topic discovery. Known channels are always retained separately.

## `initialRun` (type: `string`):

Baseline stores the current position silently; emit recent returns recent public posts immediately.

## `resetState` (type: `boolean`):

Off by default. Use only to create a fresh baseline or intentionally replay recent posts.

## Actor input object example

```json
{
  "channels": [
    "cointelegraph"
  ],
  "maxPostsPerChannel": 5,
  "maxPagesPerChannel": 2,
  "discoveryKeywords": [],
  "maxDiscoveredChannels": 20,
  "initialRun": "emitRecent",
  "resetState": false
}
```

# Actor output Schema

## `newPosts` (type: `string`):

Only posts that are new relative to this user's saved monitoring state. A successful run with an empty dataset means no new public posts were found.

## `runSummary` (type: `string`):

Counts for channel coverage, discovery, baselines, pending backlog, duplicates, and isolated non-sensitive errors.

## `checkpointCopy` (type: `string`):

A private copy of the current run's monitor state. The reusable state itself remains in this user's named key-value store.

# 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 = {};

// Run the Actor and wait for it to finish
const run = await client.actor("monkey.d.scraping/telegram-new-posts-monitor-channel-discovery").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 = {}

# Run the Actor and wait for it to finish
run = client.actor("monkey.d.scraping/telegram-new-posts-monitor-channel-discovery").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 '{}' |
apify call monkey.d.scraping/telegram-new-posts-monitor-channel-discovery --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,monkey.d.scraping/telegram-new-posts-monitor-channel-discovery"
        }
    }
}

```

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/aGIR3GOdV0nxcntf2/builds/XjyV3whRS3XkeJeSe/openapi.json