Skip to main content
Glama

Telegram MCP Server — Model Context Protocol (MCP) gateway for Telegram. 8 context-efficient tools, multi-tenant, MTProto bridge.

Try the Demo

  1. Open https://tg-mcp.l1979.ru/setup

  2. Scan the QR code from Telegram mobile (Settings → Devices → Scan QR) — no phone typing, no OTP, no 2FA. Or enter your phone number as fallback.

  3. Copy your Bearer token from the success page

Then choose your path:

MCP Client (AI assistants)

  • From the setup page, download the mcp.json file

  • Add the server to your AI client and ask: "send hello to my saved messages in telegram"

Direct API (curl)

  • Run the command below (replace TOKEN with yours):

curl -X POST "https://tg-mcp.l1979.ru/mtproto-api/messages.SendMessage" \
  -H "Authorization: Bearer TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"params": {"peer": "me", "message": "Hello!"}}'

Python Version License: MIT Docker Ready Health Status Glama Score MCP Queen operational grade

Related MCP server: mcp-telegram

How It Works

This server sits between your AI agent and Telegram's API:

Your agent → MCP/HTTP → this server → MTProto → Telegram

What it does: Authenticates you with Telegram (QR or phone/bot token), exposes 8 AI-friendly tools instead of 80+ micro-APIs, and bridges raw MTProto for power users. Multi-tenant — one server, many users, isolated sessions.

Features

Feature

Description

:building_construction: Dual Transport

Stdio for local MCP clients, HTTP for remote deploys (http-auth production, optional http-no-auth for dev)

:closed_lock_with_key: Multi-User Authentication

Shared http-auth server: one Bearer token per user, one Telegram account per MCP connection. QR login for instant auth — no phone/OTP/2FA.

:dart: AI-Optimized

8 consolidated tools vs 80+ micro-tools — context-efficient design, LLM-friendly API, MCP ToolAnnotations

:globe_with_meridians: HTTP-MTProto Bridge

Direct curl access to any Telegram API method with entity resolution and safety guardrails

:shield: Session ACL

Opt-in per-principal limits on http-auth (ACL_ENABLED) — chat lanes, read_only, blocked_peers, allow_mtproto, ACL_DENY_UNLISTED_PRINCIPALS; see SECURITY.md

:tv: QR & Web Setup

Scan QR from Telegram mobile for instant auth (no phone/OTP/2FA) or use phone/code/2FA fallback — live at /setup

:label: One Agent, Multiple Accounts

Optional PREFIX_MCP_TOOLS_WITH_ACCOUNT — when one agent uses several MCP connections (same server, different tokens), prefixes tool names so they do not collide; not needed for standard multi-user hosting

:rocket: MTProto Proxy Support

Connect via MTProto proxy with automatic Fake TLS (EE prefix) and standard proxy detection

:card_file_box: Unified Session Management

Single configuration system for setup and server; per-token session files on shared multi-user hosts

:cloud: S3 Session Storage

Store sessions in S3-compatible object storage for ephemeral hosted deployments (Smithery, Fly.io, Railway)

:mag_right: Intelligent Search

Global & per-chat message search with multi-query support and intelligent deduplication

:mag: Unified Message API

Single get_messages tool for search, browse, read by IDs, and replies - 5 modes in one

:speech_balloon: Universal Replies

Get replies from channel posts, forum topics, or any message with one parameter

:busts_in_silhouette: Smart Contact Discovery

Search users, groups, channels with uniform entity schemas, forum detection, profile enrichment

:file_folder: Folder Filtering

Filter chats by dialog folder (archived, custom folders) with integer ID or name matching

:envelope: Advanced Messaging

Send, edit, reply, post to forum topics, formatting, file attachments, and phone number messaging

:paperclip: Secure File Handling

Rich media sharing with SSRF protection, size limits, album support, optional HTTP attachment streaming

:outbox_tray: Inline File Uploads

Data: URI (base64) file uploads in files param — work in all transport modes, filenames preserved, images sent as photos

