# Telegram Info Scraper (`maximedupre/telegram-info-scraper`) Actor

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.

- **URL**: https://apify.com/maximedupre/telegram-info-scraper.md
- **Developed by:** [Maxime Dupré](https://apify.com/maximedupre) (community)
- **Categories:** Social media, Lead generation, Automation
- **Stats:** 6 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

from $4.10 / 1,000 telegram entity rows

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

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

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

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

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

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

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

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

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

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

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

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

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


# README

### Telegram Info Scraper

Telegram Info Scraper gets public profile data from [Telegram](https://telegram.org/) usernames and `t.me` links. Paste handles, channel URLs, group URLs, bot usernames, or public profile links and get a clean dataset with the title, bio, member count, verification status, profile photo, source URL, and target status.

Use it when you need to check a list of Telegram entities before outreach, research, monitoring, moderation, brand protection, or data enrichment. You do not need Telegram login, cookies, a phone number, or an API key.

### What It Does

This Actor looks up public Telegram profile preview pages and saves one row per target. It works with common public target formats:

- `@telegram`
- `telegram`
- `https://t.me/telegram`
- `https://telegram.me/telegram`

It can process users, bots, channels, groups, and supergroups when Telegram shows a public preview page for the target. Missing, private, invalid, or unavailable targets can also be saved as status rows, so your export can stay aligned with the list you uploaded.

### What Data You Get

Each Telegram entity row is built for quick filtering and export. The dataset includes:

- Original input and input row number
- Normalized Telegram handle
- Username and canonical `t.me` URL
- Lookup status and error reason when a target is not available
- Public title or display name
- Public description, bio, or about text
- Entity kind, such as channel, group, bot, user, or unknown
- Member or subscriber count when Telegram shows it
- Verification, scam, fake, restricted, and bot flags
- Profile photo URL
- Confidence and field-completeness scores
- Scrape timestamp

Fields can be `null` when Telegram does not show that value on the public preview page.

### Common Use Cases

- Check whether Telegram usernames, channels, groups, or bots exist.
- Build a clean list of Telegram channel metadata for research.
- Compare public subscriber or member counts across communities.
- Flag verified, scam, fake, or restricted Telegram entities when those labels are visible.
- Enrich a CRM, lead list, influencer list, community list, or monitoring sheet with public Telegram profile data.
- Export public Telegram entity data to JSON, CSV, Excel, an API workflow, or an Apify integration.

### How To Run It

1. Add Telegram usernames or URLs in **Telegram targets**.
2. Set **Target limit** if you only want to process part of a long list.
3. Keep **Include unavailable targets** turned on if you want one row for every input target.
4. Start the Actor and open the dataset when the run finishes.

For a small first run, try:

```json
{
	"targets": ["@telegram", "https://t.me/durov", "telegram"],
	"maxTargets": 3,
	"includeUnavailableRows": true
}
````

### Input

#### Telegram Targets

Add one Telegram username, handle, or URL per row. The Actor accepts bare usernames, `@handles`, `t.me` URLs, and `telegram.me` URLs.

Private `/c/` links and invite-only chats are not supported because they do not have a public preview page.

#### Target Limit

Use this to cap how many targets are processed from the input list. It helps keep test runs small and spend predictable.

#### Include Unavailable Targets

When this is on, the Actor saves status rows for missing, private, invalid, or unavailable targets. This is useful for bulk lookup because row numbers stay tied to your source list.

When this is off, the dataset contains found public Telegram entities only.

### Output Example

```json
{
	"inputIndex": 0,
	"originalInput": "@telegram",
	"normalizedTarget": "@telegram",
	"username": "telegram",
	"canonicalUrl": "https://t.me/telegram",
	"sourceUrl": "https://t.me/telegram",
	"status": "found",
	"errorReason": null,
	"title": "Telegram News",
	"description": "The official Telegram on Telegram. Much recursion. Very Telegram. Wow.",
	"entityKind": "channel",
	"memberCount": 10618211,
	"memberCountText": "10 618 211 subscribers",
	"isVerified": true,
	"isScam": false,
	"isFake": false,
	"isRestricted": false,
	"isBot": false,
	"profilePhotoUrl": "https://cdn.example/profile.jpg",
	"confidence": 1,
	"fieldCompleteness": 1,
	"scrapedAt": "2026-05-20T22:45:46.093Z"
}
```

### Pricing

This Actor uses pay-per-event pricing. You pay for each Telegram entity row saved to the dataset, plus the standard Actor start event shown on the run page before you start.

Unavailable target rows are useful for audits and list cleanup, but they are still dataset rows when you choose to include them.

### Limits And Caveats

- The Actor extracts public data shown by Telegram preview pages.
- It does not log in to Telegram or scrape private chats.
- It does not join groups, send messages, or collect private member lists.
- It does not find phone numbers, emails, or contacts from other websites.
- Some public profiles do not show member counts, bios, or photos. Those fields are returned as `null`.
- Telegram may show different labels over time, so use `status`, `errorReason`, and `scrapedAt` when auditing older exports.

### FAQ

#### Does Telegram Info Scraper need a Telegram account?

No. The Actor uses public Telegram preview pages. You do not need to provide a Telegram login, cookies, a phone number, or an API key.

#### Can it scrape Telegram channel members?

No. This Actor gets public entity profile data, not private member lists. It can show a public member or subscriber count when Telegram displays one.

#### What happens when a username does not exist?

If **Include unavailable targets** is on, the Actor saves a row with a status such as `not_found`, `invalid_input`, or `private_or_unavailable`. If it is off, unavailable targets are skipped.

#### Can I use this as a Telegram username scraper?

Yes, for public profile lookup. Add Telegram usernames or links and the Actor returns normalized handles, titles, bios, counts, flags, photos, and source URLs.

#### Can I schedule this Actor?

Yes. You can schedule runs on Apify and compare datasets over time. The Actor itself does not maintain a historical database.

# Actor input Schema

## `targets` (type: `array`):

Paste one public Telegram username, @handle, t.me URL, or telegram.me URL per row. Private /c/ links and invite-only chats are not supported.

## `maxTargets` (type: `integer`):

Maximum number of rows to process from your target list. Lower this for a small test run.

## `includeUnavailableRows` (type: `boolean`):

Save a status row for invalid, missing, private, or unavailable targets. Keep this on when you want the export to match your input list row by row.

## Actor input object example

```json
{
  "targets": [
    "@telegram",
    "https://t.me/durov",
    "telegram"
  ],
  "maxTargets": 100,
  "includeUnavailableRows": true
}
```

# Actor output Schema

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

Open the dataset with public Telegram profile rows and any requested unavailable target rows.

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

// Run the Actor and wait for it to finish
const run = await client.actor("maximedupre/telegram-info-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 = { "targets": [
        "@telegram",
        "https://t.me/durov",
        "telegram",
    ] }

# Run the Actor and wait for it to finish
run = client.actor("maximedupre/telegram-info-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 '{
  "targets": [
    "@telegram",
    "https://t.me/durov",
    "telegram"
  ]
}' |
apify call maximedupre/telegram-info-scraper --silent --output-dataset

```

## MCP server setup

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

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Telegram Info Scraper",
        "description": "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.",
        "version": "0.0",
        "x-build-id": "rXbEYi7lZBLKcWcZL"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/maximedupre~telegram-info-scraper/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-maximedupre-telegram-info-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/maximedupre~telegram-info-scraper/runs": {
            "post": {
                "operationId": "runs-sync-maximedupre-telegram-info-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/maximedupre~telegram-info-scraper/run-sync": {
            "post": {
                "operationId": "run-sync-maximedupre-telegram-info-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": [
                    "targets"
                ],
                "properties": {
                    "targets": {
                        "title": "Telegram targets",
                        "minItems": 1,
                        "maxItems": 1000,
                        "type": "array",
                        "description": "Paste one public Telegram username, @handle, t.me URL, or telegram.me URL per row. Private /c/ links and invite-only chats are not supported.",
                        "items": {
                            "type": "string",
                            "minLength": 1
                        }
                    },
                    "maxTargets": {
                        "title": "Target limit",
                        "minimum": 1,
                        "maximum": 1000,
                        "type": "integer",
                        "description": "Maximum number of rows to process from your target list. Lower this for a small test run.",
                        "default": 100
                    },
                    "includeUnavailableRows": {
                        "title": "Include unavailable targets",
                        "type": "boolean",
                        "description": "Save a status row for invalid, missing, private, or unavailable targets. Keep this on when you want the export to match your input list row by row.",
                        "default": true
                    }
                }
            },
            "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
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
