One protocol core. Three source languages.

miniproto turns Python intent into Telegram MTProto traffic through a deliberately small boundary: Python owns the public async API and policy, the pinned Telegram schema owns raw request and result shapes, and Rust accelerates measured hot paths without becoming a correctness requirement.

01Python intent

Lifecycle, authorization, peers, updates, messages, media, sessions, retries, and typed errors remain inspectable Python APIs.

02Layer 228 schema

Generated constructors expose Telegram's complete raw surface, with source metadata and cross-linked result and error relationships.

03Measured Rust paths

Transport framing, cryptography, and hot TL constructors select native paths when available and verified, then fall back explicitly.

Start from a secure default

import asyncio
import os

from miniproto import Client, ClientConfig, InMemorySessionStorage
from miniproto.raw import functions


async def main() -> None:
    config = ClientConfig(
        api_id=int(os.environ["MINIPROTO_API_ID"]),
        api_hash=os.environ["MINIPROTO_API_HASH"],
        session_storage=InMemorySessionStorage(),
    )
    async with Client(config) as client:
        await client.sign_in_bot(os.environ["MINIPROTO_BOT_TOKEN"])
        me = await client.get_me()
        telegram_config = await client.invoke(functions.HelpGetConfig())
        print(me.id, telegram_config.this_dc)


asyncio.run(main())

Credentials stay outside source control. This introductory call uses explicit in-memory storage, so it does not retain the bot authorization after shutdown. Durable sessions use encrypted SQLite storage and require a constructor key or MINIPROTO_SESSION_KEY; the quickstart walks through that boundary before the first persistent authorization.

Explicit by design

Connection ownership, replay safety, flood waits, datacenter migration, update recovery, media scheduling, and cancellation behavior are documented as contracts rather than hidden behind a framework.

Fast paths with fallbacks

Native acceleration is capability-checked and benchmarked. The Python surface remains available when a native symbol or wheel is unavailable.

Reference you can search

Handwritten guides and generated Python, Telegram, and Rust pages share one local Pagefind index with language, kind, module, namespace, layer, and visibility facets.

A narrow package boundary

`miniproto` is the protocol SDK. Routers, filters, middleware, plugins, commands, and broad application-framework ergonomics belong to the future `mpgram` package.

Choose your route

Evaluate the SDKSee the supported platforms, package boundary, and first authorization flow. Build with high-level operationsSend messages, resolve peers, consume updates, and transfer media. Own the raw protocolInvoke generated Telegram requests and understand their result and error relationships. Operate it safelyLearn session protection, retry boundaries, observability, deployment, and deterministic testing.

Complete reference, committed with the code

The generated Markdown is reviewed and versioned with the source. The website build needs Node.js, Python, and a pinned Rust nightly, but the deployed output is plain static HTML, CSS, JavaScript, and a self-hosted search index.

Python referencePublic modules, classes, methods, parameters, aliases, and source links extracted statically with Griffe. Telegram referenceEvery Layer 228 function, type, constructor, parameter, known RPC error, and Python-visible import path. Rust referencePublic and PyO3-facing items normalized from pinned-nightly rustdoc JSON and cargo-docs-md.