# Telegram Public Channel Monitor (`bgy_1203/telegram-public-channel-monitor`) Actor

Fetch recent public Telegram channel messages for scheduled n8n, AI-agent, and automation workflows. Newest-first results with no Telegram login.

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

## Pricing

from $1.00 / 1,000 results

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

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
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.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use 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 Public Channel Monitor

Monitor recent messages from a public Telegram channel and send clean, structured results into n8n, AI-agent, and data workflows.

This Actor reads Telegram's public `t.me/s/` web preview. It does not log in to Telegram, use an account session, join channels, access private channels, scrape members, or collect contact lists.

### What it returns

Each message is one dataset item with:

- channel username and public preview URL
- message ID, direct public URL, and publication date
- message text and visible view count
- forwarded-from label when shown publicly
- photo, video, and link-preview flags
- scrape timestamp

Results are deduplicated by message ID and ordered newest first. A separate `RUN-SUMMARY` record reports pages fetched, messages parsed, duplicates removed, output count, ordering, and the expected number of billable dataset items.

### Input

```json
{
  "channel": "telegram",
  "limit": 50
}
````

`channel` must be a public Telegram username without `@` or a URL. The channel must be visible at `https://t.me/s/USERNAME`. `limit` accepts 1 to 500 messages.

### Monitor-first workflows

Use a saved Actor task with an Apify schedule when you need repeatable monitoring. Downstream workflows can read the default dataset through Apify's API or integrations.

Typical flow:

1. Schedule this Actor for the public channel you monitor.
2. Pull the newest-first dataset into n8n, Make, an AI agent, or your own API client.
3. Filter on message ID or publication date in your workflow to act only on new records.
4. Check `RUN-SUMMARY` to catch empty output, markup changes, or unusual duplicate counts.

This Actor returns public source data. Alerting, summarization, classification, and notification logic stay in your downstream workflow.

### Ready-made n8n monitoring workflow

This Actor is **stateless** and fetches **one public channel per run**. For continuous, hands-off monitoring, an optional ready-made **n8n workflow** orchestrates this Actor on a schedule and adds the stateful layer on top.

**The n8n workflow (not the Actor) provides:**

- **Multi-channel monitoring** — loops your channel list, calling this Actor once per channel.
- **Persistent new-post detection** — remembers what it has already seen across runs (n8n workflow static data), so already-seen posts are not alerted again across runs.
- **Keyword filtering** — alert on any / all keywords, or off; case-sensitive or not.
- **Cross-run duplicate prevention** — per-channel message-ID tracking (the Actor only deduplicates *within* a single run).
- **Telegram alerts** — sends new matching posts to a Telegram chat via your own bot.
- **Scheduled monitoring** — runs on an interval (default every 15 minutes).

**Get it:**

- [Setup guide](https://github.com/bgyeth/telegram-public-channel-monitor-n8n/blob/main/SETUP-GUIDE.md)
- [Workflow JSON](https://github.com/bgyeth/telegram-public-channel-monitor-n8n/blob/main/workflow/telegram-public-channel-monitor.workflow.json)
- [Direct import (raw JSON)](https://raw.githubusercontent.com/bgyeth/telegram-public-channel-monitor-n8n/main/workflow/telegram-public-channel-monitor.workflow.json)

Import the JSON into n8n, add your own Apify and Telegram credentials, edit the channel list and filters, then activate. Full steps are in the setup guide.

The Actor itself remains stateless, reads only public `t.me/s/` previews, takes one channel per run, and uses no Telegram login or session — all monitoring **state, filtering, and alerting live in the n8n workflow**, not in the Actor.

### Output example

```json
{
  "channel": "telegram",
  "source_url": "https://t.me/s/telegram",
  "scraped_at": "2026-07-21T12:00:00+00:00",
  "id": 1234,
  "url": "https://t.me/telegram/1234",
  "date": "2026-07-21T11:30:00+00:00",
  "text": "Public message text",
  "views": 12500,
  "forwarded_from": null,
  "has_photo": false,
  "has_video": false,
  "has_link_preview": true
}
```

### Billing

The intended pricing model is pay per event using Apify's synthetic `apify-default-dataset-item` event. One dataset message equals one billable result. `RUN-SUMMARY` is stored in the default key-value store, so it does not create an extra dataset-item event.

### Monitoring behavior and limitations

- Each run returns the requested recent messages and does not remember the results of previous runs.
- To process only newly published messages, downstream workflows must filter by message ID or publication date.
- Each run accepts one public Telegram channel.
- This Actor does not provide Telegram-wide search or guarantee a complete historical archive.
- It does not access private or invite-only channels, user profiles, member lists, contacts, or Telegram account sessions.
- It does not bypass CAPTCHAs, authentication, access controls, or unavailable public previews.
- Telegram can change or restrict its public web-preview pages, which may require parser maintenance.

### Limits and responsible use

- Public `t.me/s/` channel previews only.
- No private channels, invite-only content, member lists, contacts, profiles, account sessions, or access-control bypasses.
- Telegram can change its public preview markup or restrict preview availability.
- Use the data in line with applicable law, Telegram's terms, and the public channel's rights.

# Actor input Schema

## `channel` (type: `string`):

Username only, without @ or a URL. The channel must be visible at https://t.me/s/USERNAME.

## `limit` (type: `integer`):

Maximum number of recent messages to return, ordered newest first.

## Actor input object example

```json
{
  "channel": "telegram",
  "limit": 50
}
```

# Actor output Schema

## `messages` (type: `string`):

No description

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

// Run the Actor and wait for it to finish
const run = await client.actor("bgy_1203/telegram-public-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 = {}

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

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).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 bgy_1203/telegram-public-channel-monitor --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=bgy_1203/telegram-public-channel-monitor",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Telegram Public Channel Monitor",
        "description": "Fetch recent public Telegram channel messages for scheduled n8n, AI-agent, and automation workflows. Newest-first results with no Telegram login.",
        "version": "0.0",
        "x-build-id": "ZHVAQuIMnpJMqMyPy"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/bgy_1203~telegram-public-channel-monitor/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-bgy_1203-telegram-public-channel-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/bgy_1203~telegram-public-channel-monitor/runs": {
            "post": {
                "operationId": "runs-sync-bgy_1203-telegram-public-channel-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/bgy_1203~telegram-public-channel-monitor/run-sync": {
            "post": {
                "operationId": "run-sync-bgy_1203-telegram-public-channel-monitor",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "channel",
                    "limit"
                ],
                "properties": {
                    "channel": {
                        "title": "Public channel username",
                        "pattern": "^[A-Za-z][A-Za-z0-9_]{4,31}$",
                        "type": "string",
                        "description": "Username only, without @ or a URL. The channel must be visible at https://t.me/s/USERNAME.",
                        "default": "telegram"
                    },
                    "limit": {
                        "title": "Maximum messages",
                        "minimum": 1,
                        "maximum": 500,
                        "type": "integer",
                        "description": "Maximum number of recent messages to return, ordered newest first.",
                        "default": 50
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```