logo
03

Connect Messaging Platforms

⏱️ 30 min

Connecting Messaging Platforms

"Which platform should I connect first after installing OpenClaw?" — this question gets asked to death in the Discord.

My advice is simple: for teams in China, go with Feishu or DingTalk. For personal use, Telegram. Least hassle. OpenClaw supports 22+ messaging platforms, but there's no reason to connect them all at once. Get one working first. I got greedy and tried connecting three at once — mixed up the configs and spent an entire evening debugging. Felt pretty stupid afterwards.

Supported Platforms

Main platforms: Telegram (uses grammY library, simplest, recommended for beginners), Discord (discord.js, popular with developers and gaming communities), Feishu (Feishu API, top choice for Chinese teams), WhatsApp (Baileys, personal users), Slack (Bolt, overseas teams), WeCom (WeCom API), DingTalk (DingTalk SDK).

Second tier: Signal (bridged via signal-cli), iMessage (two options — BlueBubbles is the currently recommended approach, there's also a legacy mode that's no longer actively promoted), Google Chat, Microsoft Teams, Matrix (decentralized protocol, privacy advocates love it), LINE, IRC, Nostr (decentralized social protocol, popular in crypto circles), Twitch (livestream chat interaction), QQ. These are all supported but trickier to configure. For example, iMessage via BlueBubbles requires a Mac running 24/7 as a bridge — that alone stops a lot of people. Fewer community members can help you troubleshoot, so you need to be comfortable figuring things out yourself.

Why Telegram? Three words: dead simple. Creating a Bot doesn't require enterprise verification. Five minutes tops. It's what I picked for my first platform last December.

Step 1: Create a Bot. Search for @BotFather on Telegram, send /newbot, follow the prompts to set a name and username, grab the Bot Token (looks like: 110201543:AAHdqTcvCH1vGWJxfSeofSAs0K5PALDsaw). Nobody should get stuck on this step...

Step 2: Configure OpenClaw.

openclaw channels add telegram
# Enter your Bot Token

Or edit the config file directly:

// ~/.openclaw/openclaw.json (JSON5 format, supports comments)
{
	channels: {
		telegram: {
			enabled: true,
			token: 'YOUR_BOT_TOKEN'
		}
	}
}

Step 3: Verify. Find your Bot on Telegram and send any message. OpenClaw should reply. No response? Check openclaw logs first — nine times out of ten it's a wrong Token or the Gateway isn't running.

You can also test via command line without manually opening Telegram:

openclaw message send telegram --to "@your_bot" --text "Test message"

Super handy during debugging — no window-switching needed.

Discord

  1. Go to Discord Developer Portal, click New Application, set the name
  2. Select Bot → Add Bot on the left, copy the Token
  3. You must enable Message Content Intent — the official docs mention this in tiny print, but without it the Bot can't read message content. I got stuck on this for ages before figuring out it was this toggle
  4. In OAuth2 > URL Generator, check bot under Scopes, check Send Messages and Read Message History under Permissions
  5. Use the generated URL to invite the Bot to your server

Then configure:

openclaw channels add discord
# Enter Bot Token

Feishu

Feishu integration is more involved than Telegram — you need to create a Feishu app with several steps.

  1. Go to Feishu Open Platform, create an enterprise custom app
  2. Add the Bot capability
  3. Get the App ID and App Secret
  4. Configure the Event Subscription URL: http://your-server:18789/webhook/feishu

Configure OpenClaw:

openclaw channels add feishu

Config file looks like:

// ~/.openclaw/openclaw.json
{
	channels: {
		feishu: {
			enabled: true,
			appId: 'YOUR_APP_ID',
			appSecret: 'YOUR_APP_SECRET',
			verificationToken: 'YOUR_TOKEN'
		}
	}
}

One gotcha: Feishu needs a publicly accessible URL to receive event callbacks — this trips up a lot of people. For local development, use Tailscale Funnel or ngrok for tunneling. If callbacks aren't coming through, don't immediately blame OpenClaw for bugs. It's almost certainly the tunneling tool misconfigured. Someone in the community spent two days on Feishu integration only to discover their ngrok free-tier URL had expired without them noticing.

Finally, publish the app in the Feishu admin console. Team members can then chat with the Bot.

WhatsApp

WhatsApp connects differently — it links your account via QR code:

openclaw channels login whatsapp