:microphone: Voice Transcription

Automatic speech-to-text for Premium accounts with parallel processing and polling

:zap: High Performance

Async operations, parallel queries, and memory-conscious batching

:shield: Production Reliability

Auto-reconnect, configurable logging, comprehensive error handling

Quick Start

1. Install and authenticate

Quickest path (remote server): Open /setup → scan QR → copy token (see Try the Demo).

CLI path (local stdio): Run fast-mcp-telegram-setup once to create a Telegram session — then fast-mcp-telegram serves it:

uvx --from fast-mcp-telegram fast-mcp-telegram-setup \
  --api-id="your_api_id" \
  --api-hash="your_api_hash" \
  --phone-number="+123456789"

Bot token alternative (no phone, no OTP): Set BOT_API_TOKEN instead of --phone-number. See Installation Guide.

2. Configure MCP Client

stdio mode (local): Add to your MCP client config (e.g. claude_desktop_config.json) — stdio (standard input/output) is the default transport for local MCP clients:

{
  "mcpServers": {
    "telegram": {
      "command": "uvx",
      "args": ["fast-mcp-telegram"],
      "env": {
        "API_ID": "your_api_id",
        "API_HASH": "your_api_hash"
      }
    }
  }
}

http-auth mode (remote): Add to your MCP client config (e.g. claude_desktop_config.json):

{
  "mcpServers": {
    "telegram": {
      "url": "https://tg-mcp.l1979.ru/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_TOKEN"
      }
    }
  }
}

Get your token by scanning the QR code on the setup page or see Installation Guide for deploying your own server.

3. Start Using

{"tool": "search_messages_globally", "params": {"query": "hello", "limit": 5}}
{"tool": "get_messages", "params": {"chat_id": "me", "limit": 10}}
{"tool": "send_message", "params": {"chat_id": "me", "message": "Hello!"}}

Deploy to Remote Server

Deploy your own MCP server on a VDS — see Installation Guide for step-by-step instructions.

Available Tools

Tool

Purpose

Key Features

search_messages_globally

Search across all chats

Multi-term queries, date filtering, chat type filtering

get_messages

Unified message retrieval

Search/browse, read by IDs, get replies (posts/topics/messages), date filtering in all modes

send_message

Send new message

File attachments (URLs/local/data URIs), classic formatting (markdown/html), parse_mode=rich Rich Messages, reply to forum topics

edit_message

Edit existing message

Classic or parse_mode=rich formatting

find_chats

Find users/groups/channels

Multi-term search, contact discovery, folder filtering, username/phone lookup

get_chat_info

Get detailed profile info

Member counts, bio/about, online status, forum topics, common groups, enriched data

send_message_to_phone

Message phone numbers

Auto-contact management, optional cleanup, file support (URLs/data URIs), parse_mode=rich

invoke_mtproto

Direct Telegram API (power user)

Raw MTProto methods, entity resolution, PII/credential fields dropped by default (include_sensitive=true for raw) — see MTProto Bridge

See Tools Reference for detailed documentation with examples.

Documentation

Telemetry

Anonymous tool telemetry since v0.30.1 — heartbeat every 6h, no credentials or message content collected. Opt out with DO_NOT_TRACK=1. See ADR 0005.

Auth flow telemetry since v0.38.0 — atomic events during setup (phone, QR, bot token, reauthorize). Buffered flush on flow completion. See ADR 0008.

License

MIT License - see LICENSE

mcp-name: io.github.leshchenko1979/fast-mcp-telegram

Available Tools

8 tools
edit_messageEdit messageA
DestructiveIdempotent
Inspect

Replace the text of an existing message in a Telegram chat. Only works on messages sent by the authenticated account. Cannot edit media or other message attributes — text only. parse_mode: classic markdown/html/auto or rich (Rich Message; dialect auto-detected). schedule_date (ISO 8601) reschedules an already-queued message; it does not turn a delivered message into a scheduled one, and the result then carries status='scheduled'. Success: dict with message_id, date, chat, text, status='edited', and edit_date (rich messages also set rich=true and rich_format). Error: dict with ok=false and error string (e.g. message not found or not editable). Use edit_message to update a previously sent message; use send_message to create new ones. Full documentation: https://github.com/leshchenko1979/fast-mcp-telegram/blob/main/docs/Tools-Reference.md

