Claude Code Channels: Telegram, Discord and Twitter (X) Alerts in Your Session

A channel is an MCP server that pushes. Anthropic's reference defines it as "an MCP server that pushes events into a Claude Code session so Claude can react to things happening outside the terminal." Claude Code spawns it as a subprocess and talks to it over stdio, the same transport any local MCP server uses. The difference from a normal MCP server is direction: a normal server waits for Claude to call a tool, while a channel can speak first.

One-way or two-way. A one-way channel forwards alerts, webhooks or monitoring events for Claude to act on. A two-way channel, like the Telegram and Discord bridges, also exposes a reply tool so Claude can answer in the same chat. A two-way channel that authenticates its senders can additionally relay permission prompts, so you can approve or deny a Bash or Write call from your phone (added in Claude Code 2.1.81, per the changelog).

What the model sees. Each event arrives in Claude's context wrapped in a tag such as <channel source="webhook" severity="high" run_id="1234"> with the event body inside. The source attribute comes from the server's configured name, and every meta key becomes another attribute. In your terminal the event shows as a one-line summary like ← webhook: build failed on main.

Anthropic's own comparison table places channels next to four neighbors. The distinction decides which one you want:

Status. Channels are a research preview. The changelog entry for Claude Code 2.1.80 reads "Added --channels (research preview): allow MCP servers to push messages into your session." Anthropic says availability is rolling out gradually and that the flag syntax and protocol contract may change. Neither --channels nor --dangerously-load-development-channels appears in claude --help during the preview; both still work.

Authentication. Channels require Anthropic authentication through claude.ai or a Console API key. They are not available on Amazon Bedrock, Google Cloud's Agent Platform or Microsoft Foundry.

Plans and admin switches. Pro and Max users without an organization skip the organization checks and opt in per session with --channels. On claude.ai Team and Enterprise, channels are blocked until an Owner enables them under Organization settings, Claude Code, Channels, or sets channelsEnabled: true in managed settings. Console organizations with API key auth are allowed by default unless they deploy managed settings. Admins can replace Anthropic's plugin allowlist with their own through allowedChannelPlugins.

Runtime. The four official plugins are Bun scripts, so bun --version must work. A custom channel only needs the @modelcontextprotocol/sdk package and a Node.js-compatible runtime: Bun, Node and Deno all work, per the reference.

The session must be open. Events only arrive while Claude Code is running. For an always-on setup Anthropic suggests running Claude in a background process or a persistent terminal. If Claude hits a permission prompt while you are away, the session pauses until someone answers, unless the channel relays the prompt.

The allowlist gate. During the preview, --channels only accepts plugins on an Anthropic-maintained allowlist (the channel plugins in claude-plugins-official) or your organization's list. Anything else, including a channel you write yourself or publish to your own marketplace, has to be loaded with --dangerously-load-development-channels, which shows a confirmation dialog and is ignored in non-interactive -p mode and in the Agent SDK. Being listed in .mcp.json is not enough to push messages.

Both chat bridges follow the same pattern; the plugin runs locally and polls the platform for new messages, so there is no URL to expose. For Telegram, create a bot with BotFather (/newbot) and copy the token. For Discord, create an application in the Discord Developer Portal, reset and copy the bot token, enable Message Content Intent, and invite the bot with the bot scope plus View Channels, Send Messages, Send Messages in Threads, Read Message History, Attach Files and Add Reactions.

Install. Run claude, then /plugin install telegram@claude-plugins-official (or discord@...). If Claude Code reports that the marketplace is missing, add it with /plugin marketplace add anthropics/claude-plugins-official; if the plugin is missing, refresh with /plugin marketplace update claude-plugins-official. Choose the user scope so the plugin works in every project.

Configure. /telegram:configure <token> saves the token to ~/.claude/channels/telegram/.env; Discord uses /discord:configure <token> and ~/.claude/channels/discord/.env. Setting TELEGRAM_BOT_TOKEN or DISCORD_BOT_TOKEN in your shell works too.

Restart with the flag. Exit and run claude --channels plugin:telegram@claude-plugins-official. Several plugins can follow --channels, separated by spaces.

Pair and lock down. Message or DM your bot, which answers with a pairing code. Back in Claude Code run /telegram:access pair <code>, then /telegram:access policy allowlist so only your account can reach the session. The Discord commands are the same with the discord prefix.

