# Telegram Channel Scraper — Posts, Views & Media (`darknezz/telegram-channel-scraper`) Actor

Scrape public Telegram channels without login or API key: message text, dates, view counts, forwards, photos, videos and links. Just pass channel usernames. Ideal for monitoring, research, OSINT and trend analysis.

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

## Pricing

from $2.00 / 1,000 message scrapeds

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 Channel Scraper — Posts, Views & Media

Scrape **public Telegram channels** without login, API keys, phone numbers or proxies. Pass one or more channel usernames and get structured JSON with every post: text, timestamps, view counts, forwards, photos, videos and links.

Built for OSINT researchers, growth teams and analysts who need clean, structured channel history — no `api_id`/`api_hash`, no bot token, no phone number to burn.

### Why this Actor

- **No Telegram account needed** — reads the public web preview (`t.me/s/<channel>`), so there is nothing to authenticate or configure.
- **No API key, no `api_id`/`api_hash`, no bot token, no proxy budget.**
- **Rich per-post data** — text, exact timestamp, view count, forward source, reply target, photos, video, and external links, all on one JSON row.
- **Channel metadata included** — title and subscriber count attached to every message, so a single dataset is self-describing.
- **Cheap and fast** — pay only per message scraped, plus a one-time start fee.

### How it works

Give it a list of public channel usernames (`@durov`, `durov`) or links (`t.me/telegram`, `t.me/s/telegram`). For each channel the Actor pages through the public web preview newest-first and outputs **one dataset item per message**, up to `maxPostsPerChannel`. Private channels and groups have no web preview and cannot be scraped.

### Input

```json
{
  "channels": ["@durov", "https://t.me/telegram"],
  "maxPostsPerChannel": 100
}
````

| Field | Type | Description |
|---|---|---|
| `channels` | array | Public channel usernames (`@name`, `name`) or links (`t.me/name`, `t.me/s/name`) — **required** |
| `maxPostsPerChannel` | integer | Recent posts to fetch per channel, newest first (default 50) |

### Output (one item per message)

```json
{
  "channelUsername": "durov",
  "channelTitle": "Pavel Durov",
  "channelSubscribers": 11700000,
  "messageId": 530,
  "postUrl": "https://t.me/durov/530",
  "date": "2026-07-09T12:31:00+00:00",
  "text": "…",
  "links": ["https://example.com"],
  "views": 245300,
  "isForwarded": false,
  "forwardedFrom": null,
  "replyToMessageId": null,
  "photoUrls": [],
  "hasVideo": false,
  "videoUrl": null,
  "linkPreviewUrl": null,
  "linkPreviewTitle": null
}
```

### Use cases

- 📰 **Monitoring & alerting** — track announcements, news channels or competitor channels and pipe new posts into Slack/webhooks.
- 🕵️ **OSINT & research** — archive public channel history with view counts and forward chains for investigations.
- 📊 **Trend analysis** — measure post frequency, reach (views) and topic mix over time.
- 🔗 **Lead generation** — extract external links and domains shared by niche communities.
- 🤖 **AI / datasets** — build labeled text corpora of real-world messaging for classification and summarization.

### Run it from the API

Trigger the Actor and get results in one call:

```bash
curl -X POST "https://api.apify.com/v2/acts/darknezz~telegram-channel-scraper/run-sync-get-dataset-items?token=YOUR_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"channels":["@durov","telegram"],"maxPostsPerChannel":50}'
```

**Scheduling:** attach an Apify Schedule (e.g. every 15 minutes) to keep a dataset continuously topped up with new posts from the channels you monitor.

### Limitations

- Only **public** channels with the web preview enabled can be scraped. Private channels and groups are not accessible.
- View counts are approximate (Telegram rounds them, e.g. `245.3K` → `245300`).
- Very old messages require many pagination requests; keep `maxPostsPerChannel` reasonable for faster, cheaper runs.

### Pricing

Pay per event: a small fee for each message scraped, plus Apify's standard platform events (actor start + dataset item). No subscription — you pay only for what you run.

### FAQ

**Do I need a Telegram account, bot token or `api_id`?** No — the Actor reads the public web preview, so there is nothing to authenticate.

**Can it scrape private channels or groups?** No. Only public channels that expose a `t.me/s/<name>` web preview can be scraped.

**How far back can I go?** As far as the channel's public history allows — raise `maxPostsPerChannel`. Deep history costs more pagination requests, so runs take longer.

**Why are view counts rounded?** Telegram itself only exposes rounded counts (e.g. `245.3K`) on the public preview; the Actor parses them back to integers.

**Do I need a proxy?** No. The public preview is reachable directly over HTTPS — no proxy or residential IP budget required.

**Is scraping this legal?** The web preview is public and unauthenticated. You are responsible for complying with Telegram's terms and any privacy laws (e.g. GDPR) that apply to how you store and use the data.

# Actor input Schema

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

Public channel usernames or t.me links (e.g. '@durov', 'https://t.me/telegram'). Private channels cannot be scraped.

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

Maximum number of recent posts to scrape per channel (newest first).

## Actor input object example

```json
{
  "channels": [
    "@durov",
    "telegram"
  ],
  "maxPostsPerChannel": 50
}
```

# Actor output Schema

## `results` (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": [
        "@durov",
        "telegram"
    ]
};

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

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

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Telegram Channel Scraper — Posts, Views & Media",
        "description": "Scrape public Telegram channels without login or API key: message text, dates, view counts, forwards, photos, videos and links. Just pass channel usernames. Ideal for monitoring, research, OSINT and trend analysis.",
        "version": "0.1",
        "x-build-id": "OhLdpEY9E4OteCxNv"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/darknezz~telegram-channel-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-darknezz-telegram-channel-scraper",
                "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/darknezz~telegram-channel-scraper/runs": {
            "post": {
                "operationId": "runs-sync-darknezz-telegram-channel-scraper",
                "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/darknezz~telegram-channel-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-darknezz-telegram-channel-scraper",
                "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": [
                    "channels"
                ],
                "properties": {
                    "channels": {
                        "title": "Channels",
                        "type": "array",
                        "description": "Public channel usernames or t.me links (e.g. '@durov', 'https://t.me/telegram'). Private channels cannot be scraped.",
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxPostsPerChannel": {
                        "title": "Max posts per channel",
                        "minimum": 1,
                        "maximum": 10000,
                        "type": "integer",
                        "description": "Maximum number of recent posts to scrape per channel (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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```