Pricing

from $4.99 / 1,000 results

Telegram Channels Search Scraper

Search Telegram channels, groups, and bots by keyword. Get titles, descriptions, subscriber counts, languages, and profile links. 🔍

Pricing

from $4.99 / 1,000 results

Rating

0.0

(0)

Developer

EasyApi

Actor stats

Bookmarked

Total users

Monthly active users

17 days ago

Last modified

.actor/Dockerfile

# Specify the base Docker image. You can read more about
# the available images at https://docs.apify.com/sdk/js/docs/guides/docker-images
# You can also use any other image from Docker Hub.
FROM apify/actor-node-puppeteer-chrome
# Check preinstalled packages
RUN npm ls crawlee apify puppeteer playwright

# Copy just package.json and package-lock.json
# to speed up the build using Docker layer cache.
COPY package*.json ./

# Install NPM packages, skip optional and development dependencies to
# keep the image small. Avoid logging too much and print the dependency
# tree for debugging
RUN npm --quiet set progress=false \
    && npm install --omit=dev --omit=optional \
    && echo "Installed NPM packages:" \
    && (npm list --omit=dev --all || true) \
    && echo "Node.js version:" \
    && node --version \
    && echo "NPM version:" \
    && npm --version \
    && rm -r ~/.npm

# Next, copy the remaining files and directories with the source code.
# Since we do this after NPM install, quick build will be really fast
# for most source file changes.
COPY . ./


# Run the image.
CMD npm start --silent

.actor/actor.json

{
    "actorSpecification": 1,
    "name": "telegram-channels-search-scraper",
    "title": "Empty JavaScript project",
    "description": "Empty project in JavaScript.",
    "version": "0.0",
    "buildTag": "latest",
    "meta": {
        "templateId": "js-empty"
    },
    "input": "./input_schema.json",
    "dockerfile": "./Dockerfile"
}

.actor/input_schema.json

{
    "title": "Telegram Channels Search Scraper Input",
    "type": "object",
    "schemaVersion": 1,
    "properties": {
        "keyword": {
            "title": "Keyword",
            "type": "string",
            "description": "Keyword to search Telegram channels, groups, and bots",
            "editor": "textfield",
            "default": "app",
            "prefill": "app"
        },
        "maxItems": {
            "title": "Maximum Results",
            "type": "integer",
            "description": "Maximum number of channels to scrape",
            "default": 100,
            "prefill": 100,
            "minimum": 1,
            "maximum": 50000
        },
        "proxyConfiguration": {
            "title": "Proxy Configuration",
            "type": "object",
            "description": "Proxy settings for the browser session",
            "default": { 
                "useApifyProxy": true,
                "apifyProxyGroups": [
                    "RESIDENTIAL"
                ]
            },
            "prefill": { 
                "useApifyProxy": true,
                "apifyProxyGroups": [
                    "RESIDENTIAL"
                ]
            },
            "editor": "proxy"
        }
    },
    "required": ["keyword"]
}

src/main.js

