Quickstart

One RapidAPI key. No phone number, no api_id, no MTProto client, no session file to keep alive. The free plan is 2,500 calls a month and takes no card.

Every response below is real output from the live API, captured on 16 September 2026.

Prefer a client to a terminal? Import /tgatlas.postman_collection.json by URL in Postman and you get the same calls with the headers already set.

curl 'https://telegram155.p.rapidapi.com/v1/usernames/telegram' \
  --header 'x-rapidapi-key: YOUR_KEY' \
  --header 'x-rapidapi-host: telegram155.p.rapidapi.com'

{
  "chats": [
    {
      "id": 1005640892,
      "title": "Telegram News",
      "username": "telegram",
      "verified": true,
      "participants_count": 0
    }
  ]
}

Most endpoints take a numeric peer_id, and this is where you get one. Two things are worth knowing straight away.

The size is not here. participants_count comes back 0: the resolve call identifies the channel, it does not measure it. The member count arrives in step 2.

A channel can hold several handles. When it does, username comes back empty and the live ones sit in a usernames array — @durov carries six, every one active, exactly one of them also editable. That editable entry is the primary handle. Read it first, fall back to any active entry, then to username, and only then to the numeric id — otherwise your links come out as a bare t.me/.

Already holding an id from the Bot API? Strip its -100 prefix before passing it here.

curl 'https://telegram155.p.rapidapi.com/v1/channels/1005640892' \
  --header 'x-rapidapi-key: YOUR_KEY' \
  --header 'x-rapidapi-host: telegram155.p.rapidapi.com'

{
  "full_chat": {
    "participants_count": 9542878,
    "about": "…",
    "can_view_stats": false,
    "admins_count": null
  }
}

9,542,878 members, measured at 05:23 UTC on 16 September 2026. The same object carries the description, the creation date, the verification flags and the boost counters.

curl 'https://telegram155.p.rapidapi.com/v1/peers/1005640892/history?limit=2' \
  --header 'x-rapidapi-key: YOUR_KEY' \
  --header 'x-rapidapi-host: telegram155.p.rapidapi.com'

{
  "count": 430,
  "next_page": "…",
  "messages": [
    { "id": 460, "date": 1787771554, "views": 1206173, "forwards": 3658 },
    { "id": 459, "date": 1787771544, "views": 1072118, "forwards": 2805 }
  ]
}

This is the call worth building on. Every post carries views and forwards, so engagement costs you one request:

1,206,173 views ÷ 9,542,878 members = 12.6% of the audience saw the latest post
    3,658 forwards ÷ 1,206,173 views = 0.30% forwarded it

next_page is a cursor: pass it back to walk the whole history, and count tells you how far it goes — 430 posts for this channel.

import os, requests

BASE = "https://telegram155.p.rapidapi.com"
H = {
    "x-rapidapi-key": os.environ["RAPIDAPI_KEY"],
    "x-rapidapi-host": "telegram155.p.rapidapi.com",
}

def handle(chat):
    """A channel may hold several handles. The primary one is active AND editable."""
    for u in chat.get("usernames") or []:
        if u.get("active") and u.get("editable"):
            return u["username"]
    for u in chat.get("usernames") or []:
        if u.get("active"):
            return u["username"]
    return chat.get("username") or str(chat["id"])

chat = requests.get(f"{BASE}/v1/usernames/telegram", headers=H, timeout=10).json()["chats"][0]
peer = chat["id"]

full = requests.get(f"{BASE}/v1/channels/{peer}", headers=H, timeout=10).json()["full_chat"]
members = full["participants_count"]

feed = requests.get(f"{BASE}/v1/peers/{peer}/history", headers=H, params={"limit": 20}, timeout=10).json()

for m in feed["messages"]:
    views = m.get("views") or 0
    print(f"t.me/{handle(chat)}/{m['id']}  {views:>9,}  {views / members:.1%}")

Three calls, and you hold a channel’s size, its feed and its engagement — without a phone number and without a bot inside the channel.

Every non-2xx response arrives in one envelope, so you write a single error path and reuse it everywhere:

{ "error": "service temporarily unavailable", "code": "SERVICE_UNAVAILABLE", "hint": "retry shortly" }

code is stable and machine-readable. Three of the seven cover almost everything you will meet on day one:

All seven codes, with the envelope fields, are in the endpoint reference.

2,500 calls a month, no card. That is enough to resolve a few hundred channels and walk their history before you decide anything.

On the same hub, competing Telegram listings open their free tiers at 10, 50 and 100 calls a month, and the closest paid plan to ours sells 2,500 for $9.99 (read from their own pricing pages on 2026-09-16).

Working code for the next step is on the cookbook page: engagement per post, finding the posts that travelled, watching a channel for new ones, and exporting a channel to CSV — four recipes, all on the feed route, with their real output.