Claude Code Channels Setup Guide: Telegram, Discord, and Custom Webhooks

Set up Claude Code Channels for Telegram and Discord in 30 minutes. Push webhooks, alerts, and chat messages into your terminal. Full setup guide with custom channel code.

Claude Code couldn’t receive messages. Until now.

For six lessons, we built an increasingly powerful system. Extensions that remember context. MCP servers that connect to external tools. Hooks that enforce rules. Agents that run in parallel. Plugins that package everything for others.

The system handles anything I throw at it from the terminal. But the terminal was always the bottleneck. If I’m away from my laptop, Claude Code stops. If a CI pipeline fails at 2 AM, I don’t know until morning. If a teammate wants to ask my Claude Code setup a question, they need SSH access to my machine.

Claude Code Channels fix all of that. And judging by the reaction, I’m not the only one who wanted this.

👋 Julley, I'm Dheeraj, an AI systems builder.

I build production-grade AI systems at work by day and ship my own products by night, 9 and counting, including SubflowAI and the Content OS Agents Toolkit. This newsletter is the bridge between those two worlds. Every system, every build, documented step by step.

---

Join 1,800+ builders getting the exact AI setups, prompts, and workflows that actually work in your business.

Claude Code Masterclass - Full Course

1. AI Content Multiplication System

2. The Claude Code Extension Stack

3. MCP Servers and Automation Hooks

4. Build a 3-Agent AI Research Team

5. The Full AI Content System Pipeline

6. Create a Claude Code Plugin

7. Claude Code Channels (Telegram, Discord) ← You are here

---

Claude Code kills OpenClaw?

Well, it seems that Anthropic seems to have built OpenClaw into Claude Code (almost). With Claude Code Channels new feature in 2.1.80 Claude Code version now I can,

• message my Claude Code session from Telegram while walking with my wife.

• fire a webhook from GitHub and Claude triages the issue before I open my laptop.

• send a DM to a teammate, Discord bot and gets an answer from the same Claude Code instance that knows my entire project.

The Reddit thread announcing Channels was full of developers saying “I literally built this last week.” So did we here in our OpenClaw full course seris.

This is Lesson 7 of the Claude Code Masterclass. In Lesson 6, we packaged everything into distributable plugins. Today we break Claude Code out of the terminal entirely.

Claude Code Channels are MCP servers that push external events into a running Claude Code session. Chat messages, webhooks, alerts, etc.. anything that happens outside your terminal can now reach Claude Code in real-time. Claude can respond through the same channel. Your terminal becomes a hub, not a cage.

---

What 17 AI-First Creators Are Betting On for 2026

---

👋 Julley, I’m Dheeraj and I’m an AI systems builder.

I build production-grade AI systems at work by day and ship my own products by night (9+). This newsletter is the bridge between those two worlds. Every system, every build, documented step by step.

---

Join 1,100+ builders getting the exact AI setups, prompts, and production configs that actually work in your business.

The walkie-talkie upgrade of Claude Code

Think about a home security system. The cameras record. The motion sensors trigger. The alarm sounds. But it all stays inside the house. If you’re at work, you know nothing until you get home and check the footage.

Now add a phone notification. The camera detects motion, your phone buzzes, you see the feed, and you can talk through the speaker. Same security system. But now it reaches you wherever you are.

That’s what channels do for Claude Code. Same powerful system. But now it reaches you through Telegram, Discord, or any webhook-enabled service - and you can talk back.

---

How do Claude Code Channels work?

A channel is an MCP server that runs on the same machine as Claude Code. Claude Code spawns it as a subprocess (a background process it controls directly) and communicates over stdio (standard input/output, the simplest way two programs talk).

Your Claude Code channel server is the bridge between external systems and the Claude Code session.

There are two patterns:

1. Chat platforms (Telegram, Discord): Your plugin runs locally and polls the platform’s API for new messages. When someone DMs your bot, the plugin receives the message and forwards it to Claude. No URL to expose. No server to deploy. It runs on your laptop.