1import { Actor } from 'apify';
2import { connect as connectRealBrowser } from 'puppeteer-real-browser';
3
4const SITE_BASE = 'https://telegramchannels.me';
5
6const SCRAPER_CONFIG = {
7    turnstile: true,
8    headless: false,
9};
10
11class TelegramChannelsSearchScraper {
12    async getPageStats(page) {
13        try {
14            return await page.evaluate(() => {
15                const body = document.body;
16                const bodyText = body?.innerText || '';
17
18                return {
19                    title: document.title || '',
20                    bodyText,
21                    cardCount: document.querySelectorAll('a.index-card').length,
22                    hasPagination: Boolean(document.querySelector('.index-pagination-current')),
23                    ready: Boolean(body),
24                    error: null,
25                };
26            });
27        } catch (error) {
28            return {
29                title: '',
30                bodyText: '',
31                cardCount: 0,
32                hasPagination: false,
33                ready: false,
34                error: error.message,
35            };
36        }
37    }
38
39    isCloudflareChallenge(title = '', bodyText = '') {
40        return (
41            title.includes('Just a moment') ||
42            title.includes('Attention Required') ||
43            title.includes('Cloudflare') ||
44            /security verification/i.test(bodyText)
45        );
46    }
47
48    isPageContentReady(stats) {
49        return stats.cardCount > 0 || stats.hasPagination;
50    }
51
52    async waitForPageReady(page, timeoutMs = 30000) {
53        const start = Date.now();
54
55        while (Date.now() - start < timeoutMs) {
56            const stats = await this.getPageStats(page);
57            if (stats.ready && !stats.error) {
58                return stats;
59            }
60
61            await this.randomDelay(500, 1000);
62        }
63
64        return this.getPageStats(page);
65    }
66
67    buildProxyOptions(proxyUrl) {
68        if (!proxyUrl) return undefined;
69
70        try {
71            const parsed = new URL(proxyUrl);
72            if (!parsed.hostname || !parsed.port) return undefined;
73
74            return {
75                host: parsed.hostname,
76                port: Number(parsed.port),
77                username: parsed.username || undefined,
78                password: parsed.password || undefined,
79            };
80        } catch (error) {
81            console.warn('Invalid proxy configuration');
82            return undefined;
83        }
84    }
85
86    buildSearchUrl(keyword, page = 1) {
87        const params = new URLSearchParams({ q: keyword });
88        if (page > 1) {
89            params.set('page', String(page));
90        }
91        return `${SITE_BASE}/index?${params.toString()}`;
92    }
93
94    async run(input) {
95        const { keyword, maxItems = 100, proxyConfiguration } = input;
96        const searchKeyword = String(keyword || '').trim();
97        const itemLimit = Number(maxItems);
98
99        if (!searchKeyword) {
100            throw new Error('Input must include a keyword');
101        }
102
103        if (!Number.isFinite(itemLimit) || itemLimit < 1) {
104            throw new Error('maxItems must be a positive number');
105        }
106
107        const proxyConfig = proxyConfiguration
108            ? await Actor.createProxyConfiguration(proxyConfiguration)
109            : undefined;
110
111        const maxAttempts = 2;
112
113        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
114            const proxyUrl = proxyConfig ? await proxyConfig.newUrl() : undefined;
115            const proxyOptions = this.buildProxyOptions(proxyUrl);
116
117            const realBrowserOption = {
118                args: ['--start-maximized', '--no-sandbox'],
119                turnstile: SCRAPER_CONFIG.turnstile,
120                headless: SCRAPER_CONFIG.headless,
121                customConfig: {},
122                connectOption: {
123                    defaultViewport: { width: 1400, height: 900 },
124                },
125                ...(proxyOptions ? { proxy: proxyOptions } : {}),
126                plugins: [],
127            };
128
129            let browser;
130            try {
131                const { page, browser: connectedBrowser } = await connectRealBrowser(realBrowserOption);
132                browser = connectedBrowser;
133
134                await page.setDefaultNavigationTimeout(180000);
135                await page.setDefaultTimeout(180000);
136
137                await this.scrapeKeyword(page, searchKeyword, itemLimit);
138                return;
139            } catch (error) {
140                const message = error?.message || String(error);
141                const retryable = message.includes('Verification timed out');
142
143                if (!retryable || attempt === maxAttempts) {
144                    throw error;
145                }
146
147                console.log(`Attempt ${attempt} failed (${message}), retrying with a fresh browser session...`);
148            } finally {
149                if (browser) {
150                    await browser.close();
151                }
152            }
153
154            await this.randomDelay(2000, 4000);
155        }
156    }
157
158    async safeGoto(page, url, options = {}) {
159        const opts = { waitUntil: 'domcontentloaded', timeout: 180000, ...options };
160
161        for (let attempt = 1; attempt <= 3; attempt++) {
162            try {
163                await page.goto(url, opts);
164                return;
165            } catch (error) {
166                const message = error?.message || String(error);
167                const abortable = message.includes('ERR_ABORTED') || message.includes('net::ERR_');
168                if (!abortable || attempt === 3) {
169                    throw error;
170                }
171
172                await this.randomDelay(1500, 2500);
173            }
174        }
175    }
176
177    async scrapeKeyword(page, keyword, maxItems) {
178        console.log(`Searching channels for "${keyword}"...`);
179
180        await this.safeGoto(page, SITE_BASE).catch(() => {});
181        await this.waitForCloudflare(page);
182        await this.randomDelay(1500, 2500);
183
184        let pageNumber = 1;
185        let totalSaved = 0;
186        const seen = new Set();
187
188        while (totalSaved < maxItems) {
189            const searchUrl = this.buildSearchUrl(keyword, pageNumber);
190
191            await this.safeGoto(page, searchUrl);
192            await this.waitForCloudflare(page);
193            await this.waitForResults(page);
194            await this.scrollResults(page);
195
196            const pageMeta = await this.getPageMeta(page);
197            const items = await this.extractChannels(page, keyword);
198
199            if (items.length === 0) {
200                break;
201            }
202
203            const results = [];
204            for (const item of items) {
205                if (totalSaved >= maxItems) break;
206
207                const key = `${item.title}::${item.openUrl || ''}`;
208                if (seen.has(key)) continue;
209                seen.add(key);
210
211                results.push({
212                    ...item,
213                    scrapedAt: new Date().toISOString(),
214                });
215                totalSaved++;
216            }
217
218            if (results.length > 0) {
219                await Actor.pushData(results);
220                console.log(`Saved ${totalSaved} channels for "${keyword}"`);
221            }
222
223            if (totalSaved >= maxItems) {
224                break;
225            }
226
227            const hasNextPage = pageMeta.currentPage < pageMeta.totalPages;
228            if (!hasNextPage) {
229                break;
230            }
231
232            pageNumber++;
233            await this.randomDelay(1500, 2500);
234        }
235
236        if (totalSaved === 0) {
237            console.log(`No channels found for "${keyword}"`);
238            await Actor.pushData([
239                {
240                    searchKeyword: keyword,
241                    error: 'No channels found',
242                    scrapedAt: new Date().toISOString(),
243                },
244            ]);
245            return;
246        }
247    }
248
249    async waitForCloudflare(page, timeoutMs = 180000) {
250        const start = Date.now();
251        let sawChallenge = false;
252        let lastReloadAt = 0;
253
254        while (Date.now() - start < timeoutMs) {
255            try {
256                const stats = await this.getPageStats(page);
257
258                if (stats.error) {
259                    await this.randomDelay(1000, 2000);
260                    continue;
261                }
262
263                if (this.isPageContentReady(stats)) {
264                    if (sawChallenge) {
265                        const seconds = Math.round((Date.now() - start) / 1000);
266                        console.log(`Security check — passed (${seconds}s)`);
267                    }
268                    await this.waitForPageReady(page);
269                    return;
270                }
271
272                if (!this.isCloudflareChallenge(stats.title, stats.bodyText)) {
273                    if (sawChallenge) {
274                        const seconds = Math.round((Date.now() - start) / 1000);
275                        console.log(`Security check — passed (${seconds}s)`);
276                    }
277                    await this.waitForPageReady(page);
278                    return;
279                }
280
281                if (!sawChallenge) {
282                    sawChallenge = true;
283                    console.log('Security check — waiting...');
284                }
285
286                const elapsed = Date.now() - start;
287                if (elapsed - lastReloadAt > 45000) {
288                    console.log('Security check — reloading page...');
289                    try {
290                        await page.reload({ waitUntil: 'domcontentloaded', timeout: 180000 });
291                    } catch {
292                        // navigation may fail during reload
293                    }
294                    lastReloadAt = elapsed;
295                }
296            } catch {
297                // navigation in progress
298            }
299
300            await this.randomDelay(1000, 2000);
301        }
302
303        throw new Error('Verification timed out');
304    }
305
306    async waitForResults(page, timeoutMs = 90000) {
307        const start = Date.now();
308        let previousCount = -1;
309        let stableRounds = 0;
310
311        while (Date.now() - start < timeoutMs) {
312            const stats = await this.getPageStats(page);
313
314            if (stats.error) {
315                await this.randomDelay(500, 800);
316                continue;
317            }
318
319            if (stats.cardCount > 0) {
320                if (stats.cardCount === previousCount) {
321                    stableRounds++;
322                    if (stableRounds >= 2) {
323                        await this.randomDelay(800, 1200);
324                        return;
325                    }
326                } else {
327                    stableRounds = 0;
328                    previousCount = stats.cardCount;
329                }
330            }
331
332            await this.randomDelay(500, 800);
333        }
334
335        throw new Error('Search results did not load');
336    }
337
338    async scrollResults(page) {
339        let previousCount = 0;
340        let stableRounds = 0;
341
342        for (let i = 0; i < 10; i++) {
343            const count = await page.evaluate(() => {
344                window.scrollTo(0, document.body.scrollHeight);
345                return document.querySelectorAll('a.index-card').length;
346            });
347
348            if (count === previousCount) {
349                stableRounds++;
350                if (stableRounds >= 2) {
351                    break;
352                }
353            } else {
354                stableRounds = 0;
355                previousCount = count;
356            }
357
358            await this.randomDelay(800, 1200);
359        }
360    }
361
362    async getPageMeta(page) {
363        return page.evaluate(() => {
364            const pageText = document.querySelector('.index-pagination-current')?.textContent || '';
365            const match = pageText.match(/Page\s+(\d+)\s*\/\s*(\d+)/i);
366
367            return {
368                currentPage: match ? Number(match[1]) : 1,
369                totalPages: match ? Number(match[2]) : 1,
370            };
371        });
372    }
373
374    async extractChannels(page, keyword) {
375        return page.evaluate((searchKeyword) => {
376            const parseOpenUrl = (onclick) => {
377                if (!onclick) return null;
378
379                const indexOpenMatch = onclick.match(/indexOpen\(event,'([^']+)'\)/);
380                if (indexOpenMatch) return indexOpenMatch[1];
381
382                const gowMatch = onclick.match(/gow\(this,'([^']+)'\)/);
383                if (gowMatch) return gowMatch[1];
384
385                return null;
386            };
387
388            const parseTags = (card) => {
389                const tags = [...card.querySelectorAll('.index-card-tag')].map((tag) =>
390                    tag.textContent?.replace(/\s+/g, ' ').trim(),
391                );
392
393                let type = null;
394                let subscribers = null;
395                let language = null;
396
397                for (const tag of tags) {
398                    const lower = tag.toLowerCase();
399                    if (['channel', 'group', 'bot'].includes(lower)) {
400                        type = lower;
401                    } else if (/^[a-z]{2}$/i.test(tag)) {
402                        language = tag.toLowerCase();
403                    } else if (tag) {
404                        subscribers = tag;
405                    }
406                }
407
408                return { type, subscribers, language };
409            };
410
411            return [...document.querySelectorAll('a.index-card')].map((card) => {
412                const { type, subscribers, language } = parseTags(card);
413                const avatarImg = card.querySelector('.index-card-avatar img');
414
415                return {
416                    searchKeyword,
417                    title: card.querySelector('.index-card-title')?.textContent?.trim() || null,
418                    description: card.querySelector('.index-card-desc')?.textContent?.trim() || null,
419                    type,
420                    subscribers,
421                    language,
422                    verified: Boolean(card.querySelector('.index-card-verified')),
423                    sponsored: card.classList.contains('index-card-sponsored'),
424                    avatarUrl: avatarImg?.src || null,
425                    openUrl: parseOpenUrl(card.getAttribute('onclick')),
426                };
427            });
428        }, keyword);
429    }
430
431    async randomDelay(min = 500, max = 1500) {
432        const delay = Math.floor(Math.random() * (max - min + 1) + min);
433        await new Promise((resolve) => setTimeout(resolve, delay));
434    }
435}
436
437await Actor.init();
438
439Actor.main(async () => {
440    const input = await Actor.getInput();
441    const scraper = new TelegramChannelsSearchScraper();
442    await scraper.run(input);
443});