The terminal displays a QR code. Scan it with WhatsApp (Settings → Linked Devices).

Security configuration is critical here. After WhatsApp connects, messages from strangers trigger the Pairing security mechanism:

# View pending pairing requests
openclaw pairing list whatsapp

# Approve a specific pairing code
openclaw pairing approve whatsapp <code>

Make sure Pairing is on. Otherwise anyone who messages you gets an AI response. Someone in the Discord supposedly had their AI auto-reply to an ex at 3 AM because they didn't enable this... probably an urban legend, but the point stands.

Slack

openclaw channels add slack

Requires creating a Slack App (api.slack.com/apps), installing it to a Workspace, getting the Bot Token (xoxb- prefix), then configuring Event Subscriptions. Similar flow to Feishu — also needs a public URL for callbacks.

Multi-Platform Connections

OpenClaw can connect multiple platforms simultaneously. All messages converge into the same Agent, sharing context and skills. You can even connect multiple accounts on the same platform — say you have two Telegram Bots, one internal and one public. Use the accounts config:

// ~/.openclaw/openclaw.json
{
	channels: {
		telegram: {
			enabled: true,
			accounts: [
				{ name: 'internal-bot', token: 'BOT_TOKEN_1' },
				{ name: 'public-bot', token: 'BOT_TOKEN_2' }
			]
		},
		discord: { enabled: true, token: '...' },
		feishu: { enabled: true, appId: '...', appSecret: '...' }
	}
}

The "multi-platform convergence" design is genuinely impressive. Whether you ask a question on Feishu or Telegram, the context carries over — as long as you're using the same Agent. Multi-account setups are common in the community. Companies run one Bot in the dev Slack channel, another in the support channel — separate contexts but shared skill set underneath.

Group Chat Activation Mode

After adding a Bot to a group, there's an important setting — activation mode. Default is mention mode, meaning @Bot to trigger a reply:

/activation mention    # Only responds when @Bot'd (default, recommended for groups)
/activation always     # Responds to every message (for small groups or dedicated channels)

Be careful with always mode in large groups. Every message gets a reply — token costs spike, and group members get annoyed by the spam. A friend turned on always mode in a 200-person Discord server. Burned $40 in API costs overnight. His face the next morning was priceless.

Conversation Model

OpenClaw's conversation model: in DMs, one user gets one main session. Straightforward. In group chats, the default is group-isolated session — each group has its own independent context. What's discussed in Group A doesn't leak to Group B. Smart design. Cross-group context mixing would be chaos.

Which Platform to Pick?

Just starting out? Telegram. No contest. Chinese team collaboration? Feishu, DingTalk, or WeCom. Overseas teams? Slack or Discord. Personal private assistant? Consider WhatsApp or iMessage. Developer communities mostly use Discord.

Stop overthinking which one to pick. You can always add more later. Just get something running.

Chat Commands Reference

Once connected, these commands work on any platform:

  • /status — Check Agent status
  • /new — Start new conversation
  • /reset — Reset context
  • /compact — Compress conversation history (super useful when context gets long, I use this almost daily)
  • /think <level> — Adjust reasoning depth
  • /verbose — Toggle verbose mode
  • /usage — Check token usage
  • /activation <mode> — Switch group chat activation mode (mention/always)

FAQ

Q: Telegram Bot doesn't reply?

Run openclaw status to check if it's running, verify the Bot Token is correct, then check openclaw logs. Most of the time it's a wrong Token or Gateway not started. Embarrassingly simple problem but incredibly common.

Q: Feishu event callbacks not received?

Make sure the server has a public IP or tunneling is configured. Check the event subscription URL in Feishu's Open Platform. Also, Feishu has a verification process — the first time you configure a URL, it sends a challenge request you need to respond to. Miss this step and nothing else works.

Q: Can I use it on phone and computer at the same time?

No problem. Messaging platforms already support multiple devices natively. OpenClaw handles everything on its end — no conflict.

Q: Can't connect to the Gateway?

First confirm the Gateway Control Plane is running — it listens on ws://127.0.0.1:18789 by default. openclaw status shows the Gateway state. If the port is taken, change it in openclaw.json. There's also openclaw doctor for a quick scan of common config issues including port conflicts, Token format, and permissions.

With platforms connected, your AI assistant now has "ears and a mouth." But it's not smart enough yet — next, configure LLM providers to give it a better "brain."