2. Webhooks (CI, monitoring): Your server listens on a local HTTP port. External systems POST to that port, and your server pushes the payload to Claude. GitHub pushes, Stripe events, health checks - anything that can send an HTTP request.

Both patterns follow the same flow:

1. External event arrives (message or webhook)

2. Channel server receives it

3. Server emits a notifications/claude/channel event

4. Claude reads the event and decides what to do

5. (Optional) Claude calls a reply tool to send a response back

The key insight: channels are push, not pull. Claude doesn’t periodically check for messages. The channel server pushes events into the session the moment they arrive.

---

“Wait, isn’t this just Claude Code Remote Control?”

This was the most common question, and it’s fair. Claude Code already has Remote Control (/remote-control), which lets you take over a terminal session from the Claude mobile app. There’s also Dispatch for CoWork sessions.

Here’s the difference: Remote Control connects the Claude app to your terminal. Channels connect anything to your terminal.

An Anthropic engineer clarified on X: “We want to give you a lot of different options in how you talk to Claude remotely. Channels is more focused on devs who want something hackable.”

Remote Control v/s Channels in Claude Code

Remote Control is a polished consumer experience, open the Claude app, see your session, type. Channels is a developer primitive, an MCP server that you can wire to Telegram, Discord, a webhook, a cron job, a Slack bot, or anything else with an API. Remote Control is the remote. Channels is the IR blaster you can point anywhere.

• If you want to check on Claude from your phone while you’re away from your desk, Remote Control works.

• If you want CI/CD alerts to reach Claude, or teammates to query your Claude setup through Discord, or a monitoring system to trigger actions - that’s Channels in Claude Code.

---

Commercial break: Claude Code Builder cohort

The founding batch of my Claude Code cohort starts in July on Maven. Four weeks, six sessions. Learn to build the AI system with me.

Only 12 Seats. When they’re gone, the founding price ($797) closes and Cohort 2 opens at $1,597.

Use code GENAI20 for 20% off. Expires July 9. Check the Syllabus →

---

What do you need to get started with Channels?

Before setting up channels, confirm these:

• Claude Code v2.1.80 or later - run claude --version to check

• claude.ai authentication - Console and API key auth don’t support channels

