# Telegram Channel Scraper — Messages, Views & Media (`sian.agency/telegram-channel-scraper`) Actor

Scrape public Telegram channels — messages, views, dates, media, forwards and channel stats (subscribers, photos, videos). Fast overview or full history crawl. By channel handle or t.me URL, with in-channel search. Clean JSON/CSV, no login or API token.

- **URL**: https://apify.com/sian.agency/telegram-channel-scraper.md
- **Developed by:** [SIÁN OÜ](https://apify.com/sian.agency) (community)
- **Categories:** Social media, News, Business
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $1.50 / 1,000 overview message extracteds

This Actor is paid per event. You are not charged for the Apify platform usage, but only a fixed price for specific events.
Since this Actor supports Apify Store discounts, the price gets lower the higher subscription plan you have.

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.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.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/platform/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 — Messages, Views & Media 🚀

[![SIÁN Agency Store](https://img.shields.io/badge/Store-SI%C3%81N%20Agency-1AE392)](https://apify.com/sian.agency?fpr=sian) [![Xiaohongshu Scraper](https://img.shields.io/badge/Store-Xiaohongshu%20Scraper-FF2442)](https://apify.com/sian.agency/xiaohongshu-rednote-scraper?fpr=sian) [![Douyin Scraper](https://img.shields.io/badge/Store-Douyin%20Scraper-161823)](https://apify.com/sian.agency/douyin-scraper?fpr=sian) [![Kwai & Kuaishou Scraper](https://img.shields.io/badge/Store-Kwai%20%26%20Kuaishou-FF4906)](https://apify.com/sian.agency/kwai-kuaishou-scraper?fpr=sian)

#### 🎉 Turn any public Telegram channel into a clean dataset — messages, views, media, forwards & channel stats, no login required
##### For crypto researchers, OSINT analysts, marketers and news teams who need Telegram data at scale

---

### 📋 Overview

**Track any public Telegram channel without lifting a finger** — paste a handle or a `t.me` link and get every message as structured JSON or CSV.

**Why thousands of professionals choose us:**
- ✅ **Complete message data**: text, post date, view count, author, forwards, replies, media and channel stats — 20+ fields per row
- ⚡ **Fast or deep**: a quick *Overview* of the newest posts, or a full *Crawl* back through the channel's entire history
- 🎯 **Zero setup**: no Telegram account, no phone number, no API token, no bot — just a channel name
- 💰 **Pay-per-result**: only pay for messages you actually extract, with a free tier to test
- 💎 **Bulk-ready**: scrape many channels in one run, with optional in-channel keyword search
- ✨ **NEW**: media URLs (photos + videos) and channel KPIs (subscribers, photos, videos, links) on every message

---

### ✨ Features

- 📨 **Full message capture**: body text, timestamp, view count and signed author
- 👁️ **Engagement metrics**: humanized view counts straight from the channel
- 🖼️ **Media extraction**: every photo and video URL on each post, plus a thumbnail
- 📡 **Channel intelligence**: title, description, subscriber count, photo/video/link totals on every row
- ↪️ **Forwards & replies**: see what was forwarded and what a message replies to
- 🔍 **In-channel search**: narrow results to a keyword inside a channel
- 📜 **Full history crawl**: walk back through thousands of messages, newest → oldest
- 🌍 **Bulk channels**: scrape many channels in a single run
- 📊 **Clean export**: JSON, CSV and Excel directly from the Apify dataset

---

### 🎬 Quick Start

Pick a scrape mode, drop in a channel handle, and run. Results stream into the dataset as they're scraped. Export to JSON, CSV or Excel when done.

```bash
curl -X POST "https://api.apify.com/v2/acts/sian.agency~telegram-channel-scraper/runs?token=YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d '{"scrapeMode":"overview","searchMode":"byChannel","channels":["durov"]}'
````

***

### 🚀 Getting Started (3 Simple Steps)

#### Step 1: Choose your mode

Pick **Overview** for the newest messages, or **Crawl** for the full history.

#### Step 2: Add your channels

Type one or more channel handles (e.g. `durov`), or paste `t.me` URLs.

#### Step 3: Run

Click **Start** and watch messages fill the dataset.

**That's it! In under a minute, you'll have:**

- Structured messages with views, dates and media
- Channel-level stats on every row
- A clean JSON/CSV/Excel export

***

### 📥 Input Configuration

| Field | Type | Required | Description |
|-------|------|----------|-------------|
| scrapeMode | string | No | `overview` (newest messages) or `crawl` (full history) |
| searchMode | string | No | `byChannel` (handles) or `bySearchUrl` (t.me URLs) |
| channels | array | No | Channel handles, e.g. `["durov"]` |
| searchUrls | array | No | Full `t.me` URLs to scrape |
| query | string | No | In-channel keyword search (By Channel mode) |
| pages | integer | No | Overview depth — preview pages per channel (20 msgs each) |
| maxResults | integer | No | Crawl limit — total messages per run |

**Example — newest messages from a channel:**

```json
{
  "scrapeMode": "overview",
  "searchMode": "byChannel",
  "channels": ["durov"],
  "pages": 1
}
```

**Example — deep history crawl with keyword search:**

```json
{
  "scrapeMode": "crawl",
  "searchMode": "byChannel",
  "channels": ["telegram"],
  "query": "feature",
  "maxResults": 500
}
```

***

### 📤 Output

Results are saved to the Apify dataset with **20+ fields** including:

| Field | Type | Description |
|-------|------|-------------|
| id | string | Stable `<channel>/<id>` identifier |
| url | string | Direct link to the message |
| text | string | Message body text |
| date | string | ISO 8601 post timestamp |
| views | string | Humanized view count (e.g. `3.35M`) |
| author | string | Signed author / owner name |
| media | array | Photo and video URLs |
| media\_count | number | Number of media items |
| forwarded\_from | string | Original source on a forward |
| reply\_to | string | Quoted text on a reply |
| channel | string | Channel handle |
| channel\_title | string | Channel display title |
| subscribers | string | Channel subscriber count |
| photos\_count / videos\_count / links\_count | string | Channel media totals |

**Example:**

```json
{
  "id": "durov/510",
  "url": "https://t.me/durov/510",
  "text": "With 400 validators across 6 continents, TON is one of the most decentralized blockchain networks on the planet.",
  "date": "2026-05-12T17:28:39+00:00",
  "views": "3.35M",
  "author": "Pavel Durov",
  "media": ["https://cdn4.telesco.pe/file/..."],
  "media_count": 2,
  "channel": "durov",
  "channel_title": "Pavel Durov",
  "subscribers": "12M",
  "photos_count": "99",
  "videos_count": "45",
  "links_count": "194"
}
```

***

### 💼 Use Cases & Examples

#### 1. Crypto & Web3 Alpha Tracking

**Crypto researchers monitoring project and trader channels for signals.**

**Input:** A list of crypto channel handles + a keyword like `airdrop`
**Output:** Every matching message with views and timestamps
**Use:** Spot announcements and momentum before they hit Twitter.

#### 2. Brand & Competitor Monitoring

**Marketers watching how brands and rivals post on Telegram.**

**Input:** Competitor channel handles
**Output:** Their posts, engagement and media cadence
**Use:** Benchmark content strategy and posting frequency.

#### 3. OSINT & Research

**Analysts and journalists building a searchable archive of a public channel.**

**Input:** A channel handle in Crawl mode
**Output:** The full message history as structured rows
**Use:** Timeline reconstruction and evidence preservation.

#### 4. News Aggregation

**News teams pulling breaking updates from official channels.**

**Input:** News channel handles in Overview mode
**Output:** The latest posts with views and links
**Use:** Feed a newsroom dashboard or alerting workflow.

#### 5. Sentiment & Engagement Analysis

**Data teams measuring reach and engagement across many channels.**

**Input:** Dozens of channels in one run
**Output:** Messages with view counts and media stats
**Use:** Rank channels by reach and analyze what content performs.

#### 6. Meme & Airdrop Discovery

**Traders scanning community channels for early opportunities.**

**Input:** Community channel handles + a keyword search
**Output:** Matching messages with links and media
**Use:** Surface new tokens, mints and giveaways fast.

***

### 🔗 Integration Examples

#### JavaScript/Node.js

```javascript
import { ApifyClient } from 'apify-client';
const client = new ApifyClient({ token: 'YOUR_TOKEN' });

const run = await client.actor('sian.agency/telegram-channel-scraper').call({
  scrapeMode: 'overview',
  searchMode: 'byChannel',
  channels: ['durov']
});

const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items[0]);
```

#### Python

```python
from apify_client import ApifyClient
client = ApifyClient('YOUR_TOKEN')

run = client.actor('sian.agency/telegram-channel-scraper').call(
    run_input={
        'scrapeMode': 'crawl',
        'searchMode': 'byChannel',
        'channels': ['telegram'],
        'maxResults': 500
    }
)

for item in client.dataset(run['defaultDatasetId']).iterate_items():
    print(item)
```

#### cURL

```bash
curl -X POST 'https://api.apify.com/v2/acts/sian.agency~telegram-channel-scraper/runs?token=YOUR_TOKEN' \
-H 'Content-Type: application/json' \
-d '{"scrapeMode":"overview","searchMode":"byChannel","channels":["durov"]}'
```

#### Automation Workflows (N8N / Zapier / Make)

1. **Trigger**: Schedule or webhook
2. **HTTP Request**: Call the actor API
3. **Process**: Handle the JSON results
4. **Action**: Save, notify, or transform

***

### 📊 Performance & Pricing

#### FREE Tier (Try It Now)

- **25 messages** per run — full feature access, same quality
- No credit card required
- Perfect for testing and small projects

#### PAID Tier (Production Ready)

- **Unlimited** messages per run
- Deep history crawls across many channels
- Pay-per-result: only charged for messages actually extracted

💰 **Best price on the market** — transparent pay-per-result, no monthly subscription.

🔗 [View current pricing](https://apify.com/sian.agency/telegram-channel-scraper?fpr=sian)

***

### ❓ Frequently Asked Questions

**Q: How many messages can I scrape?**
A: FREE tier: 25 per run. PAID tier: unlimited.

**Q: Does it work with private channels or groups?**
A: No — only public channels with web preview enabled are supported.

**Q: Do I need a Telegram account, bot, or API key?**
A: No. Just a public channel handle or URL.

**Q: What output formats are available?**
A: JSON, CSV and Excel — export directly from the Apify dataset.

**Q: Can I search inside a channel?**
A: Yes — add a keyword to filter messages to matching posts.

**Q: How fresh is the data?**
A: Every run fetches live from the channel's public preview at that moment.

**Q: Is this legal?**
A: It only extracts publicly available data. See the legal section below.

***

### 🐛 Troubleshooting

**No messages returned**

- Confirm the channel is **public** and has web preview enabled
- Try the handle without `@` (e.g. `durov`, not `@durov`)

**Fewer messages than expected**

- FREE tier caps runs at 25 messages — switch to PAID for more
- In Overview mode, increase `pages`; in Crawl mode, raise `maxResults`

**A specific channel is empty**

- Some channels disable their public web preview — those can't be scraped

***

### ⚖️ Is it legal to scrape data?

Our actors are ethical and do not extract any private user data, such as email addresses, gender, or location. They only extract what the user has chosen to share publicly. We therefore believe that our actors, when used for ethical purposes by Apify users, are safe.

However, you should be aware that your results could contain personal data. Personal data is protected by the **GDPR** in the European Union and by other regulations around the world. You should not scrape personal data unless you have a legitimate reason to do so. If you're unsure whether your reason is legitimate, consult your lawyers.

You can also read Apify's blog post on the [legality of web scraping](https://blog.apify.com/is-web-scraping-legal/).

> **Trademark notice:** Telegram is a trademark of Telegram FZ-LLC / Telegram Messenger Inc. This actor is an independent tool and is **not affiliated with, endorsed by, or sponsored by** Telegram. It only accesses publicly available channel data. All product names, logos, and brands are property of their respective owners.

***

### 🤝 Support

[![Telegram Support](https://img.shields.io/badge/Telegram-Support%20Group-0088cc?logo=telegram)](https://t.me/+vyh1sRE08sAxMGRi)

**Join our active support community**

- For issues or questions, open an issue in the actor's repository
- Check the [SIÁN Agency Store](https://apify.com/sian.agency?fpr=sian) for more automation tools
- 📧 <apify@sian-agency.online>

***

**Built by [SIÁN Agency](https://www.sian-agency.online)** | **[More Tools](https://apify.com/sian.agency?fpr=sian)**

# Actor input Schema

## `scrapeMode` (type: `string`):

⚙️ **Choose how deep to go:**

- **📍 Overview** — the newest messages from each channel (20 per page). Fast, cheap snapshot of recent activity.
- **📜 Crawl** — walk back through the channel's full message history, newest → oldest, up to your limit.

**TIP:** Start with Overview to preview a channel; switch to Crawl for the full archive.

## `searchMode` (type: `string`):

🔎 **How you point at channels:**

- **By channel** — type one or more channel handles (e.g. `durov`).
- **By search URL** — paste full `t.me` channel preview URLs.

Use the field below that matches your choice.

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

@ **CHANNEL HANDLES:** One or more public Telegram channel handles to scrape.

✅ **Accepted formats:** `durov` · `@durov` · `https://t.me/durov` · `t.me/s/durov`

💡 **BULK EDIT:** Click "Bulk edit" to paste many handles (one per line).

📌 **Only public channels** with web preview enabled are supported (private channels and groups are not).

## `searchUrls` (type: `array`):

🔗 **t.me URLS:** Paste full Telegram channel URLs to scrape.

✅ **Example:** `https://t.me/s/durov` or `https://t.me/durov`

💡 You can add an in-channel search to a URL, e.g. `https://t.me/s/durov?q=ton`.

📌 Only `t.me` URLs are accepted.

## `query` (type: `string`):

🔍 **OPTIONAL FULL-TEXT SEARCH:** Restrict results to messages matching a keyword inside the channel (By Channel mode only).

**Example:** `ton` → only messages mentioning "ton".

Leave blank to scrape all messages.

## `pages` (type: `integer`):

🔢 **OVERVIEW DEPTH:** How many preview pages to fetch per channel in Overview mode (20 messages each). `1` = the 20 newest messages.

**Ignored in Crawl mode** — use the message limit below instead.

## `maxResults` (type: `integer`):

🔢 **CRAWL LIMIT:** Total messages to collect per run in Crawl mode (newest → oldest).

💎 **TIER-BASED LIMITS:**

- **FREE users:** up to 25 messages per run
- **PAID users:** unlimited

Default: 200.

## `rotateProxy` (type: `boolean`):

🛡️ **IP ROTATION:** Route requests through rotating residential IPs. Useful when crawling very deep histories at scale to avoid rate limits. Not needed for normal runs.

Default: off (direct connection).

## Actor input object example

```json
{
  "scrapeMode": "overview",
  "searchMode": "byChannel",
  "channels": [
    "durov"
  ],
  "pages": 1,
  "maxResults": 200,
  "rotateProxy": false
}
```

# Actor output Schema

## `results` (type: `string`):

Scraped messages with text, views, dates, media and channel stats.

## `scrapingSummary` (type: `string`):

HTML summary showing extracted messages and key run metrics.

# 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"
    ]
};

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

