# Telegram Dev (pypi · telegram-dev)

Current official Telegram and TON docs: Bot API, Mini Apps, MTProto, TDLib, TON Connect, Tolk

- Trust score: 79/100 (medium)
- Change this week: +15
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-21

## Components

- pypi · `telegram-dev`: 79/100 (this document), [markdown](https://verifymcp.io/servers/kay0k1-telegram-dev/telegram-dev.md), [page](https://verifymcp.io/servers/kay0k1-telegram-dev/telegram-dev)

## Channel facts

- Registry: `pypi`
- Package: `telegram-dev`
- Version: `0.9.0`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-21.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - Runs setuptools.build_meta at install time, a recognised build step with no custom scripting around it.
  - 0 of 33 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 97/100
  - Source repository is publicly reachable at the declared URL.
  - Cryptographically verified build provenance (signed, bound to Kay0k1/telegram-dev).
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 10 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 66/100
  - AI-judged instruction clarity (excellent).
  - Context-footprint check failed: tool/resource definitions use about 2376 tokens (~237/item across 10 items; 10 tools + 0 resources), over budget; trim descriptions and params.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 0/100
  - Stability not yet verified: not enough scan history yet (needs a 30-day window).
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 10 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 11 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

**Unverified: 1 category.** A category scored 0 because we could not verify it: a data source with nothing on this package, evidence we could not reach, or a check we could not run. We only credit what we can confirm.

## Install

### How do I install the Telegram Dev MCP server?

Telegram Dev runs locally as a PyPI package, launched with uvx telegram-dev serve. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add kay0k1-telegram-dev -- uvx telegram-dev serve
```

### Cursor

```json
{
  "mcpServers": {
    "kay0k1-telegram-dev": {
      "command": "uvx",
      "args": [
        "telegram-dev",
        "serve"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "kay0k1-telegram-dev": {
      "command": "uvx",
      "args": [
        "telegram-dev",
        "serve"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add kay0k1-telegram-dev -- uvx telegram-dev serve
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "kay0k1-telegram-dev": {
      "type": "local",
      "command": [
        "uvx",
        "telegram-dev",
        "serve"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add kay0k1-telegram-dev --command uvx --arg telegram-dev --arg serve
```

### Hermes

```yaml
mcp_servers:
  kay0k1-telegram-dev:
    command: "uvx"
    args: ["telegram-dev", "serve"]
```

### Netclaw

```json
{
  "McpServers": {
    "kay0k1-telegram-dev": {
      "Transport": "stdio",
      "Command": "uvx",
      "Arguments": [
        "telegram-dev",
        "serve"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add kay0k1-telegram-dev -t stdio -c uvx -a telegram-dev serve
```

### Other

```json
{
  "mcpServers": {
    "kay0k1-telegram-dev": {
      "command": "uvx",
      "args": [
        "telegram-dev",
        "serve"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-19 (score 79, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-18 (score 64, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-17 (score 79, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-13 (score 64, −15)

- [security regression] Malware scan: pass → unverified

### 2026-11-12 (score 79, +15)

- [security improvement] Malware scan: unverified → pass

### 2026-11-10 (score 64)

First indexed and scored.

## MCP tools (10)

### `search_telegram_docs` (~266 tokens)

Search Telegram and TON docs

Find the official documentation sections that answer a Telegram or TON development question.

Use it before writing or reviewing code that calls the Bot API, Mini Apps JS, Telegram API/MTProto, TDLib, TON Connect, Tolk contracts or the aiogram, python-telegram-bot and grammY libraries. Returns up to `limit` sections with page URL, heading, excerpt, `document_offset` and freshness. Excerpts are partial: open the page with `get_telegram_document` at `document_offset` before relying on details. Stale matching pages are re-fetched first. An empty result is not proof that a feature does not exist; if the cache is empty, the response suggests pages to fetch.

Input parameters:

- `area` (string): Limit results to one documentation area; empty searches all areas. Core Telegram docs rank above library docs unless the query names a library.
- `limit` (integer): Maximum number of matching sections to return.
- `query` (string, required): Exact API names or short English keywords work best, e.g. 'InlineKeyboardButton style', 'sendVideoNote', 'ton_proof', 'jetton transfer', 'aiogram Router callback_query'. Common Russian feature words…

### `get_telegram_document` (~293 tokens)

Read an official documentation page

Read the text of an official Telegram, TON or bot-library documentation page, one window at a time.

Use it to read requirements, parameters and limits in full after `search_telegram_docs` found the page, or to load an entry page from `list_telegram_sources` into an empty cache. Do not use it to find which page answers a question: search first. Pages missing from the cache or older than the freshness limit (6 hours by default) are fetched first. Returns title, URL, Markdown `body` for the requested window, `next_offset` (null at the end), `total_characters`, content hash and freshness. If the live source fails, the cached text is returned with `freshness.stale` and `refresh_error` set. The observation date is when this installation read the page, not when Telegram changed it.

Input parameters:

- `length` (integer): Number of characters to return.
- `offset` (integer): Character offset to start from; use a search result's document_offset or the previous next_offset.
- `refresh` (boolean): Force a live check of the source even if the cached copy is fresh.
- `url` (string, required): Official page URL from search results or list_telegram_sources, e.g. https://core.telegram.org/bots/api or https://docs.ton.org/applications/ton-connect/overview. Pages outside the official sources a…

### `get_telegram_corpus_status` (~198 tokens)

Cache coverage and freshness

Report how complete and how current the local documentation cache is, as totals.

Use it at the start of a task or when search results look incomplete. Returns `pages`, per-area counts (`families`), crawl queue state (`frontier`), `stale_pages`, last and oldest successful checks, `refresh_policy` and up to 15 recent source `errors`. For the configured entry points use `list_telegram_sources`; for the individual cached pages use `list_telegram_cached_pages`; to answer a question use `search_telegram_docs`. Refreshing is automatic (on read, on search and in a background cycle), so there is no refresh command. Returns page counts per area, crawl queue state, stale page count, last and oldest successful checks, refresh policy and the latest source errors. Indexed pages are not all of Telegram's knowledge: absence from the cache is not evidence that a feature does not exist.

### `list_telegram_document_revisions` (~159 tokens)

Observed revisions of a page

List the revisions of one documentation page that this installation has observed, newest first.

Use it to see whether a page changed since an earlier read. To read the current text use `get_telegram_document`. Returns `revisions`: a list of {sha, captured_at, characters}, newest first. A page that this installation has never fetched returns an empty list; a URL outside the official sources is rejected with an error. It does not reconstruct history before the page was first fetched here; for Telegram release history use `list_bot_api_changes` or the changelogs (area `releases` or `ton-releases`).

Input parameters:

- `url` (string, required): Official page URL, the same form accepted by get_telegram_document.

### `list_telegram_sources` (~149 tokens)

Official documentation entry points

List the official entry points this server crawls, each with its documentation area.

Use it to find where to start reading for an unfamiliar area (for example the Bot API index, docs.ton.org/llms.txt or a library's docs) and pass the URL to `get_telegram_document`. If you already know the feature or API name, use `search_telegram_docs` instead. Returns `sources`: a list of {url, area} in the configured order (Telegram core docs, then TON, then bot libraries), and a short `scope` note. This is the source configuration, not the cache: `list_telegram_cached_pages` shows what is already stored.

### `list_telegram_cached_pages` (~194 tokens)

List cached documentation pages

List the documentation pages already stored in the local cache, sorted by URL.

Use it to see which pages of an area are available offline or to pick a page to open with `get_telegram_document`. Filter with `area`, page through results with `offset` and `limit`. Returns `pages` (url, title, area, checked_at, freshness), `total` matching pages and `next_offset` to pass back for the next page (null at the end). It lists stored pages only; to find content by topic use `search_telegram_docs`, and for totals and errors use `get_telegram_corpus_status`.

Input parameters:

- `area` (string): Only pages from this documentation area; empty lists all areas.
- `limit` (integer): Maximum number of pages to return.
- `offset` (integer): Number of pages to skip, for paging through long lists; use the previous next_offset.

### `get_bot_api_definition` (~242 tokens)

Bot API method or type definition

Return the current definition of one Bot API method or type as structured data.

Use it instead of reading the whole Bot API page when you need a method's parameters or a type's fields: each entry has its type, whether it is required, the description and any allowed values or length limits stated by Telegram, plus the changelog entries that mention it. For behaviour explained in prose elsewhere (formatting, payments, limits pages) use `search_telegram_docs` and `get_telegram_document`. Returns `kind` (method or type), `name`, `url`, `description`, then `params` (methods; with `returns`) or `fields` (types; or `one_of` for union types), plus `changes`, `bot_api_version`, `source`, `checked_at` and `freshness`. An unknown name returns `kind: null` with close-match `suggestions`. Built from the cached official page, refreshed when stale.

Input parameters:

- `name` (string, required): Exact Bot API method or type name, e.g. 'sendMessage', 'InlineKeyboardButton', 'ReplyParameters'. Case-insensitive; close matches are suggested.

### `check_bot_api_call` (~252 tokens)

Check a Bot API call

Check a Bot API request against the current official schema before running or shipping code.

Reports errors (unknown method or parameter with suggestions, missing required parameters, wrong types, values outside the documented list, a wrong `type` in union objects such as InputMedia) and warnings (lengths outside documented limits, parameters retired in an older Bot API version with the changelog entry that replaced them, numbers or booleans sent as strings). It does not call Telegram and cannot check permissions, chat state or file contents. Returns `valid` (true when there are no errors), `errors` and `warnings` as lists of {path, message} where path points into params (for example `reply_markup.inline_keyboard[0][0].style`), plus `url`, `bot_api_version` and freshness. An unknown method returns `valid: false` with suggestions. Use `get_bot_api_definition` to read the definitions it checks against.

Input parameters:

- `method` (string, required): Bot API method name, e.g. 'sendMessage'.
- `params` (object, required): The request parameters exactly as your code sends them, as a JSON object. Nested objects such as reply_markup may be objects or JSON strings.

### `list_bot_api_changes` (~247 tokens)

Bot API changes by version

List official Bot API changelog entries as structured releases: version, date, link and the individual changes.

Use it when upgrading a bot or a library ("what changed since 9.0?"), when a field seems new or missing, or to find when a method or field was added, replaced or removed. Returns `current_version` and `releases`, newest first: each has `version`, `date`, `url` and `changes` ({text, topic, refs: linked methods and types, terms: field and parameter names}). A name that no change mentions returns an empty list. For the full current definition use `get_bot_api_definition`; for TON or library changelogs use `search_telegram_docs` with area `ton-releases` or the library area.

Input parameters:

- `limit` (integer): Maximum number of releases when since_version is empty.
- `name` (string): Only changes that mention this method, type, field or parameter, e.g. 'InlineKeyboardButton' or 'reply_parameters'.
- `since_version` (string): Only releases newer than this Bot API version, e.g. '9.0'. Empty returns the latest releases.

### `check_telegram_project` (~305 tokens)

Check a bot project

Check every Bot API call in a Python bot project (aiogram, python-telegram-bot, pyTelegramBotAPI, raw HTTP requests) against the current official schema in one run.

Use it after changing an existing bot, before an upgrade, or when asked to review a bot: it reads the whole project locally and returns only findings, so the documentation does not have to enter the context. Errors: values outside the documented list (for example `style="red"`), unknown methods or parameters in raw API requests. Warnings: parameters Telegram retired, with the Bot API version and changelog entry that replaced them; keyword arguments that are neither Bot API parameters nor known library options; bot methods with no Bot API counterpart. It does not run code, follow variables or check required parameters. Returns `findings` ({file, line, severity, call, message}), `errors`, `warnings`, `files_scanned`, declared `libraries` with versions and `bot_api_version`. To check one request instead use `check_bot_api_call`. The same check runs in a shell or CI as `telegram-dev check PATH`.

Input parameters:

- `exclude` (array): Glob patterns relative to path to skip, e.g. ['tests/*', 'migrations/*'].
- `max_findings` (integer): Maximum number of findings to return; totals always count everything.
- `path` (string, required): Absolute path to the bot project directory or a single Python file on this machine.

## Diagnostics

Captured diagnostic sections: Provenance, Install scripts, Dependencies. The full working is on the page: https://verifymcp.io/servers/kay0k1-telegram-dev/telegram-dev#diagnostics

## Score history

- 2026-11-21: 79
- 2026-11-20: 79
- 2026-11-19: 79
- 2026-11-18: 64
- 2026-11-17: 79
- 2026-11-16: 64
- 2026-11-15: 64
- 2026-11-14: 64
- 2026-11-13: 64
- 2026-11-12: 79
- 2026-11-11: 64
- 2026-11-10: 64

## Common questions

### What is the Telegram Dev MCP server?

Telegram Dev is an MCP server listed in the public MCP registry as io.github.Kay0k1/telegram-dev. Current official Telegram and TON docs: Bot API, Mini Apps, MTProto, TDLib, TON Connect, Tolk. This page covers its PyPI package (telegram-dev).

### Is the Telegram Dev MCP server safe to use?

Telegram Dev scores 79 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 21 November 2026. Its build provenance is signed and verified. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Telegram Dev MCP server expose?

Telegram Dev exposes 10 tools: search_telegram_docs, get_telegram_document, get_telegram_corpus_status, list_telegram_document_revisions, list_telegram_sources, and 5 more. Their descriptions and schemas cost roughly 2,305 tokens of context every time the server is loaded.

### Is the Telegram Dev MCP server still maintained?

Telegram Dev is still listed as active in the MCP registry. We last reached this channel on 21 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Telegram Dev MCP server under?

Telegram Dev declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the Telegram Dev MCP server?

VerifyMCP ran 15 checks on Telegram Dev, covering Malware scan, Known CVEs, Install scripts, Dependency health and 11 more. One item could not be completed, a gap on our side rather than a finding about Telegram Dev: Stability. One category scores 0 for that reason, because we only credit what we can confirm. Endpoint Security and Transport & Reachability do not apply to a PyPI package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- PyPI project: https://pypi.org/project/telegram-dev/
- Socket report: https://socket.dev/pypi/package/telegram-dev
- Repository: https://github.com/Kay0k1/telegram-dev
- Changelog RSS feed: https://verifymcp.io/servers/kay0k1-telegram-dev/telegram-dev.xml
- Changelog JSON feed: https://verifymcp.io/servers/kay0k1-telegram-dev/telegram-dev/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/kay0k1-telegram-dev/telegram-dev.json
- HTML version of this page: https://verifymcp.io/servers/kay0k1-telegram-dev/telegram-dev