• Bun runtime - the official plugins use Bun (install: curl -fsSL https://bun.sh/install | bash).

  • After installing, run exec /bin/zsh (or open a new terminal) so Bun is available in your PATH. Skip this if Bun is already installed.

• Team/Enterprise users - an admin must explicitly enable channels in managed settings (channelsEnabled: true)

• Pro/Max users - channels are available, opt-in with the --channels flag

Channels are currently in research preview (as of March 2026). The --channels flag syntax and protocol may change. During the preview, only plugins from the Anthropic-maintained allowlist are supported without extra flags. Full details in the official Channels documentation.

---

The Claude Code Extension Stack: Commands, Skills, Hooks, and Agents Explained

---

Quickstart: fakechat (5 minutes)

Mini Exercise (5 minutes): Before connecting Telegram or Discord, run the fakechat test to confirm channels is working on your machine.

Step 1: Install the plugin

/plugin install fakechat@claude-plugins-official

If the marketplace isn’t registered yet:

/plugin marketplace add anthropics/claude-plugins-official

Step 2: Restart Claude Code with channels enabled

bash
claude --channels plugin:fakechat@claude-plugins-official

Troubleshooting - “fakechat MCP failed”

If you run /plugin and see “fakechat MCP” with a red X, check two things:

1. Bun not in PATH - If you just installed Bun, your shell doesn’t know about it yet. Run exec /bin/zsh and source ~/.zshrc (or open a new terminal), then restart Claude Code with the command above.

2. Port 8787 already in use - A leftover process from a previous session may be holding the port. Run lsof -i :8787 to check. If something shows up, kill it with lsof -ti :8787 | xargs kill, then restart Claude Code.

Step 3: Test it

• Open http://localhost:8787 in your browser.

• Type a message.

• Claude processes it in your terminal session and the reply appears in the browser.

That’s it. If this works, your channels infrastructure is ready. The rest is connecting real platforms.

Pro tip: Add --dangerously-skip-permissions for unattended use in trusted environments. This lets Claude act on channel messages without prompting you for approval on each tool call.

---

Setting up Telegram in Claude Code Channels (10 minutes)

This is the channel I will use most. Telegram’s bot API is free, fast, and works on every device.

Step 1: Create a Telegram bot

1. Open Telegram and search for @BotFather

2. Send /newbot

3. Give it a name (e.g., “My Claude Code Bot”)

4. Give it a unique username ending in bot (e.g., myclaude_code_bot)

5. Copy the token BotFather gives you

Step 2: Install the plugin

/plugin install telegram@claude-plugins-official

Step 3: Configure your token

/telegram:configure <your-bot-token>

This saves the token to .claude/channels/telegram/.env. Alternatively, set TELEGRAM_BOT_TOKEN in your shell environment.

Step 4: Restart with channels enabled

bash
claude --channels plugin:telegram@claude-plugins-official

Step 5: Pair your account

1. Open Telegram and send any message to your bot

2. The bot replies with a pairing code

3. In Claude Code, run: /telegram:access pair <code>

Step 6: Lock down access

/telegram:access policy allowlist

This restricts the bot to only respond to your Telegram account.

Critical for security - without this, anyone who finds your bot’s username can send messages to your Claude Code session.

Testing it

Send a message to your bot from Telegram: “What files have changed since my last commit?”

In your terminal, you’ll see the inbound message appear. Claude processes it, and the reply goes back to Telegram. The response text shows up in your chat, and the terminal shows “sent” as confirmation.

---

Setting up Discord with Claude Code (15 minutes)

Discord takes slightly longer because of its OAuth flow (a permission-granting process where you authorize the bot to access your server), but the process is straightforward.

Step 1: Create a Discord bot

1. Go to the Discord Developer Portal

2. Click “New Application” and name it

3. Go to the Bot section

4. Create a username, reset the token, and copy it

5. Enable “Message Content Intent” under Privileged Gateway Intents (this is easy to miss)

Step 2: Invite the bot to your server

1. Go to OAuth2 > URL Generator

2. Select the bot scope

3. Enable these permissions:

   • View Channels

   • Send Messages

   • Send Messages in Threads

   • Read Message History

   • Attach Files

   • Add Reactions

4. Open the generated URL to invite the bot

---

FREE n8n Full Course: Zero to Hero in AI Automation

---

Step 3: Install and configure

/plugin install discord@claude-plugins-official
/discord:configure <your-bot-token>

Step 4: Restart, pair and lock it

bash
claude --channels plugin:discord@claude-plugins-official

DM your bot on Discord. It replies with a pairing code.

Run /discord:access pair <code> in Claude Code, then lock it down with /discord:access policy allowlist.

---

Running multiple Claude Code Channels simultaneously

You can enable multiple channels in a single session:

bash
claude --channels plugin:telegram@claude-plugins-official plugin:discord@claude-plugins-official

Claude sees all incoming messages regardless of source. A Telegram message and a Discord message arrive the same way - as channel events. Claude processes them and replies through the correct channel automatically.

---

Getting one Claude Code channel working takes over an hour of reading docs, tweaking JSON, and triple-checking channel IDs. Switch to a different project next month and that clock resets.

PluggedIn includes pre-wired config templates and a 12-prompt notification pack so the next setup takes minutes, not an hour.

---

How do you build a custom Channel in Claude Code?

The official plugins cover chat platforms. But the real power is custom channels - connecting any system that can send HTTP requests.

Here’s a webhook receiver that forwards GitHub events, CI alerts, or any HTTP POST to Claude Code:

Set up the project

Initialize your project (if you don’t already have a package.json) and install the MCP SDK:

bash
bun init -y

Then install the dependency:

bash
bun add @modelcontextprotocol/sdk

The server code

Create a file called webhook-channel.ts in your new project/folder:

typescript
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

const server = new Server(
  { name: "webhook-channel", version: "1.0.0" },
  {
    capabilities: {
      experimental: {
        "claude/channel": {}
      }
    },
    instructions: "You receive webhook events from external systems. Triage each event and summarize what happened. For critical events (build failures, security alerts), flag them clearly."
  }
);

// Connect to Claude Code over stdio
const transport = new StdioServerTransport();
await server.connect(transport);

// HTTP listener for webhooks
const httpServer = Bun.serve({
  port: 9090,
  async fetch(req) {
    if (req.method !== "POST") {
      return new Response("POST only", { status: 405 });
    }

    const body = await req.json();

    // Push event to Claude Code
    await server.notification({
      method: "notifications/claude/channel",
      params: {
        content: JSON.stringify(body, null, 2),
        meta: {
          origin: req.headers.get("x-source") || "webhook",
          timestamp: new Date().toISOString()
        }
      }
    });

    return new Response("OK", { status: 200 });
  }
});

console.error(`Webhook listener on port ${httpServer.port}`);

Register in .mcp.json

json
{
  "mcpServers": {
    "webhook-channel": {
      "type": "stdio",
      "command": "bun",
      "args": ["run", "./webhook-channel.ts"]
    }
  }
}

Test with curl

Start Claude Code with the development flag (required for custom channels during preview):

bash
claude --dangerously-load-development-channels server:webhook-channel

Then from another terminal:

bash
curl -X POST http://localhost:9090 \
  -H "Content-Type: application/json" \
  -H "x-source: github" \
  -d '{"event": "push", "repo": "my-project", "branch": "main", "commits": 3}'

Claude receives the event as a tagged message in the session:

xml
<channel source="webhook-channel" origin="github" timestamp="2026-03-20T14:30:00Z">
{"event": "push", "repo": "my-project", "branch": "main", "commits": 3}
</channel>

The instructions field in the server config tells Claude how to handle incoming events - triage, summarize, or take action. Each meta entry becomes an attribute on the <channel> tag. Keys must be identifiers (letters, digits, underscores only) - keys with hyphens are silently dropped.

---

How do you make Channels two-way?

One-way channels (push events to Claude) are useful for monitoring. Two-way channels (Claude can respond back) unlock real conversations.

To make a channel two-way, expose a standard MCP tool:

typescript
import {
  ListToolsRequestSchema,
  CallToolRequestSchema
} from "@modelcontextprotocol/sdk/types.js";

// Enable tool discovery
const server = new Server(
  { name: "my-channel", version: "1.0.0" },
  {
    capabilities: {
      experimental: { "claude/channel": {} },
      tools: {}  // This enables tool listing
    },
    instructions: "You can reply to messages using the send_reply tool."
  }
);

// Register the reply tool
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [{
    name: "send_reply",
    description: "Send a reply back through the channel",
    inputSchema: {
      type: "object",
      properties: {
        message: { type: "string", description: "The reply text" },
        recipient: { type: "string", description: "Who to reply to" }
      },
      required: ["message"]
    }
  }]
}));

