whatsapp-assistant-mcp
This MCP server lets an agent read and post in a fixed allowlist of WhatsApp chats through a background daemon that holds the single WhatsApp connection.
List allowlisted chats (
list_chats) — returns jid, display name,canPostflag, and a recent-activity count; never shows other chats.Read stored messages (
read_chat_messages) — fetches the last N (default 30, max 500) messages for one allowlisted chat from the local inbox log, oldest first, working even if WhatsApp is temporarily unreachable.Send text messages (
send_chat_message) — posts one text message to an allowlisted chat withcanPost: true; the daemon sends it and the call waits up to 15s for delivery confirmation. Messages are immediate and cannot be unsent.Poll for new messages (
poll_chats) — drains messages that arrived since the last call, grouped by chat jid, with a persisted read position so each message is returned exactly once.
All operations are gated by the chat allowlist, and sending is per-chat and one message per call — there is no bulk or broadcast path.
Allows an AI agent to read and send messages in a fixed allowlist of WhatsApp chats, including listing chats, reading chat history, sending text messages, and polling for new messages.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@whatsapp-assistant-mcp Check my WhatsApp for unread messages from the family group and summarize them."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
whatsapp-assistant-mcp
A stdio MCP server that lets a Claude Code agent read and post in a fixed allowlist of WhatsApp chats.
A stdio MCP server plus a small background daemon that holds the actual WhatsApp connection. A strict chat allowlist is the only thing standing between "an agent with a WhatsApp connection" and "an agent that can message anyone," and it is a startup error to run without one. Same design lineage as its Microsoft Teams sibling -- see Related project.
Plain JS, ESM, no build step. Node 20+.
Why
Allowlist-first safety -- every tool call and every inbound message is checked against a fixed chat allowlist before anything else happens. An empty or missing allowlist is a startup error, never "allow everything."
One WhatsApp connection, ever -- Baileys (the WhatsApp library this project uses) refuses a second simultaneous connection on the same auth session, so exactly one process (
wa-daemon) is ever allowed to hold it; everything else talks to that process, never to WhatsApp directly.A file-based inbox/outbox protocol -- the MCP server and the daemon are separate processes that never share memory. They hand messages to each other through append-only JSONL files (
inbox.jsonl,outbox.jsonl), so either side can restart independently without losing state.A mechanical signature, not a suggestion -- every outgoing message is prefixed with a robot marker (🤖) before it leaves the daemon, so on a shared or personal account, anyone reading the chat can tell a message came from the assistant, not the human.
Related MCP server: WhatsApp Channel
Quickstart
Requires Node.js 20+.
git clone https://github.com/Agentic-Delivery/whatsapp-assistant-mcp.git
cd whatsapp-assistant-mcp
npm ci1. Pair
Prefer a code instead of scanning a QR:
node src/pair.js --code 15551234567 # international format, digits onlyor scan the printed QR code with WhatsApp: Settings > Linked Devices > Link a Device:
node src/pair.jsOn success this prints PAIRED as <jid> and exits. Auth state is saved under
~/.whatsapp-assistant/auth/ (chmod 700). See Troubleshooting if
the code seems to hang for a moment, or the connection closes and reopens right after --
both are normal.
2. Create the allowlist
mkdir -p ~/.whatsapp-assistant
cp wa-mcp.config.example.json ~/.whatsapp-assistant/wa-mcp.config.jsonEdit it and replace the placeholder jids with real ones -- individual chats end in
@s.whatsapp.net, groups end in @g.us. canPost defaults to (and should stay)
false until you mean it.
canRead defaults to true. Set "canRead": false to make a chat write-only: the agent
can post to it but its messages are never stored in inbox.jsonl, never downloaded, and no read
tool returns them (read_chat_messages refuses it, poll_chats and list_chats leave it out).
Use it for a channel the agent must report into but must not read, such as an operator's alert
group shared with other conversations. Both flags must be real booleans when present ("false" as a
string is refused), and a chat with both false is refused at startup. The daemon picks up a
canRead change in the config without a restart (it re-checks the file on the next incoming
message); a change to canPost takes effect for sending after a restart. A reply that quotes a
message from a chat the agent may not read keeps the quoted message's id but not its text
(replyToTextWithheld: true). Both wa-daemon and wa-mcp refuse to do anything useful
with an empty or missing allowlist.
3. Run the daemon
nohup node src/daemon.js >> ~/.whatsapp-assistant/daemon.out.log 2>&1 &It reconnects automatically on drops. If the session gets logged out (revoked from the
phone, etc.) it exits and tells you to delete the auth directory and re-pair. See
Autostart to run it as a proper service instead of nohup.
4. Register the MCP server
Run this from inside your clone, so the path resolves to wherever you actually put it -- never hardcode a home directory:
claude mcp add whatsapp-assistant -- node "$(pwd)/src/mcp-server.js"Autostart
To have wa-daemon survive reboots and terminal closures, run it as a systemd user
service instead of nohup.
~/.config/systemd/user/wa-daemon.service:
[Unit]
Description=whatsapp-assistant-mcp background daemon
After=network-online.target
Wants=network-online.target
[Service]
Type=simple
WorkingDirectory=%h/whatsapp-assistant-mcp
ExecStart=/usr/bin/env node src/daemon.js
Restart=on-failure
RestartSec=5
[Install]
WantedBy=default.target%h expands to your home directory. If you cloned this repo somewhere other than
directly under $HOME, edit WorkingDirectory to match your actual path first. Then:
systemctl --user daemon-reload
systemctl --user enable --now wa-daemon.service
loginctl enable-linger "$USER" # keep it running after you log outWhatever the daemon prints is kept by the service manager (the journal), so the daemon
prints text only. The Signal library underneath reports session changes by printing whole
session records, private keys included; the daemon and wa-pair replace every printed object
except an error's stack text with [object omitted] and keep the message
(src/console-redact.js). If you ran an earlier version as a service, your journal may hold
such records (check with journalctl --user -u wa-daemon | grep -c 'Closing session'). The
journal cannot delete one service's entries; they expire with your journald retention settings,
and clearing them early (sudo journalctl --rotate --vacuum-time=1s) deletes the logs of every
service on the machine. Treat those keys as exposed: remove the device under WhatsApp > Linked
Devices and run wa-pair again.
Under WSL, user services need systemd turned on first. Add to /etc/wsl.conf:
[boot]
systemd=truethen restart WSL (wsl --shutdown, from Windows) before the systemctl --user
commands above will work.
Architecture
WhatsApp (Baileys, exactly one socket)
|
v
+--------------+
| wa-daemon |----- creds.json + keys, atomic tmp+rename writes
+--------------+ ~/.whatsapp-assistant/auth/
| ^
append watch + drain
v |
inbox.jsonl outbox.jsonl
^ |
| v
+--------------+
| wa-mcp | <-- stdio --> Claude Code / any MCP client
+--------------+Baileys refuses a second simultaneous connection on the same auth session, so exactly
one process -- wa-daemon -- is ever allowed to hold it. wa-mcp never opens its own
connection: it reads inbox.jsonl for history (which keeps working even while WhatsApp
is briefly unreachable) and hands off sends to the daemon through outbox.jsonl,
waiting for an acknowledgement.
This isn't just a "the library says so" rule. A second process racing the first for the
same session doesn't just fail to connect -- it can corrupt creds.json mid-write,
which is a real failure class this project hit during development and has since closed
by construction: see src/atomic-auth.js. Every auth-state write
goes through a temp-file-then-rename on the same directory, so a crash at any instant
leaves either the fully-old file or the fully-new one, never a half-written one. A
session lock held by a process that's no longer alive is detected and taken over
automatically; a lock held by a live process is refused rather than raced.
Verified sends
Every send/send-file/send-image/send-video/send-voice ack is echo-verified: WhatsApp reflects each sent
message back to the daemon, and that echo is exactly what recipients receive. The
ack therefore reports what arrived, not what was attempted — verified: {fileName, mimetype, bytes} for documents (the echo must carry a file name, a real
mimetype and the exact byte count, else ok:false with the reason), verified: {mimetype, bytes} for images, verified: {ptt, mimetype, bytes, seconds} for voice
notes (the echo must be a voice note, not a plain audio file), and verified: {text:true}
for text. If no echo arrives within the timeout (default 15 s,
echoTimeoutMs per command) the ack stays ok:true with verified:null and a
warning: echo-timeout — a slow echo never fails a real send, but an unverified
delivery is always visible as such.
Sending files and images
send_chat_document sends a file as a document; send_chat_image sends a PNG or
JPEG as an image message, so it shows inline in the chat (a screenshot, a rendered
design); send_chat_video sends an MP4 as a video message, so it plays inline
instead of arriving as a file to download. All use the same allowlist and canPost
gate and the same echo-verified ack as text; send_chat_voice_note sends a voice note. The MCP server checks every file before writing anything to the
outbox, and the daemon checks it again before sending (this applies to raw
send-file commands too):
the path is absolute and points to a non-empty file readable by the daemon's user (the daemon reads it, not the MCP server);
documents need an accepted extension, because the recipient's client opens the file by it:
.pdf .docx .xlsx .pptx .md .txt .csv .json .html .png .jpg .jpeg .gif .webp .zip .mp4 .mov .webm .mp3 .m4a .wav; images must be.png,.jpgor.jpeg(the type is taken from the extension, not by inspecting the bytes);voice notes must be Ogg/Opus
.oggfiles (like images, the type is taken from the extension, not by inspecting the bytes); convert withffmpeg -i in.wav -c:a libopus -b:a 32k -ac 1 out.ogg; a voice note has no caption, so the agent marker cannot be stamped on it, and the recording itself should make clear it comes from an assistant;videos must be
.mp4(H.264 video with AAC audio plays on every client); convert withffmpeg -i in.mov -c:v libx264 -pix_fmt yuv420p -c:a aac -movflags +faststart out.mp4, or send other containers as a document. The ack isok:falseif the echo is not a video message (a video that arrives as a document is a failed send). Withffmpegandffprobeon the daemon'sPATHthe recipient sees a preview frame and the length before playing (WA_FFPROBEpoints at another ffprobe); without them the video is still sent. A systemd user unit does not inherit your shell'sPATH, so setEnvironment=PATH=...there if ffmpeg lives in, for example,~/.local/bin;limits: 100 MB for documents, 64 MB for videos, 16 MB for images and voice notes;
nothing inside the bridge's own state directory (
~/.whatsapp-assistant: auth keys, inbox, outbox, downloads) can be sent, symlinks included, so a manipulated request cannot send the account's session keys out. To forward a downloaded file, copy it elsewhere first.
The raw outbox commands, for scripts that run next to the daemon:
Command | Shape |
send a text |
|
send a document |
|
send an image |
|
send a video |
|
send a voice note |
|
edit the text of one of this account's own messages |
|
delete one of this account's own messages for everyone |
|
show or stop "typing…" |
|
mark messages read (blue ticks) |
|
read marks the listed messages read in one call. In a group each message's sender is
taken from participants ({msgId: senderJid}) or else from the message's record in
inbox.jsonl; an id whose sender is unknown is listed in the ack's errors and not marked.
It acks ok:true, read:[ids], obeys the allowlist and canPost, and leaves typing alone.
quote: {msgId, participant?, fromMe?, text?} sends the text as a WhatsApp reply to that
message (in a group, participant is the quoted message's sender; text only fills the
preview). The ack is the same as for any text.
typing with on:true shows "typing…" in the chat and keeps it up (refreshed every 10 s)
until on:false or 600 s, then the chat shows paused. It is meant to cover a whole turn: a
message sent to that chat pauses it just before the message and resumes it afterwards. It acks ok:true, typing:<on> and obeys the allowlist and canPost.
edit replaces the text of a message this account sent (msgId is the id from that
message's ack); it never targets anyone else's message. The new text gets the agent marker
like any text. It is acked like send: ok:true, msgId:<id of the edit>, edited:<msgId>, verified:{text}. WhatsApp only accepts edits for about 15 minutes after sending. The bridge
does not enforce that: when the original's record in inbox.jsonl is older, the ack carries
warning: "edit-window: ..."; when WhatsApp answers the edit with an error, the ack is
ok:false with an error that names the code. An edit past the window that WhatsApp
accepts without an error may still not show for recipients. It obeys the allowlist and canPost.
delete can only remove a message this account sent; it never touches anyone else's.
Its ack (ok:true, deleted: <msgId>) means the revoke was sent, not that the id
belonged to one of this account's messages; an id that was not ours is a no-op.
Receiving files
Incoming documents, images, videos, audio files and voice notes from allowlisted
chats are downloaded to ~/.whatsapp-assistant/downloads/<timestamp>-<filename> (a
document keeps its sanitized name -- it is untrusted remote input -- while other media
is named by type, such as image.png, video.mp4 or audio.mp3). Voice notes go to
their own folder, downloads/voice-notes/<timestamp>-voice-note.ogg. Size caps: 200 MB for videos, 25 MB for everything else. A saved
voice note can be transcribed by the bridge itself when speech is configured (see "Speech
(optional)" below), or by an agent with any tool it likes.
Each download adds a media-saved line to inbox.jsonl carrying mediaPath, beside the ordinary
[document: name] message record; oversize or failed downloads add a
media-skipped / media-error line instead, so an absent file is always
explained. The allowlist gates downloads exactly as it gates the inbox:
messages from non-allowlisted chats are neither stored nor downloaded.
Speech (optional)
The bridge can turn incoming voice notes into text and speak text back as voice notes. Both run locally with open models -- no API keys -- and both are off until you configure them.
1. Install the default engines (Python 3.10 to 3.12 -- Kokoro does not support 3.13 yet -- and ffmpeg):
python3 -m venv ~/.wa-speech
~/.wa-speech/bin/pip install -r tools/requirements-speech.txtTranscription uses faster-whisper and runs on a GPU when one is usable, otherwise on the CPU. Speaking uses Kokoro, which runs on a normal CPU. The first run of each downloads its model.
2. Add a speech block to the config (use absolute paths):
"speech": {
"transcribe": ["/path/to/.wa-speech/bin/python", "/path/to/whatsapp-assistant-mcp/tools/transcribe.py", "{input}"],
"speak": ["/path/to/.wa-speech/bin/python", "/path/to/whatsapp-assistant-mcp/tools/speak.py",
"--text-file", "{textFile}", "--output", "{output}"]
}Restart the daemon and the MCP server after changing the config.
Transcribe: every saved voice note is passed to the command as
{input}; whatever it prints becomes atype: "transcript"record ininbox.jsonl(withtextandmediaPath) and a.txtnext to the audio.poll_chatsdelivers transcripts like messages. If the command fails, atranscript-errorrecord says why. Only real voice notes are transcribed (never a document, whatever its name), one at a time, each with a 5-minute limit. A voice note still waiting when the daemon stops is not transcribed later; its audio stays saved. Options:--model(defaultsmall;large-v3-turbois more accurate),--languages en,defor the languages you expect: when a short clip's language is unsure it is tried in each of them (slower), and the transcript is prefixed[uncertain]because a very short or unclear clip can come out as a phrase nobody said; a longer clip detected outside the list is transcribed in the first one.Speak:
speak_voice_notewrites the text to{textFile}, runs the command, and sends the Ogg/Opus file it wrote to{output}as a voice note; the audio is deleted after sending. Options:--voice(defaultaf_heart) and--lang(aAmerican English,bBritish English). The default install speaks English; Kokoro's other languages need extra packages (see its README). Each voice note is made in a private temp folder that is deleted afterwards, also when the command fails or times out.
Any other engine works too: the commands are plain programs run without a shell, so point
transcribe or speak at your own script, as long as it keeps the same placeholders.
Retention
Saved voice notes are recordings of people's voices, which is personal data. An optional
retention block in the config makes the daemon delete them at startup and every hour:
"retention": { "voiceNoteDays": 30, "voiceNoteMaxMB": 200 }Only downloads/voice-notes/ is pruned, and only files named
<timestamp>-voice-note.<audio extension> (regular files; links and folders are skipped).
Voice notes older than voiceNoteDays are deleted first, then the oldest ones until the
rest fit in voiceNoteMaxMB. Transcripts next to them (*.txt, *.srt, ... -- including
the ones the bridge writes when speech is configured) and the transcript records in
inbox.jsonl are kept: they are personal data too, so delete them yourself if you do not
need them. Every other download is left alone. Each deletion is logged to daemon.log by file name. Without
a retention block nothing is ever deleted.
Tools
Tool | What it does |
| Allowlisted chats with jid, name, |
| Last N stored messages for one allowlisted chat, oldest first -- read from the local inbox log, not a live fetch |
| Sends a text message via the daemon and waits up to 15s for delivery confirmation; requires |
| Messages that arrived since the last call, grouped by chat jid; the read position is persisted, so each message is returned exactly once |
| Sends a file as a document, with an optional caption, and waits for the echo-verified ack; requires |
| Sends a PNG or JPEG as an inline image message, with an optional caption, and waits for the echo-verified ack; requires |
| Sends an MP4 as an inline video message, with an optional caption, and waits for the echo-verified ack; requires |
| Sends an Ogg/Opus |
| Speaks text (at most 2000 characters, |
| Puts an emoji reaction on one message (or removes it with an empty emoji) via the daemon and waits for its ack; requires |
Every tool validates the jid against the allowlist before touching anything else. An
unknown jid is refused with an error naming the config file; sending additionally
requires canPost: true. There is no bulk-send or broadcast tool -- one call sends one
message to one chat.
Reactions
A reaction is the cheapest signal both directions, and this bridge treats it as a first-class record and command.
Inbound. A reaction someone puts on a message arrives in inbox.jsonl as a record
of type: "reaction" with reaction.emoji and reaction.targetMsgId, so an agent can
see that a message was acknowledged without anyone typing.
Outbound. react_to_message (or a raw {"type":"react", "jid", "nonce", "msgId", "emoji", "participant?", "fromMe?"} line in outbox.jsonl) makes the daemon put the
emoji on the target message and ack with reacted: {target, emoji}. In a group the
target's sender jid goes in participant; an empty emoji removes the reaction.
A convention that works. When an agent handles messages from real people, react before or instead of replying, and keep the vocabulary tiny so the meaning is stable:
Emoji | Meaning |
👀 | Seen, being handled |
👍 | Acknowledged, no action needed |
✅ | Done |
A reaction never replaces an answer that was asked for; it tells the human the message did not fall on the floor while the answer is being produced.
Channel inbox (optional)
For a runner that serves several chat platforms through one file, the daemon can also write
every inbound human message as a platform-neutral line v1 (one JSON object per line). Off
unless set; the native inbox.jsonl is unchanged either way.
Variable | Effect |
| Appends one v1 line per message from a readable allowlisted chat that is not ours and has text (a voice note's transcript counts): |
| With |
A message with media is written once its download is done, and a voice note once its transcript is ready (or has failed), so each message is one line.
Each message line also carries addressed (boolean, always written), which says whether the
message is meant for this account:
truein a 1:1 chat;truein a group when it @-mentions this account, by phone-number jid or by LID (both of the connection's own ids,sock.user.idandsock.user.lid, device suffix ignored);truein a group when it quotes a message from this account: the quote's participant is one of those ids, or the quoted message id is one this account sent during this daemon run. The number may be shared with people on other clients; their messages arrive as ours, so a quote of one of them counts as addressed too;falseotherwise (a group message with no mention, a reply to another person, a mention of someone else).
Where information is missing it errs to true, because a missed question costs more than an
extra receipt: before the connection knows its own ids, any mention or quote counts as
addressed, and so does a quote that names no participant and whose id is not known. The list of
sent ids lives in memory only, so after a restart the participant check carries the quote rule
alone. A reader that does not know the field treats a line as addressed, which is what older
lines without it mean.
/status (optional)
With "statusFile" in wa-mcp.config.json (an absolute path to the factory runner's status.txt; status.json beside it gives the report's time) a message whose whole text is /status (any case, surrounding spaces ignored) from a sender on "statusUsers" (person jids; being in the chat is not enough, and with no list /status is off and the daemon logs it) in an allowlisted chat with canPost:true is answered at once by the daemon itself, at most once per chat per 60 s, with no model turn: a quoted reply carrying the runner's report, signed like every agent message. The reply is the shared report plus only the factory's open questions asked in this chat (status.json waiting, chatId wa:<jid>), never another chat's. An answered /status is written to neither inbox.jsonl nor the channel inbox; one from anyone else goes on as an ordinary message. A report older than "statusMaxAgeMinutes" (default 5) reads "Status unavailable: the factory's last report is N minutes old"; a report that says the factory is offline is shown however old. The report is the runner's (vd-server status_report): runner state and the customer's backlog only, never a task's own text.
Troubleshooting
Four failure modes came up repeatedly during development. All four are already handled by the code -- this section explains what you're seeing and why it's fine.
A pairing code seems to hang for a few seconds. --code only requests a pairing
code once the socket signals it's ready, and only after presenting a real desktop
browser signature -- WhatsApp's server closes the connection immediately if it sees the
library's default signature on this flow. A short pause here is that handshake
completing, not a hang.
The connection closes with status 515 right after you enter the code (or scan the
QR), then immediately reconnects. This is expected: it's WhatsApp's own protocol
telling the client "pairing configured, restart the connection now," not a failure.
wa-pair and wa-daemon both honor it automatically, bounded to a few restarts so a
genuine connection flap can't loop forever.
"Another WhatsApp process (pid N) holds the session -- refusing a second
connection." Exactly one process may ever hold the Baileys auth session. Check ps
for a stray node process before assuming anything is broken -- a previous wa-daemon
or wa-pair may still be running. If the holder is no longer alive, the next attempt
clears the stale lock automatically. The lock lives at
~/.whatsapp-assistant/session.lock.
A torn or empty auth/creds.json. Historically, a process exiting mid-write could
truncate this file; the next reader would see "unregistered" and attempt to re-pair,
which invalidates the real phone link. This is now prevented by construction (see
Architecture) -- every auth write goes tmp-then-rename, so the file is
never observed half-written. If you somehow still end up with an empty or corrupt
creds.json, treat it like a real logout: delete ~/.whatsapp-assistant/auth and run
wa-pair again.
"Not paired (creds absent or unregistered). Run 'node src/pair.js --code
' first." You'll see this from wa-daemon (or anything other than
wa-pair) when there's no valid paired session yet. Registration is deliberately
wa-pair's job alone -- any other entry point that finds unregistered auth state stops
rather than trying to register itself, because a blind registration attempt from the
wrong place is exactly what invalidates a real phone link when state was lost or torn.
Run wa-pair first, then start the daemon.
Security & Terms of Service
Auth keys and the message store live only under
~/.whatsapp-assistant(directorychmod 700, files written0600) -- never inside this repo, never committed. Treat that directory like a credential: anyone who can read it can act as your WhatsApp account.The chat allowlist in
wa-mcp.config.jsonis the blast-radius control. It is deliberately a startup error to run with an empty one. Only add chats you actually want an agent to read from or post into, and leavecanPostoff until you mean it.This tool never bulk-sends. There is no broadcast tool and no batch-send path -- every send is one explicit call to one chat.
Automating a personal WhatsApp account through this consumer protocol is against WhatsApp's Terms of Service. Use a dedicated number you're prepared to lose, or accept that risk knowingly -- this project does not make that call for you.
Related project
teams-assistant-mcp is the
Microsoft Teams sibling of this project: same design lineage -- a fixed chat allowlist
as the only blast-radius control, a single background process holding the one real
connection, and no bulk-send path.
License
Elastic License 2.0. Free to use, copy, modify, and adapt for your own organization, including commercially. You may not sell it or offer it to others as a hosted or managed product.
Available Tools
4 toolslist_chatsList allowed WhatsApp chatsARead-only
Lists the WhatsApp chats this server may touch: jid, display name, whether sending is allowed (canPost), and a lightweight recent-activity count. Never lists any other chat.
Inputs: no named parameters.
poll_chatsPoll for new WhatsApp messagesARead-only
Drains messages that arrived since the last poll_chats call, grouped by chat jid. The read position is persisted, so each message is returned exactly once across calls.
Inputs: no named parameters.
read_chat_messagesRead WhatsApp chat messagesARead-only
Reads the last N stored messages for one allowlisted chat, oldest first. Messages come from the local inbox log, not a live WhatsApp fetch, so this works even when WhatsApp is briefly unreachable.
Inputs: jid (required), limit.
send_chat_messageSend a WhatsApp chat messageA
Sends a text message to an allowlisted chat that has canPost enabled. Handed off to the background daemon -- the only process holding the WhatsApp connection -- and waits up to 15s for delivery confirmation. Real people read this immediately; it cannot be unsent.
Inputs: jid (required), text (required).
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose: listing chats, reading stored message history, sending a new message, and polling for newly arrived messages. The one potential overlap between read_chat_messages and poll_chats is resolved by their explicit focus on historical versus incremental messages.
All four tool names follow the same verb_noun snake_case pattern: list_chats, read_chat_messages, send_chat_message, and poll_chats. There are no mixed conventions or inconsistent verb styles.
Four tools is a well-scoped size for a WhatsApp assistant: list, read, send, and poll cover the core needs without unnecessary redundancy. Each tool earns its place.
The toolset covers the main assistant workflow: discovering conversations, reading previous messages, sending replies, and receiving new messages. It lacks richer operations like media sending, message search, or read receipts, but those are reasonable omissions for this focused server.
Maintenance
Related MCP Connectors
WhatsMCP connects Claude and other MCP-compatible AI agents directly to WhatsApp. Send and receive text, images, documents, and voice notes; manage groups (create, add/remove members, promote admins); look up contacts and profiles; follow channels; and read call and message history — all through a standard MCP interface. For voice use cases, WhatsMCP offers SIP-based calling plans (inbound-only, or full inbound/outbound) so AI voice agents can answer and place WhatsApp calls, plus low-latency WebSocket integrations with voice agent providers like ElevenLabs. Multiple WhatsApp accounts can be paired and managed per workspace, with webhook support for real-time inbound message delivery to your own infrastructure.
Free WhatsApp MCP server for ChatGPT and Claude: read and search chats, every send you approve.
Ask questions across your WhatsApp inbox from Claude, ChatGPT, Cursor or any MCP client.
Your own WhatsApp in Claude and ChatGPT: read chats, draft replies, send messages you approve.
Related MCP Servers
- AlicenseNot gradedqualityDmaintenanceGives Claude Desktop read-only access to your WhatsApp chats and message history via a local MCP server.4MIT
- FlicenseNot gradedqualityAmaintenanceEnables a Claude Code session to send and receive WhatsApp messages from a linked personal account or the official Cloud API, including photos, voice notes and documents, with local voice transcription and allowlist-based access control. It also lets users approve or deny Claude's tool requests remotely by emoji reaction and keeps per-chat personalities, cron jobs and conversation context across restarts.-
- FlicenseNot gradedqualityAmaintenanceConnects a Claude Code (or any MCP) session to a WhatsApp account as a linked device or via Meta's official Cloud API, enabling bidirectional chats, group support, media exchange, local voice-note transcription, and scheduled tasks. Inbound messages are gated by pairing codes, allowlists and per-group policies, and Claude's tool permission requests can be approved or denied remotely with an emoji reaction.-
- FlicenseNot gradedqualityAmaintenanceRuns a plain stdio MCP server that lets a Claude Code session send and receive chat messages from a linked phone number or official business account, including media, voice-note transcription, chunked long replies, and @-mentions. Inbound messages can wake the session, and gated access through pairing codes, allowlists and group policies lets only trusted contacts reach it, with tool-permission prompts approvable remotely by emoji reaction.-