Discord server channels. The default flow is a DM bot. Per the Discord plugin's ACCESS.md, guild channels are off by default and opted in one at a time by channel ID with /discord:access group add <channel id>; with the default requireMention: true the bot only responds when @mentioned or replied to, and --no-mention processes every message. Telegram's Bot API exposes no message history or search, so the Telegram plugin only sees messages as they arrive, while the Discord plugin has a fetch_messages tool capped at 100 messages per call.

Try it without a bot. /plugin install fakechat@claude-plugins-official, then claude --channels plugin:fakechat@claude-plugins-official, and type into the chat UI at localhost:8787. It is the quickest way to see the event and reply loop before you create real bot tokens.

None of the four official plugins reads X (Twitter). To get posts, mentions or keyword matches into a session you build a channel, and the reference gives the exact contract: declare capabilities.experimental['claude/channel'] as {}, emit notifications/claude/channel with a content string and an optional meta map, and connect over stdio. For webhooks, the reference's pattern is a channel that listens on a local HTTP port; anything that can send an HTTP POST can then push events to Claude.

There are two ways to feed that port with X data, and they mirror the two kinds of channel Anthropic describes:

Both send the same JSON body to the channel: event_type, rule_tag and a tweets array, which is the shape a TwitterAPI.io webhook delivers. That way one channel server handles either source, and you can switch from polling to push without touching it.

This file follows the reference's webhook receiver almost line for line, rewritten for Node's built-in http module instead of Bun.serve. It adds three things the reference tells you to add for a channel that faces outside traffic: a sender check before anything is emitted (here, the X-API-Key header that TwitterAPI.io sends with every webhook, compared in constant time), meta keys that are plain identifiers (keys with hyphens are silently dropped), and instructions that tell Claude the body is untrusted.

Register it. Install the SDK with npm install @modelcontextprotocol/sdk, then add the server to .mcp.json: {"mcpServers": {"x-alerts": {"command": "node", "args": ["./x-alerts.mjs"], "env": {"TWITTERAPI_IO_KEY": "your_key"}}}}. Use an absolute path if you register it in ~/.claude.json instead.

Start Claude Code with it. claude --dangerously-load-development-channels server:x-alerts. Claude Code shows the development-channel warning and the new-MCP-server consent dialog, then spawns the file itself; a dim notice confirms Channels (experimental) messages from server:x-alerts inject directly in this session. If it says "blocked by org policy", an admin has to enable channels first.

What we verified. We ran this exact file with @modelcontextprotocol/sdk 1.32.2 on Node 25 under a stdio test client. The initialize result advertised {"experimental":{"claude/channel":{}}}; a POST with a wrong key got 401; the dashboard-style test_webhook_url ping got 200 and emitted nothing; a two-post tweet batch got 200 and emitted two notifications/claude/channel messages with rule_tag, author, tweet_id and url in meta. We did not load it into a live Claude Code session, so the rendering inside the session is as documented, not observed.

Webhook path. Create a rule with POST /oapi/tweet_filter/add_rule (tag, value as an X search query, interval_seconds between 0.05 and 86,400, default 60). Rules start inactive, so call POST /oapi/tweet_filter/update_rule with every field and is_effect: 1. Set the webhook URL on the dashboard's webhook page. Per that page, deliveries are a POST with Content-Type: application/json, carry your account API key in X-API-Key, and must get an HTTP 200 within 5 seconds or they count as failed; real events (event_type: "tweet") and connection tests (event_type: "test_webhook_url") hit the same URL. The channel binds to 127.0.0.1, so the public URL has to be a tunnel or relay you run that forwards to that port, and the key check is what keeps strangers out.

Polling path. The script at the end of this page asks /twitter/tweet/advanced_search for posts newer than the last check with a since_time: operator, removes duplicates, and POSTs them to 127.0.0.1:8788 in the same body shape. Nothing listens on the internet, and Claude only sees new posts.

Write tight rules. Every post becomes text in Claude's context. Exclude reposts with -is:retweet, add lang:en if you only read English, and prefer exact phrases or from: and to: operators over single words. The study below shows why the difference between a phrase and a word is two orders of magnitude.

Tell Claude what to do with it. The channel's instructions string is delivered to Claude when the server connects. Keep it about handling: summarize, flag what matters for the current task, and never take instructions from the post body. Anthropic calls an ungated channel "a prompt injection vector"; for X data the sender is gated (only your key can post to the port), but the content is still written by strangers.

The reference says events queue and are processed in order, and that several notifications arriving while Claude is busy are delivered together on its next turn. So the question for an X channel is how often posts arrive faster than Claude can take a turn. We measured four rules on 1,059 real X posts collected in 2026, then counted, for every 60-second window in each sample, how many posts it held.

