# TGKit Telegram Channel Finder Scraper (`automation-lab/tgkit-telegram-channel-finder-scraper`) Actor

Discover public Telegram channels, groups, and bots by keyword through TGKit. Export usernames, titles, member counts, entity types, and canonical t.me URLs. No Telegram login or API key required.

- **URL**: https://apify.com/automation-lab/tgkit-telegram-channel-finder-scraper.md
- **Developed by:** [Stas Persiianenko](https://apify.com/automation-lab) (community)
- **Categories:** Social media
- **Stats:** 1 total users, 1 monthly users, 90.9% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event

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 web data automations that power AI and operations. They run on the Apify platform to scrape websites, process data, connect APIs, and automate workflows.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js/docs.md):

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

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python/docs.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## TGKit Telegram Channel Finder Scraper

Find public Telegram channels, groups, and bots by keyword with the **TGKit Telegram Channel Finder Scraper**.
Turn topics such as `crypto news`, `football`, or `AI tools` into structured public handles, titles, member counts, entity types, and canonical `t.me` URLs.
No Telegram account, API key, or login is required.

Use the Actor when you know a topic but do not yet know which Telegram usernames to inspect.
It is designed as a fast discovery step before profile enrichment, message extraction, monitoring, advertising research, or OSINT analysis.

- 🔍 Search one or many keywords
- 🎯 Filter channels, groups, bots, or all public entities
- 🔗 Export ready-to-use Telegram profile URLs
- 📊 Preserve the input query and requested type in every row
- ⚡ Use lightweight HTTP requests rather than browser automation

### What does TGKit Telegram Channel Finder Scraper do?