Inputs: chat_id (required), message (required), message_id (required), parse_mode, +1 more. Returns: Return type for ``send_message`` and ``edit_message``.

find_chatsFind chatsA
Read-onlyIdempotent
Inspect

Find users/groups/channels by name, username, or phone. Comma-separated usernames are searched in parallel and results are merged round-robin. Global search (query required) searches all Telegram; with min_date, max_date, or filter, search uses dialog list or a named filter; include_peers filters use last-activity from GetPeerDialogs; flag-based filters use dialog list dates. Success: dict with key chats (list of chat objects). Full documentation: https://github.com/leshchenko1979/fast-mcp-telegram/blob/main/docs/Tools-Reference.md

Inputs: limit, query, folder, public, +3 more. Returns: Return type for ``find_chats``.

get_chat_infoGet chat infoA
Read-onlyIdempotent
Inspect

Load profile and metadata for one user, bot, group, or channel. Success: info dict; forum chats may include topics up to topics_limit; user targets may include common_chats up to common_chats_limit. Full documentation: https://github.com/leshchenko1979/fast-mcp-telegram/blob/main/docs/Tools-Reference.md

Inputs: chat_id (required), topics_limit, common_chats_limit. Returns: Return type for ``get_chat_info``.

get_messagesGet messages in chatA
Read-onlyIdempotent
Inspect

Read or search messages in one chat: browse latest, search text, fetch by ids, or load replies to a message (comments, forum topics, threads). Use from_user to filter by sender (server-side, per-chat only). Use context to include neighboring messages and reply chains around each result. Use include_replies to fetch up to 5 direct replies per result. Do not combine message_ids with query or reply_to_id. Results are ordered by ascending date-time (oldest first) in every mode, including message_ids and nested context lists; limit selects the newest N. Success: messages, has_more, optional total_count and discussion fields. Full documentation: https://github.com/leshchenko1979/fast-mcp-telegram/blob/main/docs/Tools-Reference.md

Inputs: chat_id (required), limit, query, context, +9 more. Returns: Return type for ``search_messages_globally`` and ``get_messages``.

invoke_mtprotoInvoke MTProtoA
Destructive
Inspect

Low-level Telegram API (MTProto) invoke for methods not wrapped by other tools. Dangerous methods require allow_dangerous=true. Success: API result dict or normalized error. PII and credential-shaped fields (phone, access_hash) are dropped from a successful result by default; pass include_sensitive=true for the raw payload. A bare message id needs a chat binding: requests with no peer field (messages.GetMessages, messages.DeleteMessages) are refused, because a bare id resolves against an arbitrary dialog. Use channels.GetMessages or messages.GetHistory, which carry the binding. messages.GetHistory cannot address a forum topic (no thread_id/top_msg_id in the schema, and channels.GetHistory does not exist) -- use messages.Search with top_msg_id, or the high-level get_messages with reply_to_id. Full documentation: https://github.com/leshchenko1979/fast-mcp-telegram/blob/main/docs/Tools-Reference.md

Inputs: params_json (required), method_full_name (required), resolve, allow_dangerous, +1 more. Returns: Return type for ``invoke_mtproto``. The success payload is a JSON-safe dict who…

search_messages_globallySearch messages globallyA
Read-onlyIdempotent
Inspect

Search all Telegram chats at once (not scoped to one chat). Comma-separated query terms; optional filters by date, chat kind, and public username. Results are ordered by ascending date-time (oldest first); limit selects the newest N. Success: message list and metadata dict. Global search ignores include_total_count. Full documentation: https://github.com/leshchenko1979/fast-mcp-telegram/blob/main/docs/Tools-Reference.md

