# Telegram Username Checker: Channel, Group, Bot & User Info (`larkmoor/telegram-username-checker`) Actor

Bulk-check Telegram usernames, @handles and t.me links: exists or not, type (channel, group, bot, user), title, bio, subscribers, members online, verified badge, photo, last post date and average views. No login or phone. $0.80 per 1,000; not-found names free.

- **URL**: https://apify.com/larkmoor/telegram-username-checker.md
- **Developed by:** [Larkmoor Data](https://apify.com/larkmoor) (community)
- **Categories:** Social media, Lead generation
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, 0 bookmarks
- **User rating**: No ratings yet

## Pricing

from $0.68 / 1,000 telegram profiles

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 Username Checker: Channel, Group, Bot & User Info

Check thousands of Telegram usernames, @handles and t.me links in one run. For each one you get: **does it exist**, **what it is** (channel, group, bot, user or invite link), its title, description / bio, **subscriber or member count**, how many members are online, the **verified** badge, scam/fake flags, the profile photo and, for channels, **when it last posted** and the **average views** of its recent posts.

The data comes from Telegram's own public preview pages (`t.me/<name>` and `t.me/s/<name>`), the pages Telegram shows to anyone without an account. No login, no phone number, no Telegram API keys, no session files.

### What you can use it for

- **Clean a list of Telegram handles**: find which usernames exist, which are dead and which point to the wrong kind of account
- **Influencer and channel research**: rank channels by subscribers, see if they are still active (last post date) and how many views posts really get
- **Lead lists**: keep only channels and groups above a size you choose
- **Brand protection**: check whether a username for your brand is taken, verified or flagged as scam/fake
- **Monitoring**: schedule the actor daily to track subscriber growth and posting activity of competitor channels
- **Username availability**: names that come back `not_found` are not used by a public channel, group, bot or user

### Why this one

- **$0.80 per 1,000 existing usernames** — and **not-found or invalid names are free**, so cleaning a list costs only what is real
- **Type detection**: channel, group (members + online), bot, user, invite link
- **Activity signals for channels** at no extra cost: last post date, days since last post, average views of recent posts, photo/video/link counters
- **Any input format**: `durov`, `@durov`, `t.me/durov`, `https://t.me/s/durov`, `tg://resolve?domain=durov`, `t.me/+invite`
- **Filters that save money**: only certain types, minimum subscribers — filtered rows are not charged

### Input

| Field | What it does |
|---|---|
| Usernames or links | Any mix of names, @handles and t.me links |
| Channel activity | Last post date, average views, media counts (default on) |
| Only output existing usernames | Hide not-found / invalid rows (free anyway) |
| Only these types | Channel, group, bot, user, invite |
| Minimum subscribers / members | Skip small channels and groups |
| Max usernames | Cap per run |
| Parallel checks | 1–8 (default 4) |

```json
{
  "usernames": ["durov", "@telegram", "https://t.me/BotFather", "t.me/python", "thisnamedoesnotexist_123"],
  "includeChannelActivity": true,
  "minSubscribers": 0
}
```

### Output

A channel:

```json
{
  "input": "durov",
  "username": "durov",
  "url": "https://t.me/durov",
  "type": "channel",
  "exists": true,
  "title": "Pavel Durov",
  "description": "Founder of Telegram.",
  "verified": true,
  "scamOrFake": false,
  "subscribers": 10194770,
  "photoUrl": "https://cdn4.telesco.pe/file/...",
  "previewUrl": "https://t.me/s/durov",
  "photosCount": 102,
  "videosCount": 47,
  "linksCount": 200,
  "lastPostDate": "2026-10-11T14:52:40+00:00",
  "daysSinceLastPost": 18.8,
  "avgViewsRecentPosts": 4684000,
  "recentPostsSampled": 20,
  "checkedAt": "2026-10-30T10:38:11+00:00"
}
```

A group returns `members` and `online`; a bot returns `type: "bot"`; a name nobody uses returns `{"exists": false, "type": "not_found"}` (free).

#### Fields

| Field | Meaning |
|---|---|
| `exists` | true when Telegram shows a public page for the name |
| `type` | channel, group, bot, user, invite, not_found or invalid |
| `title`, `description` | Display name and bio / channel description as shown publicly |
| `subscribers` / `members` / `online` | Audience size for channels and groups |
| `verified`, `scamOrFake`, `flag` | Telegram's verified badge and SCAM / FAKE labels |
| `photoUrl` | Profile or channel photo |
| `lastPostDate`, `daysSinceLastPost` | Channel activity (channel activity option) |
| `avgViewsRecentPosts`, `recentPostsSampled` | Average views of the latest public posts |
| `photosCount`, `videosCount`, `filesCount`, `linksCount` | Media counters on the channel page |

### How much does it cost?

Pay per event: **$0.0008 per existing username** plus $0.001 per run start. Not-found, invalid and expired-invite rows cost nothing. Higher Apify plans get tier discounts (Bronze −5%, Silver −10%, Gold and up −15%).

Worked examples (Free tier):

- **1,000 handles from a spreadsheet, 700 exist**: 700 × $0.0008 = **$0.56**
- **50 competitor channels checked every day for a month**: 1,500 × $0.0008 = **$1.20**
- **10,000 names, only channels with 5,000+ subscribers kept (900 rows)**: **$0.72**

### FAQ

**Is it legal?** The actor reads only what Telegram itself publishes on its public preview pages for anyone on the web. It never logs in, never joins groups and never reads private chats. Use the data in line with Telegram's terms and privacy laws that apply to you (for example GDPR when you process data about people).

**Why is a user's member count empty?** Telegram shows counts only for channels and groups.

**Does it see private channels or groups?** No. Private ones and expired invite links return `exists: false`.

**Is not_found the same as "available to register"?** Mostly. Some names are reserved or held by private accounts with no public page, so treat it as a strong hint, not a guarantee.

**How fresh is the data?** It is read live when the actor runs.

**Do photo links last?** Telegram's photo links can expire after a while; download them soon if you need the images.

### Tips

- Turn off channel activity if you only need exists/type/subscribers: runs get about twice as fast.
- Use "Only output existing usernames" to get a clean list straight away.
- Schedule daily runs and compare `subscribers` across runs to measure growth.

### Integrations

Run it from the Apify API, schedules, Make, Zapier, n8n or Clay, and export as JSON, CSV or Excel. Pair it with our Telegram Channel Scraper to read the posts of the channels you find.

### Changelog

- 0.1 (Oct 2026): first release — exists/type detection, subscribers, members and online, verified and scam/fake flags, channel activity (last post, average views, media counters), invite links.

# Actor input Schema

## `usernames` (type: `array`):

Telegram usernames in any form: durov, @durov, t.me/durov, https://t.me/s/durov, tg://resolve?domain=durov, or invite links (t.me/+...). Duplicates are removed.

## `includeChannelActivity` (type: `boolean`):

For channels, also read the public channel preview: last post date, days since last post, average views of the recent posts and photo/video/link counts. No extra charge.

## `onlyExisting` (type: `boolean`):

Leave not-found and invalid names out of the dataset (they are free either way).

## `onlyTypes` (type: `array`):

Keep only these types (others are not charged).

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

Skip channels and groups below this size (not charged).

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

Cap on how many usernames are checked in this run.

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

Kept low on purpose to be polite to Telegram's public pages.

## Actor input object example

```json
{
  "usernames": [
    "durov",
    "@telegram",
    "https://t.me/BotFather",
    "t.me/python",
    "thisnamedoesnotexist_123"
  ],
  "includeChannelActivity": true,
  "onlyExisting": false,
  "minSubscribers": 0,
  "maxResults": 1000,
  "maxConcurrency": 4
}
```

# Actor output Schema

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

All results as JSON items in the run's default dataset (also downloadable as CSV/Excel from the dataset).

# 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 = {
    "usernames": [
        "durov",
        "@telegram",
        "https://t.me/BotFather",
        "t.me/python",
        "thisnamedoesnotexist_123"
    ]
};

// Run the Actor and wait for it to finish
const run = await client.actor("larkmoor/telegram-username-checker").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 = { "usernames": [
        "durov",
        "@telegram",
        "https://t.me/BotFather",
        "t.me/python",
        "thisnamedoesnotexist_123",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("larkmoor/telegram-username-checker").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 '{
  "usernames": [
    "durov",
    "@telegram",
    "https://t.me/BotFather",
    "t.me/python",
    "thisnamedoesnotexist_123"
  ]
}' |
apify call larkmoor/telegram-username-checker --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "type": "http",
            "url": "https://mcp.apify.com/?tools=fetch-actor-details,larkmoor/telegram-username-checker"
        }
    }
}
```

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/kM0eCbvdVFCzTOoFp/builds/01hyBA2axaxaAWYov/openapi.json