The Actor searches the public [TGKit Channel Finder](https://tgkit.io/channel-finder/) directory.
For every unique match, it returns the Telegram username, display title, entity kind, member count, and canonical profile URL.

You can submit up to 20 search phrases in one run.
Results are deduplicated by username across all phrases, so overlapping keywords do not create duplicate leads.

This Actor focuses specifically on **keyword-to-handle discovery**.
If you already know a Telegram username and need profile details or messages, use one of the related Telegram actors listed below.

### Who is this Telegram channel finder for?

**Community and influencer researchers**

- Discover public communities around a market, language, niche, or trend.
- Compare member counts before selecting channels for deeper research.
- Build repeatable prospect lists without manually searching Telegram.

**Telegram advertisers and growth teams**

- Find channels and groups that may match a campaign topic.
- Export handles to Sheets, a CRM, or a review queue.
- Schedule discovery to refresh a changing outreach pipeline.

**OSINT and trust-and-safety analysts**

- Build public seed lists for follow-up collection.
- Preserve the discovery query and timestamp for auditability.
- Separate channels, groups, and bots before downstream analysis.

**Brand, crypto, and market monitoring teams**

- Search several brand or topic variants in one run.
- Feed discovered `t.me` links into profile or message scrapers.
- Repeat runs to spot newly indexed public entities.

### Why use this Telegram search scraper?

- **No Telegram login:** the source exposes anonymous public directory results.
- **No API credentials:** you do not need a Telegram developer application.
- **Focused output:** every row is a discovery result, not a mixture of posts and profiles.
- **Low overhead:** direct JSON extraction avoids browser startup and rendering costs.
- **Traceable records:** `query`, `requestedKind`, and `scrapedAt` explain how each username was found.
- **Stable exports:** use JSON, CSV, Excel, XML, RSS, or the Dataset API.
- **Automation ready:** schedule runs, trigger webhooks, and connect through Make, Zapier, or MCP.
- **Resilient requests:** bounded retries, response validation, and conservative concurrency handle temporary source errors.

### What Telegram data can you extract?

| Field | Type | Description |
|---|---|---|
| `query` | string | Search phrase that produced the first saved match |
| `requestedKind` | string | Requested filter: `any`, `channel`, `group`, or `bot` |
| `username` | string | Public Telegram username without `@` |
| `title` | string | Public channel, group, or bot title |
| `kind` | string | Entity type returned by TGKit |
| `members` | integer or null | Public member/subscriber count when TGKit supplies it |
| `telegramUrl` | URL | Canonical `https://t.me/{username}` link |
| `scrapedAt` | ISO date | UTC timestamp when the match was processed |

The Actor does not fabricate descriptions, languages, verification flags, or contact details when TGKit does not return them.
Use a related enrichment actor after discovery when you need more fields.

### How much does it cost to find Telegram channels?

This Actor uses **pay-per-event pricing**.
A small one-time start event covers request setup, and a result event is charged only for each unique Telegram entity saved.
Platform compute and storage costs are included in the event prices.

| Event | Free | Starter | Scale | Business |
|---|---:|---:|---:|---:|
| Run started | $0.005 | $0.005 | $0.005 | $0.005 |
| Item extracted | $0.0001572 | $0.0001367 | $0.00010662 | $0.000082019 |

For example, a Starter-plan run saving 10 unique entities costs about **$0.00637**: $0.005 start plus 10 × $0.0001367.
A run returning no matching entities only incurs the start event.
Higher Apify plans receive additional volume discounts.

Prices shown here are synchronized with the Actor configuration; always review the live run estimate before starting a large workflow.

### How to find Telegram channels by keyword

1. Open **TGKit Telegram Channel Finder Scraper** on Apify.
2. Add one or more phrases to **Search phrases**.
3. Choose **Channels**, **Groups**, **Bots**, or **Any entity**.
4. Set a small maximum for your first run.
5. Click **Start** and wait for the run to finish.
6. Open the Dataset tab to review usernames and `t.me` URLs.
7. Export the results or send them to a downstream Actor.

A minimal channel search input:

```json
{
  "queries": ["crypto news"],
  "kind": "channel",
  "maxResultsPerQuery": 5,
  "maxConcurrency": 2
}
````

A public group search:

```json
{
  "queries": ["football"],
  "kind": "group",
  "maxResultsPerQuery": 10,
  "maxConcurrency": 1
}
```

A multi-topic discovery run:

```json
{
  "queries": ["artificial intelligence", "machine learning", "AI news"],
  "kind": "any",
  "maxResultsPerQuery": 15,
  "maxConcurrency": 3
}
```

### Input parameters

| Parameter | Type | Default | Limits | Description |
|---|---|---|---|---|
| `queries` | string\[] | required | 1–20 phrases; 2–100 characters each | Topics or keywords to search |
| `kind` | string | `any` | `any`, `channel`, `group`, `bot` | Telegram entity filter |
| `maxResultsPerQuery` | integer | `10` | 1–20 | Maximum matches saved from each query |
| `maxConcurrency` | integer | `3` | 1–5 | Number of simultaneous TGKit searches |

Whitespace is trimmed from every query.
Exact duplicate query strings are removed before requests start.
Invalid values fail fast instead of being silently converted.

### Output example

```json
{
  "query": "crypto news",
  "requestedKind": "channel",
  "username": "cryptowallet_news_en",
  "title": "Wallet News",
  "kind": "channel",
  "members": 3768092,
  "telegramUrl": "https://t.me/cryptowallet_news_en",
  "scrapedAt": "2026-07-19T04:30:00.000Z"
}
```

`members` is emitted as a number, not formatted text, whenever TGKit supplies a public count.
Bots or other records without a source count use `null`; numeric values remain easy to sort and filter.

If the same username appears for two phrases, the first completed discovery is saved and later duplicates are skipped.
The source supplies a compact ranked list rather than an unlimited paginated catalog.

### Tips for better Telegram discovery

- Start with a specific two- or three-word phrase rather than a single broad word.
- Search spelling variants and industry synonyms in the same run.
- Use `kind: channel` for broadcast publishers and `kind: group` for communities.
- Use `kind: any` when you want bots and other public entity types in the same seed list.
- Keep concurrency at 1 or 2 if TGKit begins returning temporary rate limits.
- Schedule a small recurring run instead of one oversized batch when monitoring new entities.
- Sort `members` descending to prioritize larger communities.
- Review every public community before outreach; discovery does not imply endorsement.
- Feed canonical URLs into downstream Telegram actors instead of rebuilding links manually.

### Telegram research integrations

**TGKit finder → Telegram profile enrichment**

Discover unknown usernames here, then pass `telegramUrl` values to the [Telegram Info Scraper](https://apify.com/automation-lab/telegram-info-scraper) for known-handle details.

**TGKit finder → message monitoring**

Create a reviewed seed list, then send selected channels to the [Telegram Channel Messages Scraper](https://apify.com/automation-lab/telegram-channel-messages-scraper).

**TGKit finder → Google Sheets**

Schedule weekly topic searches and sync usernames, titles, member counts, and timestamps to a prospecting or research sheet.

**TGKit finder → Slack or Discord**

Use an Apify webhook to notify analysts when a scheduled run finds usernames not present in the previous export.

**TGKit finder → Make or Zapier**

Trigger enrichment, CRM deduplication, analyst review, or lead routing after each successful Dataset item.

**TGKit finder → data warehouse**

Pull Dataset items through the API, store snapshots by `scrapedAt`, and analyze changes in the discovered entity set over time.

### Using the Apify API with Node.js

Install the official client:

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

Run the Actor and read its dataset:

```javascript
import { ApifyClient } from 'apify-client';

const client = new ApifyClient({ token: process.env.APIFY_TOKEN });
const run = await client.actor('automation-lab/tgkit-telegram-channel-finder-scraper').call({
    queries: ['crypto news', 'blockchain'],
    kind: 'channel',
    maxResultsPerQuery: 10,
    maxConcurrency: 2,
});
const { items } = await client.dataset(run.defaultDatasetId).listItems();
console.log(items);
```

### Using the Apify API with Python

```bash
pip install apify-client
```

```python
import os
from apify_client import ApifyClient

client = ApifyClient(os.environ['APIFY_TOKEN'])
run = client.actor('automation-lab/tgkit-telegram-channel-finder-scraper').call(run_input={
    'queries': ['football'],
    'kind': 'group',
    'maxResultsPerQuery': 10,
    'maxConcurrency': 1,
})
items = client.dataset(run['defaultDatasetId']).list_items().items
print(items)
```

### Using the Apify API with cURL

```bash
curl -X POST \
  "https://api.apify.com/v2/acts/automation-lab~tgkit-telegram-channel-finder-scraper/runs?token=$APIFY_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "queries": ["AI tools"],
    "kind": "any",
    "maxResultsPerQuery": 10,
    "maxConcurrency": 2
  }'