Inputs: query (required), limit, public, max_date, +4 more. Returns: Return type for ``search_messages_globally`` and ``get_messages``.

send_messageSend messageA
Destructive
Inspect

Send text and optional file attachments to a Telegram chat. Supports reply-to (including forum topics and channel discussion groups), parse_mode: classic markdown/html/auto (entities) or rich (Rich Message document; dialect auto-detected). parse_mode=rich cannot be combined with files. File attachments as http(s) URLs, local paths, or data: URIs. When files are provided, the message text becomes a caption. For channel posts with reply_to_id, automatically posts in the linked discussion group. schedule_date (ISO 8601, must be in the future) queues the message instead of delivering it now, so the result carries status='scheduled' plus scheduled and schedule_date. save_as_draft=true saves the text as the chat's draft instead of sending it (empty message clears the draft; user sessions only, bots cannot; text-only, so no files, no parse_mode='rich', no schedule_date). Success: dict with message_id, date, chat, text, status='sent', and sender info (rich messages also set rich=true and rich_format). Error: dict with ok=false and error string. Use send_message to create new messages; use edit_message to modify existing ones. Use send_message_to_phone when targeting a phone number instead of a chat_id. Full documentation: https://github.com/leshchenko1979/fast-mcp-telegram/blob/main/docs/Tools-Reference.md

Inputs: chat_id (required), message (required), files, parse_mode, +3 more. Returns: Return type for ``send_message`` and ``edit_message``.

send_message_to_phoneSend message to phoneA
Destructive
Inspect

Send to a phone number: may create a temporary contact, then send text or files. Supports parse_mode: classic markdown/html/auto or rich (Rich Message; dialect auto-detected). parse_mode=rich cannot be combined with files. schedule_date (ISO 8601, future) queues the message instead of delivering now; save_as_draft=true saves the text as the draft in that chat instead of sending. Success: send result plus contact_was_new / contact_removed when applicable. Full documentation: https://github.com/leshchenko1979/fast-mcp-telegram/blob/main/docs/Tools-Reference.md

Inputs: message (required), phone_number (required), files, last_name, +6 more. Returns: Return type for ``send_message_to_phone``.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.1/5.0

    Scored across 8 tools

    Disambiguation4/5

    Each tool has a fairly distinct role: reading (get_messages, get_chat_info), searching (search_messages_globally, find_chats), writing (send_message, edit_message), plus a phone-targeted send and an MTProto escape hatch. The only mild overlaps are find_chats vs get_chat_info (locate vs profile) and the two send_message variants, but names and descriptions make the intended split clear.

    Naming Consistency4/5

    All snake_case with a leading verb (get_, search_, send_, edit_, find_, invoke_), which is predictable. Minor deviations: qualifier suffixes on search_messages_globally and send_message_to_phone, and invoke_mtproto uses a protocol name rather than a resource noun.

    Tool Count5/5

    Eight tools is well within the 3-15 sweet spot for a Telegram client surface, and each tool covers a substantive capability rather than a thin variant. Nothing appears redundant or padded.

    Completeness4/5

    Read, search, send, edit, chat discovery and profile lookup are covered, and invoke_mtproto provides an escape hatch for the rest. However, common lifecycle operations like deleting messages, forwarding, or joining/leaving chats have no first-class tool, leaving agents to fall back on raw MTProto calls.

    Maintenance

    ActivityActive
    ResponsivenessLimited data

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      A
      maintenance
      Production-grade MCP server for Telegram with dual-mode Bot API and MTProto. 6 composite tools covering messages, chats, media, contacts management with 3-tier token optimization.
      11
      Apache 2.0
    • A
      license
      Not graded
      quality
      D
      maintenance
      MCP server that connects AI assistants to your real Telegram account via User API (MTProto). Features default-deny ACL with per-chat permissions, message search, file sending, forwarding, media downloads, and rate limiting.
      3
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Privacy-first Telegram MCP server enabling maintainers to triage chats, inspect context, search messages, draft replies, and send authorized messages locally without a cloud relay.
      57 npm
      1
      MIT