# Telegram Keyword Search Scraper & Monitor (`marvinkruell/telegram-keyword-search-scraper`) Actor

Search 1,400+ big public Telegram channels for any keyword with Telegram's own search. Every result really contains your keyword. Export posts, views and reactions, and monitor brands, tickers and topics on a schedule. No login, no API key.

- **URL**: https://apify.com/marvinkruell/telegram-keyword-search-scraper.md
- **Developed by:** [Marvin](https://apify.com/marvinkruell) (community)
- **Categories:** Social media, News, AI
- **Features:** Limited permissions
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $2.10 / 1,000 matching posts

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/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 Keyword Search Scraper & Monitor

**Search public Telegram channels by keyword and get every post that mentions your brand, product, crypto ticker or topic.** This Telegram scraper uses Telegram's own search inside each channel, so every result really contains your keyword. Export channel posts with views, reactions, links and media, and monitor new mentions on a schedule. No Telegram account, no API key, no phone number.

### What does Telegram Keyword Search Scraper do?

Telegram has no public search across channels. Most Telegram keyword scrapers work around that by asking Google for `t.me` links and returning whatever post happens to be on that page, which often does not contain your keyword at all.

This Actor searches Telegram directly:

1. **It picks the channels.** Your keywords are searched in the largest active public Telegram channels from our directory of 1,400+ channels (news, markets, crypto, tech, AI, sport and more, in many languages), plus any channels you name, plus topic channels it finds on the web. The directory is rebuilt every week, so new channels are added and inactive ones dropped.
2. **It runs Telegram's own search in every channel** and pages back through the results until your time window ends.
3. **It checks every post** and labels how it matched: the exact phrase, all words, or a related word.
4. **It follows the trail.** Channels that matching posts forward from or mention are searched too, so you find sources you did not know about.

You get one clean row per post, ready for Excel, Google Sheets, a dashboard, an alerting workflow or an AI agent. With a monitor name and a schedule, new mentions arrive in **Slack, a Telegram chat or any webhook** automatically.

### Use cases

- **Brand monitoring and social listening.** See every public Telegram post that mentions your company, product or CEO, with reach (views) and engagement (reactions).
- **Crypto and stock research.** Track tickers, tokens and projects across the biggest crypto and market news channels. Spot narratives early.
- **News and OSINT.** Follow a person, place or event across hundreds of news channels at once, in English, Russian, Ukrainian, Arabic, Persian and more.
- **Competitor and market research.** Find where competitors are discussed and which channels drive the conversation.
- **Lead and channel discovery.** Find active channels that write about your niche, with subscriber counts.
- **AI agents and RAG pipelines.** Give Claude, ChatGPT or your own agent fresh Telegram context through the Apify API or MCP.

### How to search Telegram by keyword

1. Click **Try for free**.
2. Enter one or more **keywords**, for example `openai` or your brand name.
3. Optional: choose **channel languages** (English is preselected) and a **time window** like `7 days`.
4. Click **Start**. Matching posts appear in the **Matching posts** table within about a minute.
5. Download the results as JSON, CSV, Excel or HTML, or read them through the API.

### How to monitor Telegram for new mentions

1. Set **Monitor name**, for example `my-brand`.
2. Save the input as a **Task**.
3. Add a **Schedule** (every hour or every day) to the Task.
4. Get alerts: paste a **Slack incoming webhook URL**, a **Telegram bot token and chat ID**, or any **webhook URL** (Make, Zapier, n8n, your own API). After each run, the new posts are sent there, the most-viewed first.

Each scheduled run returns only posts that are new since the last run with the same monitor name, and you only pay for those. No new posts means no alert and no cost.

### Ready-made examples

Start from a working setup and change the keywords:

- [Monitor brand mentions on Telegram](https://apify.com/marvinkruell/telegram-keyword-search-scraper/examples/telegram-brand-mentions-monitor)
- [Telegram keyword alerts to Slack or Telegram](https://apify.com/marvinkruell/telegram-keyword-search-scraper/examples/telegram-keyword-alerts)
- [Track crypto token mentions on Telegram](https://apify.com/marvinkruell/telegram-keyword-search-scraper/examples/telegram-crypto-token-mentions)
- [Bitcoin ETF news from Telegram channels](https://apify.com/marvinkruell/telegram-keyword-search-scraper/examples/telegram-bitcoin-etf-news)
- [Search Telegram for AI news](https://apify.com/marvinkruell/telegram-keyword-search-scraper/examples/telegram-ai-news-search)
- [Stock market news from Telegram](https://apify.com/marvinkruell/telegram-keyword-search-scraper/examples/telegram-stock-market-news)
- [Track competitor mentions on Telegram](https://apify.com/marvinkruell/telegram-keyword-search-scraper/examples/telegram-competitor-mentions)
- [OSINT: monitor a topic across Telegram news](https://apify.com/marvinkruell/telegram-keyword-search-scraper/examples/telegram-osint-news-monitor)
- [Football transfer news from Telegram](https://apify.com/marvinkruell/telegram-keyword-search-scraper/examples/telegram-football-transfer-news)
- [Find crypto airdrop posts on Telegram](https://apify.com/marvinkruell/telegram-keyword-search-scraper/examples/telegram-airdrop-mentions)

### Why this Telegram scraper

| | Typical Telegram keyword scrapers | This Actor |
|---|---|---|
| Where results come from | Pages Google happened to index | Telegram's own search in each channel |
| Every result contains the keyword | Often not | Yes, and each result says how it matched |
| Channels covered | Only indexed pages | 1,400+ large channels, your channels, web discovery and forwards |
| Only new posts on scheduled runs | No | Yes, with a monitor name |
| Login, API key or phone number | Sometimes | Never |
| Hidden extra runs | Some start a separate Google search Actor | No |

### Input

| Field | What it does | Default |
|---|---|---|
| `keywords` | Words or phrases to find. Each is searched separately. | required |
| `channels` | Public channels you want included (username, @username or t.me link). | none |
| `useDirectory` | Search the largest public channels from the built-in directory. | on |
| `directoryChannels` | How many directory channels to search per keyword. | 150 |
| `languages` | Only use directory channels in these languages. | all (English preselected in the form) |
| `discoverChannels` | Also find topic channels through web search. | on |
| `expandViaForwards` | Also search channels that matching posts forward from or mention. | on |
| `since` | Time window, like `24 hours`, `7 days`, `3 months`, or a date. | 30 days |
| `matchFilter` | `exact_phrase`, `all_words` or `any` (includes related words). | all_words |
| `maxResults` | Stop after this many posts. Also your cost cap. | 200 |
| `maxResultsPerChannel` | Most posts to take from one channel per keyword. | 40 |
| `minViews`, `minSubscribers` | Skip small posts or small channels. | 0 |
| `monitorKey` | Monitor name: return only new posts on each run. | none |
| `slackWebhookUrl` | Send new posts to Slack (incoming webhook URL). Stored encrypted. | none |
| `telegramBotToken`, `telegramChatId` | Send new posts to a Telegram chat through your bot. The token is stored encrypted. | none |
| `webhookUrl` | Send new posts as JSON to any endpoint, Make, Zapier or n8n. | none |

#### Example: brand monitoring in English channels

```json
{
  "keywords": ["notion ai", "notion calendar"],
  "languages": ["en"],
  "since": "7 days",
  "matchFilter": "exact_phrase"
}
```

#### Example: hourly crypto ticker monitor in big channels

```json
{
  "keywords": ["solana", "$SOL"],
  "minSubscribers": 50000,
  "monitorKey": "solana-watch",
  "since": "24 hours"
}
```

#### Example: only your own channel list

```json
{
  "keywords": ["layoffs"],
  "channels": ["WatcherGuru", "insiderpaper", "https://t.me/s/disclosetv"],
  "useDirectory": false,
  "discoverChannels": false
}
```

### Output

One row per matching Telegram post:

```json
{
  "keywords": ["openai"],
  "matchType": "exact_phrase",
  "channelUsername": "financialjuice",
  "channelTitle": "FinancialJuice",
  "channelSubscribers": 112000,
  "channelVerified": false,
  "discoveredVia": "directory",
  "messageId": 98765,
  "url": "https://t.me/financialjuice/98765",
  "postedAt": "2026-11-08T09:12:40+00:00",
  "text": "OpenAI is in talks to raise new funding ...",
  "views": 18400,
  "reactionsTotal": 96,
  "reactions": [{ "emoji": "🔥", "count": 61 }, { "emoji": "👍", "count": 35 }],
  "isForwarded": false,
  "forwardedFrom": null,
  "links": ["https://example.com/article"],
  "hashtags": [],
  "mentions": [],
  "mediaTypes": ["photo"],
  "isEdited": false,
  "scrapedAt": "2026-11-08T10:00:00.000Z"
}
```

**How results match** (`matchType`):

- `exact_phrase`: the whole keyword appears as you wrote it.
- `all_words`: every word of the keyword appears.
- `related`: Telegram's search found it, but not every word is literally there (for example "BTC" for "bitcoin"). Hidden by default.

**Run summary.** Each run also saves a `SUMMARY` record in its key-value store: results per keyword, exact matches, total views, the newest post and the top channels. Handy for dashboards and AI agents.

### How much does it cost to scrape Telegram?

You pay per result, and only for posts that match:

| What | Free plan | Bronze | Silver | Gold and up |
|---|---|---|---|---|
| Matching post, per 1,000 | **$3.00** | $2.70 | $2.40 | $2.10 |
| Web channel discovery, per keyword (only when turned on) | $0.01 | $0.01 | $0.01 | $0.01 |

Examples: 100 matching posts cost $0.30. A daily monitor that finds 20 new mentions costs about $0.06 per day. Channels without matches, filtered-out posts and errors are free. Set **Maximum results** to cap the cost of any run. Apify's free plan includes monthly credit, so you can try it without paying.

### Use it through the API, integrations and AI agents

- **API:** run the Actor and fetch results with one HTTP call, or use the Apify JavaScript and Python clients.
- **Integrations:** send results to Google Sheets, Slack, email, Make, Zapier, n8n or a webhook.
- **AI agents (MCP):** this Actor works as a tool in Claude, ChatGPT, Cursor and other MCP clients through the [Apify MCP server](https://mcp.apify.com). Ask, for example: *"What are Telegram channels saying about Solana in the last 24 hours? Summarize the top 10 posts by views."* Keep `maxResults` small for chat use.

Python example:

```python
from apify_client import ApifyClient

client = ApifyClient("<YOUR_API_TOKEN>")
run = client.actor("marvinkruell/telegram-keyword-search-scraper").call(
    run_input={"keywords": ["openai"], "languages": ["en"], "since": "7 days", "maxResults": 100}
)
for post in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(post["postedAt"], post["channelTitle"], post["views"], post["url"])
```

### Limits

- **Public channels only.** Groups, private channels, bots and direct messages need a Telegram login and are out of scope.
- **Web preview must be on.** A few public channels turn off their web preview; those are skipped automatically.
- **Coverage, not all of Telegram.** Nobody can search all of Telegram without an account. Coverage comes from the directory, your channels, web discovery and forwards. Add channels you care about to make sure they are included.
- Very new posts can take a few minutes to show up in Telegram's search.

### FAQ

**Can I search all of Telegram by keyword?**
Not without logging in; Telegram has no public global search. This Actor gets close by searching 1,400+ of the largest public channels plus channels you add and channels it discovers.

**Do I need a Telegram account, API ID or bot token?**
No. The Actor reads the public web versions of channels (`t.me/s/...`), the same pages anyone can open in a browser.

**How is this different from a Telegram channel scraper?**
A channel scraper downloads posts from channels you already know. This Actor finds the posts that mention your keyword across many channels, including ones you did not know about. If you only need everything from one channel, put it in `channels` and use a broad keyword, or use a dedicated channel scraper.

**Can I search in Russian, Arabic, Persian or other languages?**
Yes. Keywords work in any language, and you can limit the channel directory to specific languages.

**How often should I run a monitor?**
Every hour or every day works well. Each run only pays for new posts.

**Can I get the results in Excel or Google Sheets?**
Yes. Download as Excel or CSV from the run, or connect the Google Sheets integration.

**Is it legal to scrape Telegram?**
This Actor reads only public pages that Telegram publishes for everyone on the web, without logging in or bypassing access controls. Personal data can still appear in public posts, so make sure your use complies with laws such as GDPR. If in doubt, ask a lawyer.

### Feedback

Found a bug or missing a feature? Open an issue on the **Issues** tab. Requests for new data fields and channels are welcome.

# Actor input Schema

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

Words or phrases to search for, for example a brand, product, ticker or topic. Each keyword is searched separately.

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

Public channels you already know. Use a username, @username or t.me link. These are always searched, in addition to the channels found automatically.

## `useDirectory` (type: `boolean`):

Search your keywords in the largest active public Telegram channels from our channel directory (news, crypto, tech, finance and more, in many languages). This is where most mentions are found.

## `directoryChannels` (type: `integer`):

How many of the largest directory channels to search for each keyword. More channels find more mentions and take longer.

## `languages` (type: `array`):

Only search directory channels in these languages. Leave empty for all languages.

## `discoverChannels` (type: `boolean`):

Also look up channels about each keyword through web search engines and Telegram search sites.

## `maxChannelsPerKeyword` (type: `integer`):

How many automatically found channels with matches to keep per keyword. Channels you list yourself are always included.

## `expandViaForwards` (type: `boolean`):

Also search channels that matching posts forward from or mention. This finds related channels that search engines miss.

## `since` (type: `string`):

Only return posts newer than this. Use a window like "24 hours", "7 days" or "3 months", or a date like 2026-10-01. In monitor mode this applies to the first run only.

## `matchFilter` (type: `string`):

Telegram's search also finds related words (for example "BTC" for "bitcoin"). Choose whether to keep those.

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

Stop after this many posts in total, newest first. You pay per result, so this is also your cost cap.

## `maxResultsPerChannel` (type: `integer`):

How many matching posts to take from a single channel for each keyword.

## `minViews` (type: `integer`):

Skip posts with fewer views than this.

## `minSubscribers` (type: `integer`):

Skip channels with fewer subscribers than this.

## `monitorKey` (type: `string`):

Give your monitor a name, for example "my-brand", and schedule this Actor. Each run then returns only posts that are new since the last run with the same name, and you only pay for those.

## `slackWebhookUrl` (type: `string`):

Send new matches to a Slack channel. Create an incoming webhook in Slack and paste its URL here.

## `telegramBotToken` (type: `string`):

Send new matches to a Telegram chat. Create a bot with @BotFather, paste its token here, and add the chat ID below.

## `telegramChatId` (type: `string`):

The chat, group or channel the bot should post to, for example 123456789 or @mychannel. The bot must be allowed to post there.

## `webhookUrl` (type: `string`):

Send new matches as JSON (title, count, posts, summary) to your own endpoint, Make, Zapier or n8n.

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

How many Telegram pages to load at the same time.

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

Telegram pages are loaded directly first, which is fastest. If Telegram slows a request down, the retry goes through this proxy. The default works for most runs.

## Actor input object example

```json
{
  "keywords": [
    "bitcoin etf",
    "solana"
  ],
  "channels": [
    "cointelegraph",
    "@WatcherGuru",
    "https://t.me/s/wublockchainenglish"
  ],
  "useDirectory": true,
  "directoryChannels": 150,
  "languages": [
    "en"
  ],
  "discoverChannels": true,
  "maxChannelsPerKeyword": 15,
  "expandViaForwards": true,
  "since": "30 days",
  "matchFilter": "all_words",
  "maxResults": 200,
  "maxResultsPerChannel": 40,
  "minViews": 0,
  "minSubscribers": 0,
  "maxConcurrency": 24,
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}
```

# Actor output Schema

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

One row per Telegram post that matches your keywords.

## `summary` (type: `string`):

Results per keyword, top channels and total views.

# 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 = {
    "keywords": [
        "bitcoin etf"
    ],
    "channels": [
        "cointelegraph"
    ],
    "languages": [
        "en"
    ],
    "since": "30 days",
    "proxyConfiguration": {
        "useApifyProxy": true
    }
};

// Run the Actor and wait for it to finish
const run = await client.actor("marvinkruell/telegram-keyword-search-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 = {
    "keywords": ["bitcoin etf"],
    "channels": ["cointelegraph"],
    "languages": ["en"],
    "since": "30 days",
    "proxyConfiguration": { "useApifyProxy": True },
}

# Run the Actor and wait for it to finish
run = client.actor("marvinkruell/telegram-keyword-search-scraper").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 '{
  "keywords": [
    "bitcoin etf"
  ],
  "channels": [
    "cointelegraph"
  ],
  "languages": [
    "en"
  ],
  "since": "30 days",
  "proxyConfiguration": {
    "useApifyProxy": true
  }
}' |
apify call marvinkruell/telegram-keyword-search-scraper --silent --output-dataset

```

## MCP server setup

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

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/0RCcTUAoHGgouaTdN/builds/hltfUibKjljmYLpva/openapi.json