.dockerignore

# configurations
.idea

# crawlee and apify storage folders
apify_storage
crawlee_storage
storage

# installed files
node_modules

# git folder
.git

.editorconfig

root = true

[*]
indent_style = space
indent_size = 4
charset = utf-8
trim_trailing_whitespace = true
insert_final_newline = true
end_of_line = lf

.eslintrc

{
    "extends": "@apify",
    "root": true
}

.gitignore

# This file tells Git which files shouldn't be added to source control

.DS_Store
.idea
node_modules
storage

package.json

{
    "name": "js-scrape-single-page",
    "version": "0.0.1",
    "type": "module",
    "description": "This is an example of an Apify actor.",
    "engines": {
        "node": ">=18.0.0"
    },
    "dependencies": {
		"apify": "^3.4.4",
        "axios": "^1.7.7",
        "cheerio": "^1.0.0",
        "crypto-js": "^4.1.1",
        "puppeteer-real-browser": "^1.4.4"
    },
    "scripts": {
        "start": "node ./src/main.js",
        "test": "echo \"Error: oops, the actor has no tests yet, sad!\" && exit 1"
    },
    "author": "It's not you it's me",
    "license": "ISC"
}

Telegram Channels Ranking Scraper

easyapi/telegram-channels-ranking-scraper