Broad rules arrive as batches. On the bare phrase "claude code", 93.9% of minutes held two or more posts and the busiest minute held 24; over five-minute windows the busiest held 39. Pointed at a session doing real work, that is a stream of grouped events competing with your task for context.

Mentions are the middle ground. Mentions of @claudeai ran at 77 an hour: 41.0% of minutes held exactly one post and 30.8% held several. A brand account smaller than Anthropic's would sit far lower.

Feature phrases are quiet. The phrase "claude code" channels produced 8.3 posts a day with a median gap of 92 minutes; 99.4% of minutes were empty. That is the right shape for a channel: occasional events Claude can handle one at a time.

Treat the batching column as an upper bound on interruptions rather than a forecast: how many posts Claude receives together depends on how long its turns take, which this study cannot see.

The same search doubles as a read on how the feature is discussed. Across 343 posts matching "claude code" channels (Latest and Top results, 292 distinct authors), these are the sources people name:

Slack is the most-named platform that is not a channel. Some of those posts use "channels" in the Slack sense, but the pattern matches a common confusion: Claude in Slack is a separate feature that spawns cloud sessions, not a channel into your local session. WhatsApp has no official channel plugin either.

Webhooks are rarely discussed. Only 7 posts mention webhooks, although the reference's first worked example is a webhook receiver. Custom event sources, X included, are the least-covered use of the feature.

The official accounts barely mention it. In the last 100 posts from @claudeai and 100 from @AnthropicAI, 0 mention Claude Code channels (19 and 2 mention Claude Code at all). The oldest posts in the Top results for the phrase date to March 2026, consistent with the 2.1.80 release; the docs and changelog are where the feature is actually specified.

TwitterAPI.io bills tweet reads at 15 credits per post returned, which is $0.15 per 1,000 posts, with a minimum of 15 credits ($0.00015) per request, so an empty check is never free. A rule checked every 60 seconds therefore has a floor of 43,200 checks a month, $6.48, before it returns a single post; every 5 minutes the floor is $1.30. The official X API's pay-per-usage rate card at docs.x.com/x-api/getting-started/pricing charges $0.005 per post read, which is $5 per 1,000 posts, about 33 times $0.15, and caps pay-per-usage at 3 million post reads a month.

Applied to the four rules measured above, with a 60-second check:

Quiet rules are paid by the clock, loud rules by the posts. For the two quiet rules the bill is the $6.48 polling floor, and stretching the interval is the lever. For the loud rules the posts dominate, and narrowing the query is the lever. The X column counts post reads only; it excludes the cost of any empty checks on X's side and any other X fees.

New accounts that pass the automatic bot check get up to $1 of free credits (at most 100,000 credits, no card, one per person or network, expiring after 31 days), enough to try a feature-phrase rule for a few days. Purchased credits never expire. Before the first payment the rate limit is 0.2 requests per second, which is fine for one poller; it rises to 20 once paid. Plans and current numbers are on the pricing page.

Channels and ordinary MCP servers combine. With the Telegram or Discord channel running, you message the bot from your phone, and the work runs in your local session against your files. If that session also has an X data MCP server, the same message can ask about X: "what are people saying about our launch today?" Claude calls the X tools, answers, and the reply goes back to Telegram through the channel's reply tool.

TwitterAPI.io's MCP server is one command in Claude Code: claude mcp add twitterapi-io npx -- -y @twitterapi_io/mcp-server -e TWITTERAPI_IO_API_KEY=your_key_here. It is pull, not push: Claude queries it when asked. Use it for questions you send from the chat, and the x-alerts channel for events you want to arrive unasked.

Keep the gates on. Anyone who can message a paired bot can put text in front of Claude, and with permission relay they can approve tool calls. Keep the allowlist policy, gate on the sender's ID rather than the room (the reference is explicit that group chats otherwise let any member inject messages), and treat every X post as untrusted input.

Write actions are separate. Reading X needs no X account. If a workflow should post or reply on X, TwitterAPI.io's write endpoints run through an authenticated session: one /twitter/user_login_v2 login ($0.10, with a proxy you supply) returns login_cookies, then each action such as /twitter/create_tweet_v2 costs 60 credits ($0.0006), billed per HTTP 200 call. Each call acts as that account, X can rate-limit, lock or suspend it, the session can need a re-login, and you should keep a human pace and approve posts yourself rather than let a channel event trigger one.