# Telegram Channel Scraper + AI Translate & Summarize (`kassieiii/telegram-channel-scraper-ai`) Actor

Export posts from any public Telegram channel: text, date, views, reactions, links, media, forwards. No login or bot token. Optional AI with your own API key (OpenAI, Claude, Gemini...): translate, summarize, entities, sentiment. Monitoring mode returns only new posts.

- **URL**: https://apify.com/kassieiii/telegram-channel-scraper-ai.md
- **Developed by:** [Kassym Yermakhanbet](https://apify.com/kassieiii) (community)
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.00 / 1,000 post saveds

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/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 + AI Translate & Summarize

Export posts from any **public Telegram channel** to JSON, CSV, Excel or Google Sheets: text, date, views, reactions, links, hashtags, media and forwards. **No login, no phone number, no bot token.**

Turn on **AI enrichment with your own API key** (OpenAI, Anthropic Claude, Google Gemini, OpenRouter, DeepSeek, Groq or any OpenAI-compatible API) and every post also gets a **translation** (English or 17 other languages), a **one-sentence summary**, **topics**, **people / organizations / locations** and **sentiment**. You can read Russian, Ukrainian, Persian or Arabic channels in English without copy-pasting into a translator. You choose the model and pay your provider directly, with no markup on tokens.

Use **monitoring mode** on a schedule to get only the posts published since your last run.

### What you can use it for

- **Media & news monitoring:** follow news, politics or industry channels, translated and summarized
- **Market, crypto & finance research:** track signal and analysis channels; filter by keywords like `BTC` or `IPO`
- **Brand & competitor tracking:** keyword filters for your brand, product or competitors
- **Academic & OSINT research:** reproducible exports with dates, views and forwarding chains
- **AI agents & RAG pipelines:** clean, structured posts ready for LLMs (works via Apify MCP)

### How to use

1. Add channels: `durov`, `@durov`, `t.me/durov` or `https://t.me/s/durov`.
2. Optionally set a date range, keywords, max posts, and turn on AI enrichment.
3. Click **Start** and download the results in any format, or connect them to Google Sheets, Slack, Make, Zapier or webhooks.

#### Input example

```json
{
  "channels": ["durov", "telegram"],
  "maxPostsPerChannel": 200,
  "dateFrom": "2026-09-01",
  "keywords": ["update", "privacy"],
  "aiEnrichment": true,
  "aiProvider": "openai",
  "aiApiKey": "sk-...your key...",
  "aiModel": "gpt-4o-mini",
  "aiTargetLanguage": "en"
}
```

#### Output example

```json
{
  "channelUsername": "examplenews",
  "channelTitle": "Example News",
  "channelSubscribers": 125000,
  "postId": 48213,
  "postUrl": "https://t.me/examplenews/48213",
  "date": "2026-09-20T10:15:00+00:00",
  "text": "Цены на нефть выросли на 3% после решения ОПЕК+ ...",
  "views": 15400,
  "reactions": [{ "emoji": "👍", "count": 1200 }],
  "links": ["https://example.com/oil"],
  "hashtags": ["нефть"],
  "isForwarded": false,
  "media": [{ "type": "photo", "url": "https://cdn4.telesco.pe/file/..." }],
  "ai": {
    "language": "ru",
    "translation": "Oil prices rose 3% after the OPEC+ decision ...",
    "summary": "Oil prices increased by 3% following an OPEC+ decision.",
    "topics": ["oil prices", "OPEC+"],
    "entities": { "people": [], "organizations": ["OPEC+"], "locations": [] },
    "sentiment": "neutral"
  }
}
```

### Monitoring mode (only new posts)

Turn on **"Monitoring mode"** and schedule the Actor (Schedules → hourly or daily). Each run remembers the newest post per channel and next time returns **only newer posts**, so you never pay twice for the same post. Use a different **Monitor name** for each separate watch list.

### Pricing

Pay only for what you get (pay-per-event):

| Event | Price |
|---|---|
| Run start | $0.001 |
| Post saved | $0.001 (= $1 per 1,000 posts) |
| AI-enriched post (translation + summary + topics + entities + sentiment, using your own API key) | $0.0005 |

AI tokens are billed by **your own AI provider**, typically about $0.20–0.50 per 1,000 posts with a small, fast model. Posts are sent in batches to keep this low.

Examples: 1,000 posts ≈ **$1**; 1,000 posts with AI ≈ **$1.50** + your tokens. Monitoring 20 channels daily (~600 new posts/day) costs about **$18/month**, or **$27/month** with AI (+ tokens). Set a **max cost per run** in the run options and the Actor stops exactly at your limit.

### Use with AI agents (MCP)

This Actor works with Claude, Cursor and other MCP clients through Apify's MCP server (`https://mcp.apify.com`). Ask your agent: *"Get the last 50 posts from @durov, translated to English, and summarize the main themes."*

### FAQ

**Which channels work?** Public channels that show their posts at `https://t.me/s/<channel>`. Private channels, groups and invite links (`t.me/+...`) are not supported, and channels with the web preview disabled are skipped (you're not charged).

**How far back can it go?** As far as the public history goes. Use *Max posts per channel* and *Max pages per channel* for large exports.

**Does it collect personal data?** No member lists or user profiles, only what the channel itself publishes. Use the data in line with your local laws and Telegram's terms.

**Is my AI API key safe?** It's a secret input: Apify stores it encrypted, and the Actor only sends it to the provider you selected. It's never logged or written to the results. If the provider rejects the key, AI is switched off for that run and your posts are still saved (no AI charge).

**Which model should I use?** Any fast, cheap chat model works well, e.g. gpt-4o-mini on OpenAI, a Haiku-class model on Anthropic, a Flash-class model on Gemini, or deepseek-chat.

**Posts without text (only a photo or video)?** They're saved with media info. AI enrichment is only charged for posts that have text.

**Something broke?** Open an issue in the *Issues* tab. We usually reply within 1–2 days.

# Actor input Schema

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

Public channel usernames or links. Accepts <code>durov</code>, <code>@durov</code>, <code>t.me/durov</code> or <code>https://t.me/s/durov</code>. Private channels and groups are not supported.

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

Newest posts first. Scraping stops at this number (or earlier if you set a start date).

## `dateFrom` (type: `string`):

Oldest post date to include, YYYY-MM-DD (UTC). Leave empty for no limit.

## `dateTo` (type: `string`):

Newest post date to include, YYYY-MM-DD (UTC). Leave empty for up to now.

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

Keep only posts containing at least one of these words (case-insensitive). Leave empty to keep all posts. You pay only for posts that are saved.

## `includeMedia` (type: `boolean`):

Add photo/video/document info and preview URLs to each post.

## `onlyNewPosts` (type: `boolean`):

Remembers the newest post of each channel. Schedule this Actor (e.g. hourly or daily) and every run returns — and charges for — only posts published since the previous run.

## `monitorName` (type: `string`):

Use a different name for each separate monitor (e.g. "crypto-news", "competitors"). Only letters, numbers and dashes.

## `aiEnrichment` (type: `boolean`):

For every post with text: detected language, full translation, one-sentence summary, up to 3 topics, people/organizations/locations and sentiment. Uses YOUR OWN AI API key below — you pay your AI provider directly for tokens (usually cents per 1,000 posts).

## `aiProvider` (type: `string`):

Any OpenAI-compatible API. Tip: a free Google AI Studio key works with "Google Gemini". Choose "Custom" for your own gateway, Together, Mistral, a local server, etc.

## `aiApiKey` (type: `string`):

Stored encrypted by Apify, never logged or saved to results. Only used to call the provider you chose.

## `aiModel` (type: `string`):

Model name at your provider. Leave empty for the default: OpenAI gpt-4o-mini, OpenRouter openai/gpt-4o-mini, Google Gemini gemini-3.5-flash-lite (works with a free AI Studio key), DeepSeek deepseek-chat. Required for Anthropic, Groq and Custom — use a fast, cheap model.

## `aiBaseUrl` (type: `string`):

Only for provider "Custom": the OpenAI-compatible base URL, e.g. https://api.together.xyz/v1

## `aiTargetLanguage` (type: `string`):

Language for translations, summaries and topics.

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

Safety limit. Each page holds about 20 posts. Increase it when a keyword filter skips many posts.

## `requestDelayMs` (type: `integer`):

Polite pause between page requests. Lower is faster but more likely to be rate-limited.

## `proxyConfiguration` (type: `object`):

Apify Proxy helps avoid rate limits on large runs.

## Actor input object example

```json
{
  "channels": [
    "durov",
    "telegram"
  ],
  "maxPostsPerChannel": 100,
  "includeMedia": true,
  "onlyNewPosts": false,
  "monitorName": "telegram-channel-monitor",
  "aiEnrichment": false,
  "aiProvider": "openai",
  "aiTargetLanguage": "en",
  "maxPagesPerChannel": 200,
  "requestDelayMs": 1000,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

No description

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

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

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,kassieiii/telegram-channel-scraper-ai"
        }
    }
}
```

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/xGGQTs9b9LDwgqkdK/builds/NIZbBN6h4jOJ4wSGt/openapi.json