Markdown edition

# Pair one Telegram sender with Claude Code and verify a private reply

> Install Claude Code's official Telegram channel, pair one sender, inspect its allowlist, and check a same-chat reply against an existing project file.

By BIGCHANGE.AI Editorial

Published: 2026-10-26T13:19:38.898Z
Updated: 2026-10-26T13:19:38.898Z
Canonical: https://bigchange.ai/blog/claude-code-telegram-channel-pair-private-reply-guide

![Conceptual charcoal illustration of one phone in a stand on a side table, with a blank desktop monitor across the room.](https://bigchange.ai/api/media/file/claude-code-telegram-one-sender-hero-v3.png)
AI-generated conceptual illustration by BIG CHANGE.

This guide pairs one Telegram sender with a running Claude Code project session, then checks a reply against a file you own. Documentation was checked on 26 October 2026. BIG CHANGE did not run a bot or model for this article.

## The big change

- **What changed:** Anthropic documents a Telegram channel plugin for Claude Code.
- **Why it matters:** Comparing the answer with an independently opened file gives the owner a concrete completion check.
- **What to watch:** The owner should see the intended sender in the access readback, a real inbound event and permitted file read in the terminal, then a matching answer in the same Telegram chat. A chat reply alone cannot establish what file the session read.

## 1. Check access and install the plugin

[Anthropic's Channels manual](https://code.claude.com/docs/en/channels) calls Channels a research preview. Use claude.ai or Console authentication; Bedrock, Google Cloud Agent Platform and Foundry are excluded. Team, Enterprise and managed Console organizations need enablement. Stop on a policy denial. Review project instructions and tools. Bun is required.

In the project terminal:

```sh
claude --version
bun --version
claude
```

At the Claude prompt:

```text
/plugin install telegram@claude-plugins-official
```

Choose user scope. For a missing marketplace, use the first command; for a missing plugin, the second. Retry once:

```text
/plugin marketplace add anthropics/claude-plugins-official
/plugin marketplace update claude-plugins-official
```

If the install requests a reload, run:

```text
/reload-plugins
```

## 2. Create the bot and keep its token private

The [official Telegram plugin README](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/telegram) documents BotFather setup. Open the genuine [BotFather](https://t.me/BotFather) chat and send:

```text
/newbot
```

Choose a display name and a unique username ending in `bot`. In your file manager or editor, create `~/.claude/channels/telegram` if absent (`~` means your home directory). Save a file named `.env` inside it, containing:

```text
TELEGRAM_BOT_TOKEN=<ACTUAL_PRIVATE_TOKEN>
```

Restrict the file's access to your account before entering the actual token. Keep it out of prompts, repositories and screenshots. A shell `TELEGRAM_BOT_TOKEN` overrides the file; inspect that source if the wrong bot appears. This recipe assumes the default directory: stop on a custom state directory and consult its configuration instructions. The README's alternative configure command puts the token in a Claude interaction; this guide uses the private file route.

Exit Claude, return to the same project and relaunch:

```sh
claude --channels plugin:telegram@claude-plugins-official
```

Keep the terminal open; check registration warnings. Read the reply on Telegram. Preview flags may be absent from help. Offered permission relay lets trusted senders authorize tools.

## 3. Pair only your sender and read back access

Message the bot privately from the intended account. The [plugin's access reference](https://github.com/anthropics/claude-plugins-official/blob/main/external_plugins/telegram/ACCESS.md) says the first message yields a pairing code and is dropped. At the Claude prompt:

```text
/telegram:access pair <code>
/telegram:access policy allowlist
/telegram:access
```

Check the reported policy, senders, pending pairings and groups. Proceed only with `allowlist`, your sole numeric sender ID and no enabled groups. Hold on an unfamiliar ID. To remove one, use its read-back ID and inspect again:

```text
/telegram:access remove <numeric-user-id>
/telegram:access group rm <group-id>
/telegram:access
```

To discard a pending code:

```text
/telegram:access deny <code>
```

Stop if `TELEGRAM_ACCESS_MODE=static` is set: it pins startup access and disables pairing. Allowlist silently drops unlisted senders, so silence alone is no evidence of rejection. Keep the answer short; Telegram chunks long messages.

## 4. Check an actual file and the same-chat reply

Choose an existing, nonsensitive project file that you are allowed to send through Telegram and Anthropic. Open it yourself and write down its first heading and one literal field or fact. Record its revision or hash if you can. Check that the Claude terminal is still in the intended project and review the session's tools and instructions before sending a request.

Replace both brackets with facts from that file, then send this from the paired Telegram account:

```text
Read [relative path to the approved existing file]. Report its first heading and [one exact field]. Stop if missing or a new permission is needed. Do not edit files, infer the answer from memory or contact other services.
```

At the terminal, look for the inbound event and actual permitted file-read action. Handle any permission request there. Compare the answer in the same Telegram chat with the file you opened independently. If the event or read is missing, or the answer differs, hold the result; do not call it a successful check. The prompt expresses the requested scope, while the session's actual permissions determine access.

Keep a short private record so you can distinguish a verified result from an attempted send:

```text
UTC/version/account route: [actual, no secrets]
Project/file revision: [actual]
Access readback: [policy, own sender only, no groups]
Inbound event and file read: [observed or unknown]
Same-chat answer compared with file: [match/mismatch/unknown]
Second-account check: [not run, or actual admission evidence]
Stop state: [actual]
Decision: [complete/hold with reason]
```

If nothing arrives, inspect the running session, channel registration, token source and access readback before retrying. When a send result is uncertain, inspect the existing chat first to avoid mistaking a late reply for a new one. Do not claim an unauthorized-sender test from silence; record that optional check only if you can observe its admission evidence. Exit the Claude session when finished and verify that it stopped. Stopping does not erase provider records or local credentials. If a token is exposed, leave the channel stopped and follow the provider's current credential-recovery process.

## Cost and scope

[Anthropic's cost guide](https://code.claude.com/docs/en/costs) distinguishes subscription usage from API billing. Pro and Max include usage within plan limits; API use consumes billable tokens. Team and Enterprise terms depend on the account. At the Claude prompt, check:

```text
/usage
```

Review plan limits and any enabled extra usage credits. Session dollar figures are estimates; Console billing is the authoritative record for API charges. This documented workflow establishes no fixed cost, delivery time or offline-delivery guarantee.

For a Mac self-chat through Claude Code, see our [iMessage channel guide](https://bigchange.ai/blog/claude-code-imessage-channel-self-chat-guide). Our [OpenClaw forum-topic guide](https://bigchange.ai/blog/openclaw-telegram-topics-separate-agents-memory-check) covers agent and memory separation, while the [Hermes VPS guide](https://bigchange.ai/blog/hermes-vps-docker-private-telegram-first-reply) covers a deployed gateway. Those are different setups from pairing this Telegram plugin with one running Claude Code session.

## Sources

- [Anthropic, Claude Code Channels](https://code.claude.com/docs/en/channels) — Account eligibility, installation and channel behavior. Verify actual availability and your organization's policy.
- [Anthropic, official Telegram plugin README](https://github.com/anthropics/claude-plugins-official/tree/main/external_plugins/telegram) — BotFather and token setup, default directory and token-source behavior. The private file recipe assumes the plugin's default state directory; custom installations need their own instructions.
- [Anthropic, Telegram plugin access reference](https://github.com/anthropics/claude-plugins-official/blob/main/external_plugins/telegram/ACCESS.md) — Pairing, access policy/readback, removal, pending-code denial and static-mode limits. A silent drop is not an observed unauthorized-sender test.
- [Anthropic, Claude Code costs](https://code.claude.com/docs/en/costs) — Subscription and API billing, usage and estimate limits. Actual charges depend on the reader's account and billing record.