How to Use the Telegram API in Your Agent

Give your agent a public-channel watchlist and get profiles plus readable posts. Paste this into your agent:

Set up https://monid.ai/SKILL.md, then use Monid to inspect Telegram tools, fetch profiles for telegram and telegramtips, and read two posts from telegram. Save channel and post tables separately, preserve raw counts, and stop after these small calls.

Discover, inspect, then collect a small sample before scheduling.

If you're a developer searching for the Telegram API, copying channel information into a spreadsheet stops working as soon as your two-channel list also needs post dates, message identifiers, and a repeatable refresh. A channel profile and a message are different records, even when they appear on the same page.

A manual export leaves your agent without a collection step. A custom reader adds parsing, pagination, and storage decisions before your actual research task begins.

We'll build two small tables through Monid, the OpenRouter for agent tools: one key and one balance for tool calls. Start with channel profiles, collect posts only where needed, and preserve the returned identifiers for the next refresh.

Here is the profile preview from our November 10 test, using public organizational channels:

How to use the Telegram API with Monid

Use Monid to discover a public-channel reader, inspect its input, and make one small request. An endpoint is a callable function with a defined input and response; this guide uses read functions supplied by TikHub and Litescrape.

Step 1. Install and add your key

For agents: get a key at app.monid.ai, then give your agent the setup instruction and the key through its credential workflow.

set up https://monid.ai/SKILL.md

The agent quickstart explains that setup. Your agent performs discovery and schema inspection before spending on collection.

For humans: install the CLI and save your key locally.

npm install -g @monid-ai/cli
monid keys add -k <your-api-key> -l main

The CLI quickstart covers configuration. Keep credentials out of article examples, saved research tables, and shared repositories.

Step 2. Inspect your two collection jobs

Search the Telegram tools for profiles and posts, then inspect the batch profile function before calling it.

monid discover -q "telegram batch channel info" -l 3 --include-unavailable
monid inspect -p tikhub -e /api/v1/telegram/web/batch_channel_info

The batch input is channels, a comma-separated string with a documented maximum of 20 usernames. This is a request-size limit, not a promise that every supplied channel produces a usable profile.

Step 3. Collect two channel profiles

Call batch_channel_info with the two brand channels; --query is required because inspection places the input in query parameters.

monid run -p tikhub -e /api/v1/telegram/web/batch_channel_info \
  --query '{"channels":"telegram,telegramtips"}' -w

Our call returned count: 2 and two ok: true entries, each containing channel and info. Keep each entry's success flag with its profile so downstream filtering does not confuse a failed lookup with an empty subscriber count.

Step 4. Read two posts from the selected channel

Inspect and call fetch_channel_posts, setting a small limit when testing so you can review the actual records before expanding collection.

monid inspect -p tikhub -e /api/v1/telegram/web/fetch_channel_posts
monid run -p tikhub -e /api/v1/telegram/web/fetch_channel_posts \
  --query '{"channel":"telegram","limit":2}' -w

This returned two messages, the channel profile, and a pagination object. Save the completed response by retrieving its run ID with monid runs get -r <runId> -o posts.json; retrieving that same completed run avoids a second collection request.

Why separate channel profiles from Telegram posts?

Separate profiles from posts because a subscriber display describes a channel, while a view display belongs to one message. Joining them carelessly repeats audience numbers across messages and creates misleading totals.

Keep channel context at channel level

The two profile records returned username, title, verified, description, photo, subscribers, and counters. Store one profile snapshot per channel and collection time; retain the original subscriber string rather than presenting a rounded display as an exact audience measurement.

For a single channel, fetch_channel_info accepts channel instead of a list. We tested it separately and got the same Telegram News subscriber display and verification flag as the batch response.

monid inspect -p tikhub -e /api/v1/telegram/web/fetch_channel_info
monid run -p tikhub -e /api/v1/telegram/web/fetch_channel_info \
  --query '{"channel":"telegram"}' -w

Its price is $0.001 per call, Verified 2026-11-10, on the TikHub tools page.

Keep message identity at post level

The post response returned message identifiers 460 and 459 with separate dates, types, and views. Use the channel identifier together with the message identifier as your storage key; a message number alone does not describe which channel you read.

The posts response already includes channel_info, so a refresh that needs both posts and that channel's current profile does not require a separate profile call. Reserve batch profiles for qualifying a list before deciding which channels deserve post collection.

The 3 ways to collect public Telegram data