// Handle reply calls from Claude
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  if (request.params.name === "send_reply") {
    const { message, recipient } = request.params.arguments;

    // Send via your platform's API (Telegram, Slack, email, etc.)
    await sendToExternalPlatform(recipient, message);

    return {
      content: [{ type: "text", text: `Reply sent to ${recipient}` }]
    };
  }
});

Claude automatically discovers the reply tool and uses it when it determines a response is needed. You control where the reply goes - Telegram, Slack, email, a database, anywhere.

---

How do you secure Claude Code Channels?

Every channel maintains a sender allowlist. Only approved IDs can push messages into your Claude Code session. This is non-negotiable.

Why it matters: Without an allowlist, anyone who discovers your bot or webhook URL can inject prompts into your Claude Code session. The allowlist is what makes channels safe to use in real workflows.

The official Telegram and Discord plugins handle this with the pairing process:

1. You send a message to the bot

2. Bot generates a one-time pairing code

3. You enter the code in Claude Code

4. Your platform ID is added to the allowlist

For custom channels, you must implement allowlist validation yourself:

typescript
const ALLOWED_SENDERS = new Set(["user123", "ci-bot-token"]);

// In your webhook handler
async fetch(req) {
  const sender = req.headers.get("x-sender-id");

  if (!ALLOWED_SENDERS.has(sender)) {
    return new Response("Unauthorized", { status: 403 });
  }

  // Forward to Claude...
}