Browse top-ranked Telegram channels and groups by language, category, and type. Get ranks, subscriber counts, and profile links. 📊

EasyApi

Telegram Channels Scraper

i-scraper/telegram-channels-scraper

⚡️ Telegram Channels Scraper: Extract posts from public Telegram channels.

i-Scraper

241

5.0

Telegram Channels Scraper

pamnard/telegram-channels-scraper

Scrapes channels data from Telegram

Mike

878

1.0

Telegram Info Scraper

automation-lab/telegram-info-scraper

Resolve public Telegram handles, channels, groups, bots, and profiles into clean metadata rows without Telegram login.

Stas Persiianenko

Telegram Channels Scraper

maximedupre/telegram-channels-scraper

Search Telegram channels by keyword or enrich known handles and t.me links. Export channel titles, URLs, descriptions, member counts, and verification flags.

Maxime Dupré

Telegram Info Scraper

maximedupre/telegram-info-scraper

Get public Telegram profile data from usernames, @handles, t.me links, channels, groups, and bots. Export titles, bios, member counts, verification flags, profile photos, statuses, and source URLs.

Maxime Dupré

100

Telegram Groups Search Scraper

powerai/telegram-groups-search-scraper

Search and rank Telegram groups by keyword. Get member counts, rankings, language, avatars, and Telegram links with automatic pagination. 📊

PowerAI

5.0

Telegram Channels Scraper – Cheap 📱

contactminerlabs/telegram-channels-scraper---cheap

🔍 Scrape Mass/Bulk Telegram Channels Enter any keyword & extract relevant Telegram channels, including channel name, description, subscriber count & channel URL 📢 Perfect for audience research, community discovery, trend monitoring, influencer discovery, competitor tracking or AI pipelines