# Run the Actor and wait for it to finish
run = client.actor("sian.agency/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"
  ]
}' |
apify call sian.agency/telegram-channel-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Telegram Channel Scraper — Messages, Views & Media",
        "description": "Scrape public Telegram channels — messages, views, dates, media, forwards and channel stats (subscribers, photos, videos). Fast overview or full history crawl. By channel handle or t.me URL, with in-channel search. Clean JSON/CSV, no login or API token.",
        "version": "1.0",
        "x-build-id": "HUJ12uvgt3ac4499J"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/sian.agency~telegram-channel-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-sian.agency-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/sian.agency~telegram-channel-scraper/runs": {
            "post": {
                "operationId": "runs-sync-sian.agency-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/sian.agency~telegram-channel-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-sian.agency-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",
                "properties": {
                    "scrapeMode": {
                        "title": "⚙️ Scrape Mode",
                        "enum": [
                            "overview",
                            "crawl"
                        ],
                        "type": "string",
                        "description": "⚙️ **Choose how deep to go:**\n\n- **📍 Overview** — the newest messages from each channel (20 per page). Fast, cheap snapshot of recent activity.\n- **📜 Crawl** — walk back through the channel's full message history, newest → oldest, up to your limit.\n\n**TIP:** Start with Overview to preview a channel; switch to Crawl for the full archive.",
                        "default": "overview"
                    },
                    "searchMode": {
                        "title": "🔎 Search Mode",
                        "enum": [
                            "byChannel",
                            "bySearchUrl"
                        ],
                        "type": "string",
                        "description": "🔎 **How you point at channels:**\n\n- **By channel** — type one or more channel handles (e.g. `durov`).\n- **By search URL** — paste full `t.me` channel preview URLs.\n\nUse the field below that matches your choice.",
                        "default": "byChannel"
                    },
                    "channels": {
                        "title": "@ Channel Handles (By Channel mode)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "@ **CHANNEL HANDLES:** One or more public Telegram channel handles to scrape.\n\n✅ **Accepted formats:** `durov` · `@durov` · `https://t.me/durov` · `t.me/s/durov`\n\n💡 **BULK EDIT:** Click \"Bulk edit\" to paste many handles (one per line).\n\n📌 **Only public channels** with web preview enabled are supported (private channels and groups are not).",
                        "default": [
                            "durov"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "searchUrls": {
                        "title": "🔗 Channel URLs (By Search URL mode)",
                        "uniqueItems": true,
                        "type": "array",
                        "description": "🔗 **t.me URLS:** Paste full Telegram channel URLs to scrape.\n\n✅ **Example:** `https://t.me/s/durov` or `https://t.me/durov`\n\n💡 You can add an in-channel search to a URL, e.g. `https://t.me/s/durov?q=ton`.\n\n📌 Only `t.me` URLs are accepted.",
                        "items": {
                            "type": "object",
                            "required": [
                                "url"
                            ],
                            "properties": {
                                "url": {
                                    "type": "string",
                                    "title": "URL of a web page",
                                    "format": "uri"
                                }
                            }
                        }
                    },
                    "query": {
                        "title": "🔍 In-Channel Search (Optional)",
                        "type": "string",
                        "description": "🔍 **OPTIONAL FULL-TEXT SEARCH:** Restrict results to messages matching a keyword inside the channel (By Channel mode only).\n\n**Example:** `ton` → only messages mentioning \"ton\".\n\nLeave blank to scrape all messages."
                    },
                    "pages": {
                        "title": "🔢 Overview Pages",
                        "minimum": 1,
                        "type": "integer",
                        "description": "🔢 **OVERVIEW DEPTH:** How many preview pages to fetch per channel in Overview mode (20 messages each). `1` = the 20 newest messages.\n\n**Ignored in Crawl mode** — use the message limit below instead.",
                        "default": 1
                    },
                    "maxResults": {
                        "title": "🔢 Max Messages (Crawl mode)",
                        "minimum": 1,
                        "type": "integer",
                        "description": "🔢 **CRAWL LIMIT:** Total messages to collect per run in Crawl mode (newest → oldest).\n\n💎 **TIER-BASED LIMITS:**\n- **FREE users:** up to 25 messages per run\n- **PAID users:** unlimited\n\nDefault: 200.",
                        "default": 200
                    },
                    "rotateProxy": {
                        "title": "🛡️ Rotate IPs (Deep Crawls)",
                        "type": "boolean",
                        "description": "🛡️ **IP ROTATION:** Route requests through rotating residential IPs. Useful when crawling very deep histories at scale to avoid rate limits. Not needed for normal runs.\n\nDefault: off (direct connection).",
                        "default": false
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