Important security note from the community:

One Reddit user flagged the concurrent instruction race. What happens when your desktop session and Telegram are both active with potentially contradictory instructions? This is a real edge case.

Channels don’t create separate sessions. They push into the same session. If you’re actively working in the terminal and a Telegram message arrives, Claude handles both in sequence. Keep this in mind if multiple people have access to your bot.

1. Gate on sender identity, not chat identity: The docs are specific about this. In group chats, message.from.id differs from message.chat.id. If you gate on the room, anyone in an allowlisted group can inject messages. Always gate on the sender.

2. Enterprise controls: On Team and Enterprise plans, the channelsEnabled setting in managed settings controls whether channels are available at all. Pro/Max users can opt-in freely with --channels. Team/Enterprise admins must explicitly enable it.

---

How do Claude Code Channels compare to OpenClaw?

If you followed our OpenClaw series, you know OpenClaw does something similar - it connects AI to messaging platforms like WhatsApp and Discord. Some are calling Channels an “OpenClaw killer.” Here’s what I think after testing both.

Quick OpenClaw backstory if you missed it:

OpenClaw started as “Clawdbot” by Austrian developer Peter Steinberger in November 2025. A personal project to automate his email and calendar. It hit over 145,000 GitHub stars within weeks after OpenAI backed it. Anthropic sent a cease-and-desist over the original name (it was “Clawd,” too close to Claude).

Steinberger was later hired by OpenAI. The irony of Anthropic now shipping the feature that made OpenClaw popular is not lost on anyone.

Where Claude Code Channels win over OpenClaw

• Zero deployment: Runs on your laptop. No Hetzner server, no Docker, no VPN tunnels. OpenClaw requires a dedicated server setup that took us 60 minutes in Article 2 of our OpenClaw series.

• Built-in security: Sender allowlists, pairing process, enterprise controls baked in. OpenClaw’s security model is... still evolving (remember the 341 malicious skills in ClawdHub?).

• Your existing tools: Channels plug into your Claude Code session with all your MCP servers, hooks, agents, and skills intact. Everything we built in Lessons 1-6 works through channels automatically. OpenClaw starts from scratch.

• No hardware tax: BentoBoi nailed this one. Developers were buying Mac Minis and renting Hetzner VPS instances solely to run OpenClaw 24/7. Channels run wherever Claude Code runs - your existing laptop.

• Official support: Anthropic maintains the channel protocol and plugins. The community can build connectors for Slack or WhatsApp themselves using MCP, and submit them for security review.

Where OpenClaw still wins:

• Always-on by design: OpenClaw runs monitoring loops every 30 minutes on a server. Channels require Claude Code to be running in a terminal or background process. Close the lid, lose the connection.

• WhatsApp and iMessage: OpenClaw supports WhatsApp, iMessage, SMS, Slack, Signal, and Teams. Channels currently ship with Telegram and Discord only (custom channels can bridge anything else, but you build them yourself).

• Proactive scheduling: OpenClaw’s cron-like loops trigger actions without any external event. Channels are reactive - they need something to push an event first. You can work around this with a cron job that POSTs to a webhook channel, but it’s not native.

• Multi-model: OpenClaw is model-agnostic - Claude, GPT-4, Gemini, even open-source models like Kimi K2.5. Channels are Claude Code only, which means Anthropic ecosystem only.

