← All posts
Comparison

Telegram's Guest Mode vs a Unified Inbound Webhook: Which Actually Solves Multi-Agent Messaging? — UnifyPort

In March 2026, Telegram shipped Bot API 9.5 and quietly solved a problem that’s annoyed bot developers for years: what happens when someone @mentions your bot in a group chat it was never added to? Until now, the answer was “nothing” — the bot doesn’t receive the message, can’t see the chat, and can’t reply. Guest Mode changes that. Enable it in BotFather’s settings, and your bot can now receive a guest_message update and fire back one reply via answerGuestQuery, without ever joining the group.

If you’re building Telegram bots, this is a genuinely useful primitive. If you’re building agents that operate across Telegram, WhatsApp, LINE, Zalo, TikTok, and X, it solves about one-sixth of your actual problem — and it’s worth being precise about which sixth.

What Guest Mode actually does

The mechanics are narrow and well-defined. When a user @mentions your bot in a supported chat, or replies to one of its previous messages, Telegram sends an Update containing a guest_message, plus a guest_query_id — an opaque token — and identifiers for guest_bot_caller_user and guest_bot_caller_chat. Your bot calls answerGuestQuery with that token and gets back a SentGuestMessage. One mention, one reply.

That’s the entire interaction. Telegram is explicit about the limits:

  • No chat history. The bot sees the triggering message and nothing before it.
  • No participant list. You can’t enumerate who’s in the chat.
  • No standing presence. Unless mentioned or replied to again, the bot doesn’t hear about future messages in that chat.
  • One reply per query. This is a request/response primitive, not a subscription.

For a narrow class of bots — a documentation lookup bot that gets @mentioned in random dev group chats, a unit-converter bot, a translation helper — this is exactly right. It’s lightweight, opt-in (the chat admin doesn’t need to add the bot, and the bot operator flips one switch in BotFather’s MiniApp), and it removes the friction of “please add @MyBot to this group” that killed adoption for a lot of utility bots.

The problem it doesn’t solve

Guest Mode is a Telegram feature, full stop. It’s implemented in Telegram’s client and server stack, surfaced through Telegram’s Bot API, and triggered by Telegram-specific UI (an @mention or reply inside a Telegram chat). None of that transfers.

If your team is running support or agent workflows across more than one channel — which is most teams doing customer-facing automation in 2026 — “how does my bot get pulled into a conversation without being formally added” is not a Telegram-only question. The same shape of problem exists on:

  • WhatsApp, where a customer messages a number directly and your system needs to pick it up without a pre-existing “conversation” object
  • LINE, where a user follows an Official Account and starts messaging — no group membership involved at all
  • X, where someone DMs your account or @mentions it in a reply
  • TikTok and Zalo, each with their own inbound shape

Telegram solved its version of “receive a message addressed to you, from somewhere you weren’t explicitly watching.” But if you build your inbound pipeline around guest_message and answerGuestQuery, you’ve built it for one-sixth of your channels. The other five need their own integration, their own auth model, their own event shapes — and Guest Mode’s specific constraints (no history, one reply, re-trigger required) don’t even map cleanly onto how WhatsApp or LINE conversations work in the first place.

The actual shape of the problem

Strip away the platform-specific mechanics and what every team in this position wants is the same thing: a single normalized event that fires whenever a message arrives addressed to one of your accounts, regardless of which platform it came in on, plus one endpoint to send the reply back.

That’s not a Telegram feature. That’s an integration layer — and it’s the layer UnifyPort exists to be.

How a unified webhook covers the same ground, across six platforms

UnifyPort’s webhook emits a single message.received event for inbound messages on any connected channel:

{
  "event": "message.received",
  "account_id": "acct_8Q2vK",
  "provider": "telegram",
  "from": "user_3f9c1a",
  "text": "Hey, are you open on weekends?",
  "timestamp": 1749427200,
  "message_id": "tg_msg_5d2b7e"
}

Switch provider to whatsapp, line, zalo, tiktok, or x, and the shape of the event doesn’t change — only the value of that one field does. Your handler doesn’t branch on six different SDKs or six different webhook formats; it branches on evt.event === "message.received" once, and evt.provider tells it which channel to reply through if that matters.

Replying is symmetric: one POST /v1/messages call, authenticated with a Bearer API key, addressed by account_id and from — same call regardless of which platform the inbound message arrived on. Every delivery to your webhook is signed with HMAC-SHA256 using the signing_secret you configured, so verification is also one code path, not six.

Telegram ─┐
WhatsApp ─┤
  LINE   ─┼──► UnifyPort ──► message.received ──► your webhook
  Zalo   ─┤         ▲                                   │
 TikTok  ─┤         │                                   ▼
   X     ─┘    POST /v1/messages ◄──────────── your reply logic

Where Guest Mode requires the chat admin (or the conversational context) to @mention your bot before it can act, UnifyPort’s inbound events fire on the platform-native trigger for each channel — a DM, a follow, a reply — translated into the same message.received shape every time. You’re not waiting for a Telegram-specific signal to replicate itself on five other platforms that don’t have an equivalent.

What this means in practice

If Telegram is genuinely your only channel and your use case fits Guest Mode’s shape — occasional @mentions in group chats you don’t manage — it’s worth enabling. It’s free, it’s native, and it requires no additional infrastructure.

But if you’re past that point — running an agent or support workflow that needs to receive messages on Telegram and WhatsApp and whatever else your customers use — building around Telegram-specific primitives means rebuilding the same logic five more times, once per platform, each with its own quirks. A unified webhook collapses that into one integration done once. Connect your channels and read the message.received reference — and if you’re feeding it to an AI coding agent to scaffold the receiver, here’s what that build looks like in practice.