M
MCP Directory CURATED DIRECTORY
911 MCP servers indexed
中文
← Back to directory
W

WhatsApp Channel for Claude Code

Community
Drive your Claude Code session straight from WhatsApp
How to install ↓ Compare GitHub source repository ↗
Category
Collaboration #2 of 55
Stars
★ 109 Popular
Transport
stdio (local process)
Runtime
Bun
Credentials
No credential needed
License
Apache-2.0
Last commit
Tools
10
64FMRS · C

A community-built WhatsApp channel plugin, reviewed and published to the Anthropic Official Plugin Marketplace (the repo describes it as the first community WhatsApp channel plugin reviewed and published by Anthropic). It links a personal WhatsApp account as a linked device with no API keys, Docker, or WhatsApp Business API. It is most complete inside Claude Code, where inbound messages can wake the session as channel notifications; on other MCP clients it degrades to polling. It suits individual developers who are fine configuring from a terminal and value local privacy, but not teams needing official hosting, multiple instances, or a compliance-grade enterprise channel. Note that only one linked session per account is allowed, and approval commands stay terminal-only by design for safety.

Strongest · Documentation 16/20 Weakest · Reliability 10/20

Reliability
10/20
Security and permissions
12/20
Maintenance
12/20
Documentation
16/20
Setup experience
14/20
Why each score
Reliability 10/20
Static evidence is limited to the README: it describes a stdio MCP server, a single Bun process, and a tool list (reply/react/edit_message/download_attachment/status/unreplied/catch_up/list_groups), plus an extensive troubleshooting table (440 disconnect, singleton connection, dropped channel notifications, Claude Code client bug #37933). This shows awareness of failure modes and diagnosable errors (diag.log, WHATSAPP_DIAG_DEBUG), but the manifest is not cached, no committed tests or CI workflows are provided, so declared tool behavior, clean startup, and the MCP init/tool-list handshake cannot be verified. Capped at 12 by the static calibration; scored 10: happy path plausible and error handling described in detail, but reproducibility evidence is missing.
Security and permissions 12/20
Security intent is visible: approving access always requires the specific pairing code (guarding against prompt-injected 'approve the pending one'), access.ts is deliberately not exposed as an MCP tool, runtime state (auth, allowlists, group configs, inbox) lives in ~/.whatsapp-channel rather than the repo, no API keys or third-party relay servers are claimed, and Apache-2.0 plus SECURITY.md provide disclosure channels. Deductions: the permission chain rests on a single WhatsApp linked device, Claude sends as the user's own number (identity confusion / mis-send risk), the README requires the dangerous --dangerously-load-development-channels flag, and tool approval via emoji reaction is a weak confirmation for high-risk actions. Credential storage encryption, log privacy, and outbound network boundaries are unverifiable without source. No red-line issue (no malware, theft, covert exfiltration), hence 12 rather than 0-4.
Maintenance 12/20
Maintenance signals: explicit Apache-2.0 license, copyright attribution, CONTRIBUTING.md and SECURITY.md (private disclosure), marketplace publication badge and screenshot, 87 stars, 0 open issues, actively maintained docs and troubleshooting. Missing: verifiable release history, versioning policy, dependency update path; zero open issues says nothing about response capability; no cached manifest or source to confirm commit cadence. Evidence is insufficient for a high score, so 12.
Documentation 16/20
The strongest dimension. Layered install steps (marketplace add + install + pairing code flow), full config examples for other MCP clients (Codex CLI, Gemini CLI, Cursor), absolute-path and timeout guidance, terminal equivalents for access control, one-time voice-transcription setup, a symptom-driven troubleshooting table with log files and debug env vars, explicit disclosure of the one-client-per-account constraint, and pointers to USAGE.md. Deductions: key behaviors (channel notifications, single client, terminal-only setup) are scattered as asides rather than a consolidated limits list; cost and privacy data-flow details are not disclosed; USAGE.md content is not supplied so consistency with the README is unverifiable. Scored 16.
Setup experience 14/20
Setup path is reasonably clear: three commands to install the plugin, pairing via a phone-number code, no Meta developer account or API key required; stdio config snippets for Codex CLI, Gemini CLI, and Cursor plus timeout recommendations (startup_timeout_sec 30, tool_timeout_sec 120). Platform constraints are explicit: requires Bun and voice transcription is Apple Silicon only (mlx-whisper). Friction is notable: the dangerous --dangerously-load-development-channels flag is currently the only way and --channels is not supported, non-Claude-Code clients need manual absolute paths and are poll-based (no push), and setup must be done from a terminal. Capped at 15 by static calibration; scored 14.

Static review · not runListed 2026-09-10

Read the FMRS scoring method →

Fit and risk

What it can accessUses the networkChanges third-party account data

Best for

  • Individuals who want to talk to Claude from their personal WhatsApp number
  • Developers comfortable configuring from a terminal and using the Claude Code development flag
  • Automation scenarios needing remote tool approval from a phone

Not for

  • Compliance scenarios requiring the official WhatsApp Business API or a Meta developer account
  • Teams needing officially hosted, multi-tenant, or cloud multi-instance deployment
  • Environments unable to guarantee only one client instance at a time
  • Users expecting voice transcription without setting up mlx-whisper themselves

Required permissions

  • Read and send WhatsApp messages as your personal number
  • Access the local runtime state directory ~/.whatsapp-channel/ (auth, allowlists, group configs, inbox)
  • Read and write local repository files and run scripts (e.g. bun scripts/access.ts, scripts/watchdog.sh)
  • Optional local voice transcription (ffmpeg and an mlx-whisper environment)

Risks and side effects

  • Messages Claude sends appear from your own number and are indistinguishable to recipients
  • WhatsApp allows one linked-device session per account; running two servers makes them kick each other off
  • Access-control commands are deliberately not MCP tools (terminal-only); exposing them to the message side risks prompt injection
  • Session waking depends on the Claude Code channel extension; other clients get no push
  • A known Claude Code client bug (#37933) may cause messages not to arrive, a client-side issue
  • Launching with --dangerously-load-development-channels carries risk, so verify the source is trustworthy

Setup

Before you start

Runtime：Bun

Other optional settings (1)
WHATSAPP_DIAG_DEBUG optional Set to 1 to log Baileys' full debug stream for diagnosing inbound/outbound message issues; not required.

Option 1 (Claude Code plugin): run claude plugin marketplace add Rich627/whatsapp-claude-plugin, then claude plugin install whatsapp-channel@whatsapp-claude-plugin, then launch with claude --dangerously-load-development-channels plugin:whatsapp-channel@whatsapp-claude-plugin (this flag registers the plugin as a channel; without it tools load but new messages do not wake the session). Inside the session run /whatsapp-channel:configure <phone> (country code + number, no +); a pairing code is printed on first launch. On your phone: WhatsApp → Settings → Linked Devices → Link a Device → Link with phone number instead → enter the code. Option 2 (other MCP clients): register the stdio server with an absolute path, e.g. Codex CLI's ~/.codex/config.toml, Gemini CLI's ~/.gemini/settings.json, or Cursor's mcp.json, using command bun and args run --cwd /absolute/path/to/whatsapp-channel start, with generous timeouts (e.g. startup_timeout_sec 30, tool_timeout_sec 120).

.mcp.json 
{
  "mcpServers": {
    "whatsapp": {
      "type": "stdio",
      "command": "bun",
      "args": ["run", "--cwd", "/absolute/path/to/whatsapp-channel", "start"]
    }
  }
}

Shown for Claude Code. Other clients may use a different file or key (VS Code uses "servers") — the configurator below converts it.

.vscode/mcp.json
{
  "servers": {
    "whatsapp": {
      "type": "stdio",
      "command": "bun",
      "args": [
        "run",
        "--cwd",
        "/absolute/path/to/whatsapp-channel",
        "start"
      ]
    }
  }
}

Goes in your project's .vscode/mcp.json (VS Code uses a "servers" key).

Terminal
claude mcp add whatsapp -- bun run --cwd /absolute/path/to/whatsapp-channel start

Run it in a terminal; replace any <…> placeholders with your own values first.

Generate and validate client config

Check that it works

Start the session and call the status tool — it should report the linked-device connection. On first launch a pairing code is printed; enter it under WhatsApp → Linked Devices → Link with phone number instead.

Troubleshooting

  1. Pairing code not showing: run /whatsapp-channel:configure <phone> first, then relaunch
  2. 440 disconnect error: only one connection per auth state is allowed; kill stale processes with pkill -f "whatsapp.*server"
  3. Session not waking on new messages: usually launched without --dangerously-load-development-channels plugin:whatsapp-channel@whatsapp-claude-plugin; check the MCP debug log for Channel notifications skipped
  4. Messages not arriving: may relate to Claude Code client bug #37933; server-side is correct
  5. Replies send but nothing arrives: send a DM as well as a group message; check ~/.whatsapp-channel/diag.log for inbound upsert lines and set WHATSAPP_DIAG_DEBUG=1 for Baileys' full debug stream
  6. Auth expired: run /whatsapp-channel:configure reset-auth and re-pair
  7. No push in other clients: poll with wait_for_messages, catch_up, or unreplied

Things to try

Once connected, you can ask your AI assistant things like:

  • Check the WhatsApp connection status
  • Show me any unreplied messages
  • Reply to that number with a short message
  • List my WhatsApp groups

Tools 10

reply writes
Send a message to a chat, with chunking and optional @-mentions.
react writes
Add an emoji reaction to a message (also used for permission approve/deny).
edit_message writes
Edit a previously sent message.
download_attachment read-only
Download a received media attachment.
status read-only
Report server and connection status.
unreplied read-only
List unreplied messages and their count.
catch_up read-only
Replay recent two-way conversation, unreplied counts, and open tasks after a restart.
list_groups read-only
List available groups.
Show 2 more tools
wait_for_messages read-only
Poll for the next message, waiting up to about 40 seconds.
whatsapp_unavailable read-only
The single tool served when another process holds the connection, naming the process that holds it.

Use cases

Drive a Claude Code session with natural language from WhatsApp
Transcribe incoming voice notes and hand the text to Claude
Approve or deny Claude's tool calls from a phone via emoji reaction
Give each group its own personality and conversation memory
Schedule recurring server-side tasks in a group's config.md
Gate incoming messages with pairing codes and allowlists

Supported clients

Claude Code
CodexPartial support
Gemini CLIPartial support
CursorPartial support

Listed from the project's documentation, not tested by this site.

Overview

WhatsApp Channel for Claude Code is an MCP server that connects to WhatsApp as a linked device (the same protocol as WhatsApp Web, via Baileys) and exposes it to Claude Code as a channel. Incoming messages reach the session in real time, and Claude replies from your own number so recipients see a normal chat. Everything runs locally on your machine; messages travel directly between WhatsApp and your session with no third-party servers in between. Once paired it keeps working while your phone is off — only the Claude Code session needs to stay open, and reconnects never require re-pairing. It is a plain stdio MCP server any MCP client can run, though inbound waking relies on the Claude Code notifications/claude/channel extension; elsewhere it is poll-based.

Similar servers

Compare with other MCP servers

Source revision 135227cf6f51 Data synced 2026-10-19 Read the FMRS scoring method