• Persistent memory: OpenClaw remembers context across weeks. Claude Code resets between sessions (though CLAUDE.md and the memory system from Lesson 2 close this gap significantly).

• Cost structure: OpenClaw is free - you only pay for the API calls. Claude Code requires a Pro/Max subscription ($20+/month) on top of any API costs.

The bottom line

• If you’re already in the Claude Code ecosystem (which you are, if you’ve followed this series), Channels give you 80% of what OpenClaw offers with 20% of the setup complexity.

• If you need always-on autonomous agents with multi-model support across every messaging platform, OpenClaw still has an edge.

But Anthropic shipped texting, thousands of MCP skills, and autonomous bug-fixing in four weeks. That gap is closing fast.

---

When to use Channels vs OpenClaw vs n8n

I have been playing with all three tools lately Claude Code, OpenClaw and n8n. Here is what I can tell so far. These are three tools, three different jobs:

Claude Code with Channels

Use when you need an AI that understands your codebase to react to external events.

• A CI build fails and you want Claude to diagnose it using your project context

• You’re away from your desk and want to trigger an SEO audit via Telegram

• A teammate asks a question about the codebase through Discord

The key: Channels are reactive and context-aware. Something happens, Claude responds using everything it knows about your project.

OpenClaw

Use when the next step depends on what the agent discovers autonomously.

• Reading your inbox every 30 minutes and surfacing emails that need replies

• Monitoring competitor newsletters and flagging content relevant to your niche

• Following up on leads based on their specific situation and history

The key: OpenClaw is proactive and autonomous. No trigger needed. It runs loops, makes decisions, and acts on what it finds.

n8n

Use when the steps are fixed and repeatable.

• Send a welcome email when someone subscribes

• Post to social media on a fixed schedule

• Sync data between Notion, Google Sheets, and your CRM every hour

• Multiply one article across 7 platforms with the same workflow every time

The key: n8n is deterministic and cheap. If you can draw the workflow as a flowchart, n8n runs it faster and at a fraction of the cost. No AI reasoning needed for fixed paths.

The decision framework: If the steps are known in advance, use n8n - it’s cheaper and more reliable. If the agent needs to decide the next step based on what it finds, use OpenClaw. If you need your AI coding partner to respond to external events while staying connected to your project, use Channels.

Community channels already building

The official plugins are Telegram and Discord, but the community isn’t waiting for Anthropic to ship everything:

• claude-code-telegram - remote Claude Code access from anywhere via Telegram

• claude-code-discord - Discord bot wrapper for Claude Code sessions

Because channels are built on MCP (the same open standard that powers all of Claude Code’s tool connections), anyone can build a channel for Slack, WhatsApp, Teams, or any platform with an API. The protocol is open. The plugins are on GitHub. Anthropic reviews and approves community submissions for the official allowlist.

Claude Code is proprietary, but MCP is open source (donated to the Linux Foundation’s Agentic AI Foundation in December 2025). You get the reliability of a tier-one AI provider with the extensibility of an open ecosystem.

---

Practical workflows: 3 setups I will be running now

Here are three workflows practical use cases of Claude Code Channels that I’m running / building right now:

1. CI/CD triage bot

My GitHub Actions webhook posts to a local channel. When a build fails, Claude reads the error log, identifies the likely cause, and sends a Telegram message: “Build failed on main. The Playwright test for /checkout timed out - likely the same flaky selector from last week. Want me to fix it?”

2. Content calendar alerts

A cron job checks my Notion calendar every morning and POSTs to my channel with today’s publishing schedule. Claude reviews the queue, checks if drafts are ready, and sends a Telegram or Discord summary: “2 posts scheduled today. Post 115 is finalized. Post 116 is missing the hero image - want me to generate one?”

3. Remote control from phone

This is the simplest and most useful. I’m away from my desk, I message Claude on Telegram: “Run the SEO audit on the latest draft and tell me the score.” Claude runs the audit using all my configured tools and replies with the results. No SSH. No VPN. A text message.

