# Telegram Channel Scraper (`zinin/telegram-channel-intel`) Actor

Pull recent post stats from any public Telegram channel: view counts, post text, publish dates and subscriber count, straight from Telegram's own public preview page. No bot token, no Telethon session, no login required.

- **URL**: https://apify.com/zinin/telegram-channel-intel.md
- **Developed by:** [Tim Zinin](https://apify.com/zinin) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.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/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 Channel Intel — Public Post Stats

Read any public Telegram channel like an API — view counts, post text, publish dates and
subscriber count — without a bot token, a login, or a Telethon session. One HTTP fetch per
channel, straight from the same public preview page Telegram already serves to search
engines and link-preview bots.

### What you get

- **Up to ~20 recent posts per channel** — text, view count and publish date for each,
  plus the channel's display name and subscriber count.
- **No bot token, no login, no MTProto session.** Reads the public SSR preview page
  (`t.me/s/<channel>`) that a search engine or a link-preview bot already sees,
  unauthenticated.
- **Flexible input.** Bare username, `@handle`, or a full `t.me/...` URL all work — one
  entry per channel.
- **Private and nonexistent channels return gracefully.** A channel with no public preview
  comes back as a single `found: false` row with the reason, at no charge.
- **Built for lists.** Concurrency up to 50, so a watchlist of channels is a single run.
- Runs on Apify: schedule it, monitor it, call it from the API or the MCP server, export
  to JSON, CSV or Excel, or push results straight into your own pipeline.

### How to run it

1. Click **Try for free** — no card needed on the free plan.
2. Paste your channel usernames into **Channels**, one per line.
3. Press **Start**. Results appear in the dataset — one row per post — read them in the
   UI, pull them from the API, or have a webhook push them onward.

### Pricing

Pay-per-event: **$0.005 per run start + $0.002 per post row returned**. No monthly seat,
no minimum. 100 posts cost about **$0.21**; 1,000 posts about **$2.01**.

A channel with no public preview — private, nonexistent, or preview disabled — is still
returned, as one row with `found: false` and the reason, and it is **not** charged for.
You pay for posts actually pulled, not for channels checked.

### Input

| Field | Required | What it does |
|---|---|---|
| `items` | yes | Public Telegram channel usernames to read — bare (`durov`), `@handle`, or a full `t.me/...` URL. Up to 100 per run. |
| `maxConcurrency` | no | How many channels to fetch at once, 1–50 (default 10). |

```json
{
    "items": ["durov", "telegram"]
}
```

### Output

One row per post. This is a real row from a real run:

```json
{
    "input": "durov",
    "channel": "durov",
    "channelTitle": "Pavel Durov",
    "subscribers": "11.5M",
    "postId": "durov/514",
    "text": "🇦🇪 Dubai is full of traffic and crowds again. Already missing the Iranian fireworks — they helped clear the city of the easily impressed.The UAE’s air defenses proved excellent under fire. For 0% tax, we get better protection than Europeans paying 50%.",
    "views": "3.46M",
    "date": "2026-05-16T13:57:49+00:00",
    "found": true,
    "scrapedAt": "2026-07-26T13:23:11.211Z"
}
```

| Field | What it means |
|---|---|
| `channel` | The channel username you passed |
| `channelTitle` | Channel display name |
| `subscribers` | Subscriber count as shown on the channel header (e.g. `11.5M`) |
| `postId` | Telegram's own post identifier (`channel/messageId`) |
| `text` | First ~400 characters of the post text |
| `views` | View count as shown on the post (e.g. `3.46M`) |
| `date` | ISO publish date/time |
| `found` | Whether the post was read successfully |
| `found: false` | A single row with `error` explaining why (no public preview) — not billed |

#### Need the rest of the picture?

These run on the same account, take the same shape of input and bill the same way, so they slot into an existing pipeline without new plumbing.

| Actor | What it does |
|---|---|
| [Doctoralia Mexico Directory Scraper](https://apify.com/zinin/doctoralia-directory) | Search Doctoralia Mexico by specialty + city and get public professional listings: name, specialty,… |
| [AI Answer Change Alert](https://apify.com/zinin/ai-answer-change-alert) | Track whether an AI assistant's answer to a query you care about changed since last time — new sources… |
| [AI Crawler Access Checker](https://apify.com/zinin/ai-crawler-access-checker) | Check which AI crawlers (GPTBot, ClaudeBot, PerplexityBot, Google-Extended & more) can access your website |
| [AI Overview Citation Tracker](https://apify.com/zinin/ai-overview-tracker) | For each query that matters, see which sources and domains AI assistants cite in their answer — grounded… |
| [B2B Lead Enricher](https://apify.com/zinin/b2b-lead-enricher) | Turn a list of company websites into sales-qualified lead cards: detected tech stack, a rough revenue… |

### FAQ

**Does it need a bot token or login?** No — it reads Telegram's public preview page, the
same one an unauthenticated search engine or link-preview bot sees.

**How many posts do I get per channel?** Up to the ~20 most recent shown on the preview
page. For deeper history, run it again later — each run reflects what's currently live.

**Does it work on private channels?** No — only channels with a public username and public
preview enabled.

**Can I call it from an AI agent?** Yes — a standard Apify Actor, callable from the Apify
API, the SDK, or the Apify MCP server.

**What this is NOT.** It does not read private channels, does not go deeper than the
preview page's ~20 recent posts, and does not use a phone-number-based Telegram session —
everything comes from the same unauthenticated page anyone can already open in a browser.

Found a wrong result, or need a check we don't run? Open an issue on this Actor's page.

***

Built by [zinin](https://apify.com/zinin). Questions? Telegram [@timzinin](https://t.me/timzinin).

# Actor input Schema

## `items` (type: `array`):

List of public Telegram channel usernames to read (bare username, @handle, or full t.me URL all work). One entry per channel; each returns up to ~20 recent posts.

## `maxConcurrency` (type: `integer`):

How many channels to fetch in parallel.

## Actor input object example

```json
{
  "items": [
    "durov",
    "telegram"
  ],
  "maxConcurrency": 10
}
```

# 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 = {
    "items": [
        "durov",
        "telegram"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("zinin/telegram-channel-intel").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 = { "items": [
        "durov",
        "telegram",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("zinin/telegram-channel-intel").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 '{
  "items": [
    "durov",
    "telegram"
  ]
}' |
apify call zinin/telegram-channel-intel --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

Download the OpenAPI definition: https://api.apify.com/v2/acts/RHNhio1AWe79VB0UG/builds/uoJgI8otqj8xogj4y/openapi.json