Choose between agent-driven calls, CLI-driven calls, and a collector you maintain. These are workflow choices; the response contract and your storage requirements still need explicit handling.

Let an agent choose the function

An agent is useful when the input starts as a research request: qualify these channels, then read posts from the relevant ones. Give it a stopping rule, accepted inputs, and a spend ceiling rather than asking it to search and collect indefinitely.

For the same collection pattern on another public social source, see using Instagram data in an agent. It separates profile totals from nested posts and preserves completed run evidence, the same distinctions your Telegram collector needs.

Fix the calls in a script

A script fits when the channel list and output columns are stable. Keep discovery and inspection in your development checklist, then use the inspected function and query parameters in the recurring job.

Keep a working collector

Keep your existing collector when its output already satisfies the task. A migration earns its effort when you need a different collection contract or a shared tool balance; moving a working pipeline for a new label adds no research value.

How do you turn the response into a useful table?

Export channel profiles and message summaries as separate tables, joined by channel identity. The following message table comes from the two-record TikHub call, with text and media links omitted.

Preserve evidence before adding interpretation

Keep views as a raw string, the publication timestamp, and your own collection timestamp. A missing preview and an empty reactions array describe the returned response; they do not establish that nobody reacted or that the message never contained a link.

Our editorial recommendation is to summarize topic and recency before ranking by displayed reach. The two returned messages share a publication date, while their displayed views differ; a useful report keeps those facts together rather than declaring the larger number the better channel.

For a deeper treatment of rounded counters, cursor gaps, and post-age comparisons, read Telegram channel posts and views without a bot token.

Choose a compact text response when that is enough

The alternative Litescrape /telegram/posts returned 20 posts with id, url, text, published_at, and views. Its response also included channel title, description, and next_before; our call used the same public brand channel.

monid inspect -p litescrape -e /telegram/posts
monid run -p litescrape -e /telegram/posts \
  --query '{"channel":"telegram"}' -w

There is no limit property in this inspected input schema, so do not copy the TikHub limit option into it. The call is $0.00015 per request, Verified 2026-11-10, as shown on the Litescrape card.

How much does public Telegram collection cost?

These four tested functions bill per call, and discovery and inspection are free. Monid charged one billed unit for each completed request, including the batch that contained two channel profiles.

The batch profile price is $0.008 per call; the TikHub posts price is $0.001 per call, Verified 2026-11-10. Both are available through the Telegram collection catalog.

Budget requests separately from returned rows

Our four calls cost a measured total of $0.01015, Verified 2026-11-10. They produced two batch profiles, one duplicate single-channel profile, two TikHub messages, and 20 Litescrape posts; those counts are different from the four billable requests.

Created-to-completed times were 3.041 seconds for batch profiles, 4.731 seconds for TikHub posts, 1.927 seconds for the single profile, and 3.283 seconds for Litescrape posts. These are individual run observations, including queue time, rather than a latency guarantee.

Bound history collection before scheduling

TikHub returned before_cursor: 459, after_cursor: 460, and has_more_before: true. A deeper history request is another call, so set both a page ceiling and a stopping date before allowing an agent to follow cursors.

All four tests succeeded; neither empty-result billing nor failure billing was measured. Do not turn successful-call evidence into a refund rule for cases this sample did not contain.

Which endpoint should you choose for each job?

Choose the smallest response that contains the fields your next operation requires. Each function below was inspected and run successfully on November 10; the price at the end of each row is per call, Verified 2026-11-10.

When should you use something else?

Use another collection path when you need authenticated access, message sending, member identities, or exact audience measurements. The functions tested here read public channel information and posts; they do not provide those other capabilities.

This is the Monid blog, and we resell access to these providers. Choose TikHub's richer response when media structure and a bounded message sample matter; choose Litescrape's compact response when the returned text fields cover the task. Keep your own established integration when it already delivers your required access and output.

Neither response creates a durable archive or scheduler for you. Your application owns storage, repeated execution, deduplication, and alerting; signed media addresses are also unsuitable as permanent archive identifiers.

Conclusion

You now have a repeatable path from a public-channel list to separate profile and post tables through Monid. Qualify channels first, read only the posts your research needs, and save identifiers, raw counts, dates, and cursors together. The sample used existing credentials, so it establishes collection results rather than a setup-time or hours-saved estimate. Your next report can refresh the same evidence without rebuilding the collection process.

FAQ

Published November 2026.