```

After the run succeeds, use its `defaultDatasetId` to fetch items from the Dataset API.
Never embed an Apify token in public source code.

### Use with AI agents via MCP

TGKit Telegram Channel Finder Scraper can be used by assistants supporting the [Model Context Protocol](https://docs.apify.com/platform/integrations/mcp).
The hosted Apify MCP server lets an agent start the Actor and inspect its output with your authorization.

For Claude Code:

```bash
claude mcp add --transport http apify "https://mcp.apify.com?tools=automation-lab/tgkit-telegram-channel-finder-scraper"
```

For Claude Desktop, Cursor, or VS Code, add:

```json
{
  "mcpServers": {
    "apify": {
      "url": "https://mcp.apify.com?tools=automation-lab/tgkit-telegram-channel-finder-scraper"
    }
  }
}
```

Example prompts:

- “Use `automation-lab/tgkit-telegram-channel-finder-scraper` to find public crypto news channels and rank them by members.”
- “Find public football discussion groups on Telegram and return usernames with canonical profile links.”
- “Build a deduplicated Telegram OSINT seed list for AI, machine learning, and generative AI monitoring.”

OAuth asks you to authorize access to your Apify account on first use.

### Scheduling Telegram discovery runs

Use an Apify schedule when the workflow depends on fresh public entities.
A daily run can watch fast-moving crypto or brand topics, while a weekly run is often enough for slower research lists.

Recommended recurring workflow:

1. Run several stable keyword variants.
2. Export Dataset items to a persistent table or named dataset.
3. Compare `username` against previously reviewed entities.
4. Route only new usernames to analysts or enrichment actors.
5. Keep the original `query` and `scrapedAt` fields for provenance.

The Actor does not maintain historical state itself.
Your integration decides how to compare snapshots and trigger alerts.

### Reliability and source limits

TGKit is a third-party public directory and may change its endpoint, ranking, fields, or availability.
The Actor validates the JSON response so an incompatible payload does not silently create corrupt rows.

Temporary 408, 425, 429, and common 5xx responses are retried with backoff.
A partial multi-query run preserves successful query results and logs failures.
If every query request fails, the Actor exits with a failed status rather than reporting false success.

A valid empty result list is not an error.
It means TGKit returned no indexed matches for that phrase and entity type at run time.
The source currently returns compact ranked results and does not expose unlimited pagination.

### Is it legal to scrape TGKit and Telegram directory data?

This Actor extracts public directory data exposed without login.
Public availability does not remove your responsibility to follow applicable laws, platform terms, and ethical-use standards.

Do not use the output for harassment, spam, unlawful profiling, or attempts to access private Telegram communities.
When handling personal data, establish a lawful purpose, minimize retained data, respect deletion requests, and comply with GDPR or other relevant regulations.

This documentation is general information, not legal advice.
Consult qualified counsel for regulated or high-risk use cases.

### Troubleshooting

**Why did my query return no rows?**

TGKit may not index an entity matching that phrase and type.
Try `kind: any`, shorten an overly specific phrase, check spelling, or search a related term.
A valid zero-result response is shown in logs and succeeds without per-result charges.

**Why are fewer rows returned than my maximum?**

`maxResultsPerQuery` is a cap, not a promise.
TGKit returns a compact ranked set, and global username deduplication can reduce the saved count when several queries overlap.

**Why did the run fail after retries?**

The public source may be temporarily unavailable or rate limiting requests.
Retry later with fewer queries and `maxConcurrency: 1`.
The run fails only when all source searches fail or the response format is no longer compatible.

**Why is a member count different from Telegram or null?**

Member counts are snapshots returned by TGKit and can lag the live Telegram profile.
Some bots have no count in the source and return `null`; use counts for discovery and rough prioritization rather than exact real-time analytics.

### FAQ

**How fast is the Telegram channel finder?**

A small search usually completes in seconds because the Actor calls a public JSON endpoint and does not launch a browser.
Runtime depends on query count, retries, source response time, and concurrency.

**Do I need a Telegram account or API key?**

No.
The Actor searches an anonymous public TGKit surface and does not ask for Telegram credentials.

**Can it search private Telegram groups?**

No.
It only returns public entities indexed by TGKit and never attempts to join, bypass access controls, or expose private groups.

**Does it scrape Telegram messages?**

No.
This Actor discovers public handles by keyword.
Use the Telegram Channel Messages Scraper after reviewing the discovered channels.

**Can I use the results as advertising leads?**

You can use public data for legitimate research subject to applicable laws and platform rules.
Review relevance manually and avoid unsolicited spam or abusive outreach.

**How are duplicate results handled?**

Usernames are compared case-insensitively across the entire run.
Only the first occurrence is saved and charged.

**How much will my run cost?**

Cost equals the one-time start event plus the plan-specific price for each unique saved entity.
Check the pricing table above and the Apify run estimate before large workloads.

### Other Telegram and discovery actors

- [Telegram Scraper](https://apify.com/automation-lab/telegram-scraper) — enrich known public channels and extract messages.
- [Telegram Info Scraper](https://apify.com/automation-lab/telegram-info-scraper) — inspect known Telegram handles and profile URLs.
- [Telegram Channel Messages Scraper](https://apify.com/automation-lab/telegram-channel-messages-scraper) — collect public message history from selected channels.
- [Telegram Media Downloader](https://apify.com/automation-lab/telegram-media-downloader) — download media from known public Telegram sources.
- [Cross-Platform OSINT Seed List Monitor](https://apify.com/automation-lab/cross-platform-osint-seed-list-monitor) — monitor reviewed public identifiers across platforms.
- [YouTube Channel Search Scraper](https://apify.com/automation-lab/youtube-channel-search-scraper) — discover YouTube channels by keyword for cross-platform creator research.

Use this Actor first when your starting point is a **topic**.
Use the enrichment and message actors when your starting point is already a **known Telegram username or URL**.

# Actor input Schema

## `queries` (type: `array`):

Add 1–20 keywords or topics, such as crypto news, football, or AI tools.

## `kind` (type: `string`):

Choose all matching public entities or restrict discovery to channels, groups, or bots.

## `maxResultsPerQuery` (type: `integer`):

Limit the number of Telegram entities saved for each search phrase.

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

Control simultaneous TGKit requests. Lower this if the source is rate limiting.

## Actor input object example

```json
{
  "queries": [
    "crypto news"
  ],
  "kind": "channel",
  "maxResultsPerQuery": 5,
  "maxConcurrency": 2
}
```

# Actor output Schema

## `overview` (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 = {
    "queries": [
        "crypto news"
    ],
    "kind": "channel",
    "maxResultsPerQuery": 5,
    "maxConcurrency": 2
};

// Run the Actor and wait for it to finish
const run = await client.actor("automation-lab/tgkit-telegram-channel-finder-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 = {
    "queries": ["crypto news"],
    "kind": "channel",
    "maxResultsPerQuery": 5,
    "maxConcurrency": 2,
}

# Run the Actor and wait for it to finish
run = client.actor("automation-lab/tgkit-telegram-channel-finder-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 '{
  "queries": [
    "crypto news"
  ],
  "kind": "channel",
  "maxResultsPerQuery": 5,
  "maxConcurrency": 2
}' |
apify call automation-lab/tgkit-telegram-channel-finder-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "TGKit Telegram Channel Finder Scraper",
        "description": "Discover public Telegram channels, groups, and bots by keyword through TGKit. Export usernames, titles, member counts, entity types, and canonical t.me URLs. No Telegram login or API key required.",
        "version": "0.1",
        "x-build-id": "C2xFL6InoWX0RCOcR"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/automation-lab~tgkit-telegram-channel-finder-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-automation-lab-tgkit-telegram-channel-finder-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/automation-lab~tgkit-telegram-channel-finder-scraper/runs": {
            "post": {
                "operationId": "runs-sync-automation-lab-tgkit-telegram-channel-finder-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/automation-lab~tgkit-telegram-channel-finder-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-automation-lab-tgkit-telegram-channel-finder-scraper",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "required": [
                    "queries"
                ],
                "properties": {
                    "queries": {
                        "title": "Search phrases",
                        "minItems": 1,
                        "maxItems": 20,
                        "type": "array",
                        "description": "Add 1–20 keywords or topics, such as crypto news, football, or AI tools.",
                        "items": {
                            "type": "string",
                            "minLength": 2,
                            "maxLength": 100
                        }
                    },
                    "kind": {
                        "title": "Telegram entity type",
                        "enum": [
                            "any",
                            "channel",
                            "group",
                            "bot"
                        ],
                        "type": "string",
                        "description": "Choose all matching public entities or restrict discovery to channels, groups, or bots.",
                        "default": "any"
                    },
                    "maxResultsPerQuery": {
                        "title": "Maximum matches per phrase",
                        "minimum": 1,
                        "maximum": 20,
                        "type": "integer",
                        "description": "Limit the number of Telegram entities saved for each search phrase.",
                        "default": 10
                    },
                    "maxConcurrency": {
                        "title": "Parallel searches",
                        "minimum": 1,
                        "maximum": 5,
                        "type": "integer",
                        "description": "Control simultaneous TGKit requests. Lower this if the source is rate limiting.",
                        "default": 3
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```