I will update the findings and results over next week of running these.

---

What do you do when Channels don’t connect?

Channel doesn’t start

Check claude --version is 2.1.80+. Channels require claude.ai auth, not API keys.

No messages arriving

Verify the plugin is loaded with /plugins. Check that you passed --channels on startup. Without the flag, channels are disabled even if the plugin is installed.

Pairing code doesn’t work

Codes are one-time use. If it fails, send another message to the bot and get a fresh code.

Custom channel not loading

During the research preview, custom channels need --dangerously-load-development-channels. The official allowlist only includes Anthropic-maintained plugins.

Messages arrive but Claude doesn’t respond

Check if your sender ID is on the allowlist. Run /telegram:access list or /discord:access list to verify.

Enterprise: channels flag ignored

Admin must enable channelsEnabled: true in managed settings. This is separate from installing the plugin.

“Channels are not currently available” error

This is the most reported issue on Reddit. Check three things: (1) you’re on claude.ai auth, not API billing, (2) your Claude Code version is 2.1.80+, (3) if you’re on Team/Enterprise, admin has enabled channelsEnabled. API usage billing does NOT work with channels - this locks out some enterprise users.

Session drops after 30 minutes

Multiple users report this with Remote Control, and some see it with channels too. Running Claude Code in a persistent terminal (tmux or screen) helps. For always-on setups, consider running on a VPS or keeping your machine awake.

Example always-on Telegram setup for Claude Code Channels

# Install tmux first if not done already
brew install tmux

# Start a named tmux session in your project directory
tmux new -s claude-channels

# Run Claude Code inside your project
claude --channels plugin:telegram@claude-plugins-official

# Press Ctrl+B, then D to detach                                            
# Close terminal, walk away, session keeps running 
# Everything can happen through Telegram from now on for this project

# Reattach only when you want to - not because you have to
tmux attach -s claude-channels

---

What you learned in this lesson

• Channels are MCP servers that push external events into a running Claude Code session

• Two patterns: chat platforms (poll external APIs) and webhooks (listen on HTTP ports)

• Official plugins cover Telegram and Discord with built-in security

• Custom channels let you connect any system via the MCP protocol

• Two-way communication works by exposing a reply tool

• Security is handled through sender allowlists - never skip this

• Channels vs. OpenClaw: less setup, better security, but not yet always-on

---

Want to Skip the Copy-Paste-Debug Loop?

You just wired up Claude Code to send real messages to Telegram, Discord, or a webhook endpoint. That probably took a solid hour of reading docs, tweaking JSON, and triple-checking your channel IDs.

Good - you understand how it works now. But next time you need to do this (different project, different channel, different hook), you don’t need to start from zero.

Included in your paid subscription:

• Claude Code Channel Config Templates - Pre-wired .clauderc and hook config files for Telegram, Discord, and generic webhooks. Drop in your token and channel ID, done.

• Notification Prompt Pack - 12 ready-to-use prompts for common Claude Code events (task complete, error caught, approval needed, build finished). Copy into your hooks, customize the message text, ship it.

• Multi-Channel Routing Cheatsheet - Quick reference for routing different event types to different destinations (errors → DM, completions → team channel, webhooks → Slack). Saves the “wait, which config does what?” confusion.

You spent the hard hour understanding the mechanics. These assets are for every hour after that - when you’re setting up a new project at 11pm and just want it to work.

If you’re already paid, these are waiting in the lesson downloads below. If not, this is what the upgrade unlocks.

---

Get PluggedIn

You already paid the one-hour setup tax on Claude Code Channels. Stop paying it on every project after this.

See what's included →

Without the templates, every new channel setup costs another hour of reading the same docs from scratch.

Get PluggedIn to go from re-debugging JSON configs each time you wire up a new project to dropping in a pre-built config, swapping your token, and shipping in minutes

Related reading: Build a competitive-analysis AI agent