wazap-mcp
wazap-mcp links your own WhatsApp account as a device and exposes 23 MCP tools so an AI assistant can read, search, catch up on, and send/manage WhatsApp chats locally with confirmation for writes.
Link/check accounts with QR or phone pairing code; inspect connection, sync and status.
List/read chats and messages, including stories; page history; wait for new messages.
Catch up across accounts: waiting asks, mentions, calls, groups and stories within a token budget.
Search messages by meaning and words with context; fetch full message details, reactions, poll votes and receipts.
Find/list contacts, resolve names/nicknames/tags, inspect group info and participants.
Get media and voice-note transcripts, save files, and use kept copies.
Keep local notes/tags/fields about people; mark asks handled; hide #private/#no-catchup contacts.
Draft messages/media/polls/locations/forwards; confirm to send once; schedule for later.
Edit, react to, or delete messages; manage chats via archive, pin, mute, star, clear, block, etc.
Manage groups: create/join, members, settings, invite links, join requests, leave.
List/cancel scheduled messages and set/list/cancel local reminders.
Run locally over stdio or HTTP, with read-only mode, multiple accounts, webhooks, remote access, and no wazap cloud dependency.
Provides tools for interacting with a linked WhatsApp account, enabling management of chats, messages, media, contacts, and groups, including sending messages, searching history, downloading media, and administering group settings.
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., "@wazap-mcp what did I miss on WhatsApp today?"
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 for your AI agent.
wazap is an MCP server for your own WhatsApp account. It links as a device, the way WhatsApp Web does, keeps what it sees on your machine, and gives any MCP client — Claude, ChatGPT, Gemini, Cursor, Codex — 23 tools over your chats, messages, media, contacts and groups.
You stop opening WhatsApp to find things and ask instead:
"What did I miss on WhatsApp today?" — one answer across every linked account: who is waiting on you, mentions, missed calls, busy groups condensed.
"Find the invoice Dan sent in spring." — search by meaning and by words at once, then open the file.
"What did the voice note from mama say?" — voice notes come back as text.
"Tell Ana I'll be twenty minutes late." — you see the recipient and the exact words first. Nothing leaves until you say yes.
No browser, no business account, no third-party service. There is no wazap cloud: it runs where you run it.
Get started
You need Node.js 22.16+ on the 22 line, or 24+, and a phone with WhatsApp.
npx wazap-mcp setupsetup links your account, finds the MCP clients installed on this machine
(Claude Code, Claude Desktop, Cursor, Codex, Gemini CLI), writes their config,
installs the five skills where the client reads them, and tells you what to
restart. Then ask your assistant: "what did I miss on WhatsApp today?"
Rather let your agent do it? Paste this into it:
Set up WhatsApp for me: run
npx wazap-mcp setup --agentand follow what it prints.
npx wazap-mcp on its own, in a terminal, starts nothing: it prints where you
stand and the next command. When something is off, npx wazap-mcp status is
the first thing to run; it prints a fix next to anything broken.
Per client
Client | Fastest path |
Claude Code |
|
Claude Desktop | download |
Cursor | the badge below, then |
Codex CLI |
|
Gemini CLI |
|
claude.ai, ChatGPT, other hosted agents | a URL they sign in to with OAuth: see Remote access |
Anything else | command |

The hand-written entry, for any client that takes the usual JSON:
{
"mcpServers": {
"whatsapp": { "command": "npx", "args": ["-y", "wazap-mcp"] }
}
}Every step setup takes, each file connect writes, and upgrading are in
docs/install.md.
Related MCP server: wa-bridge
Linking your account
Linking is a one-time step. setup does it for you; on its own it is:
npx wazap-mcp login # QR code: Settings → Linked devices → Link a device
npx wazap-mcp login --phone +15550100 # pairing code instead, no camera neededWith --phone, wazap prints an 8-character code. On the phone, go to
WhatsApp → Settings → Linked devices → Link a device → Link with phone number
instead and type it in. The pairing code works over SSH and on a headless
server, where a QR is impractical.
An assistant can link the account itself, too: the link_account tool returns
the same code, so a Claude Desktop user never needs a terminal.
Several WhatsApp accounts can live in one wazap (wazap account add <id>, then
wazap login --account <id>); see docs/accounts.md.
The 23 tools
What every argument means, and every error code, is in
docs/tools.md. The assistant gets it from learn, one topic at a time (ids, workflows, errors), when it needs it.
Tool | Kind | What it does |
| read | The guide by topic: id formats and several accounts, the workflows, every error code with its fix. Called when unsure, not first. |
| read | Connection, sync, linked accounts, how fresh the history is, webhook delivery, versions. |
| read | Link an account from the assistant; returns the 8-character code to type into the phone. |
| read | Conversations newest-first: |
| read | One chat, paging back into the phone's history; |
| read | "What did I miss?" across every account, in one call and within a token budget. |
| read | Messages by meaning and by words at once, narrowed by chat, sender or date. |
| read | One message in full: its quote, reactions and who left them, poll votes, delivery and read receipts. |
| read | Who "mama", a nickname, a group name or a number means, before anything is drafted. |
| read | The phone's address book a page at a time: saved name, number, when you last talked. |
| read | Participants, admins, group settings, the invite link for an admin. |
| read | A voice note as its transcript, a photo as an image, a video as a contact sheet, a document as its text, for one message or up to eight at once; a local session also saves the file. Served from the copy kept on arrival first. |
| read | Block up to 55 s until a message arrives, with a cursor so nothing is missed between calls. |
| local | A note, tags or details about a person, kept on this machine. Nothing changes on WhatsApp. |
| write | Draft a message, media, poll, location or forward — and send nothing. |
| write | Send that draft, once, after the user has seen the preview and said yes; a draft for later is scheduled. |
| write | Edit your own message, within WhatsApp's 15-minute window. |
| write | Add or remove an emoji reaction. |
| write | Delete for everyone (your own message, or anyone's in a group you admin), or only on this account. |
| write | Preview archive, pin, mute, star, clear, delete, block and undo actions; confirm the preview to apply once. |
| write | Create, join, rename, add, remove, promote, invite links, join requests, settings, leave. |
| write | List the scheduled messages (sent, missed, failed too) or cancel one before it goes. |
| local | "Remind me if Ana has not answered in 2 days": set, list or cancel; posted to your webhook when due. |
Scheduled messages and reminders. send_message with send_at ("tomorrow
at 9" as 2026-10-12T09:00 in Europe/Bucharest) drafts a message for later;
the user's yes to that preview, time included, schedules it, and every send
check runs again when it goes. One wazap could not send within 15 minutes of
its time is reported as missed, never sent late. reminder keeps "remind me if
Ana has not answered in 2 days" and posts it to your webhook when due. Both
survive restarts; see Scheduling a message
and Reminders.
Two features are off by default and can run entirely on your machine:
voice transcription with whisper.cpp (docs/voice.md) and
semantic recall, so search matches meaning and not only words
(docs/recall.md). Turn them on with
wazap config transcribe local and wazap config recall local.
Skills
Tools say what is possible; the five Agent Skills in
skills/ say how to do the job well.
Skill | What the agent does |
| Triage: needs you / FYI / noise, plus replies you forgot. Read-only. |
| Find an address, an invoice, a photo, a thing someone said. Read-only. |
| Catch up on a busy group: decisions, dates, what is asked of you. Read-only. |
| Find who you mean, draft in the chat's own tone, show it, send on a yes. |
| Diagnose, link or repair the connection. |
setup installs them for Claude Code, Codex and Cursor
(npx wazap-mcp skills install <harness> does it by hand). Every other client
gets the same five as MCP prompts from the server, with nothing to install.
Transports
stdio is the default: the client starts npx -y wazap-mcp and talks to it
over stdin/stdout. Nothing listens on the network.
HTTP (Streamable HTTP) is for a server that outlives the client, or one another machine reaches:
npx wazap-mcp serve --http # http://127.0.0.1:8766/mcp, health at /healthz--host/--port (or WAZAP_HOST/WAZAP_PORT) move it. wazap refuses to bind
anything but loopback without WAZAP_READ_TOKEN. Clients authenticate with a
static bearer token (WAZAP_READ_TOKEN, plus WAZAP_WRITE_TOKEN for the write
tools) or with OAuth 2.1, which wazap serves itself. Details in
docs/self-host.md.
Remote access
Two commands keep wazap running and reachable from hosted agents:
npx wazap-mcp service install # a launchd agent (macOS) or systemd user unit (Linux)
npx wazap-mcp expose # a public https URL through Tailscale Funnel or Cloudflare Tunnelexpose prints the URL and a consent password. Give the agent only the URL;
it registers itself, and the consent page asks you for the password and
whether that agent may only read or also send. See
Keep it running.
The service recovers by itself: a dropped link is retried with backoff, a
watchdog replaces a socket that went dead across a sleep or stopped answering,
and when reconnecting keeps failing wazap exits so launchd or systemd starts it
fresh. The linked session is never deleted for any of that; only WhatsApp
unlinking the device needs a new link. An agent's MCP session outlives those
restarts and its daily token rotation too: its next call is simply served,
and answers travel gzip-compressed to every client that accepts it
(HTTP mode). Set WAZAP_WEBHOOK_EVENTS to include
alert to be told when the link has been down for 5 minutes, when it is back,
and when it needs linking again (Link alerts);
get_status shows the same under link.
Deployment
On a server of your own, the session never leaves it. With Docker (images for
amd64 and arm64 at ghcr.io/razvangirgiz/wazap):
mkdir wazap && cd wazap
curl -fsSLO https://raw.githubusercontent.com/razvangirgiz/wazap/main/docker-compose.yml
printf 'WAZAP_READ_TOKEN=%s\nWAZAP_WRITE_TOKEN=%s\n' $(openssl rand -hex 32) $(openssl rand -hex 32) > .env
docker compose run --rm wazap login --phone +15550100 # once; the session lands in the volume
docker compose up -d
curl -s http://127.0.0.1:8766/healthzThe container publishes port 8766 on loopback only; put TLS in front
(deploy/Caddyfile is two lines). A systemd unit is in
deploy/wazap.service. Both setups, reverse-proxy
trust and the OAuth server are in docs/self-host.md.
Calling wazap from your own product, and receiving signed webhooks for incoming
messages, is in docs/api-and-webhooks.md.
Configuration
Every setting is optional. They are environment variables, read from the
process or from ~/.wazap/.env (a real environment variable wins, a flag wins
over both). You rarely edit them by hand: wazap config shows the effective
settings and changes one.
Setting | Default | What it does |
|
| Where credentials, databases and models live ( |
| unset |
|
|
|
|
|
| Where |
| unset | Static bearer tokens for HTTP; only the write token gets the write tools. |
| unset | Both together turn on OAuth for hosted agents. |
|
|
|
|
|
|
|
|
|
|
| Which chats' media is downloaded on arrival and kept, so |
The full list, including the webhook filters, kept-media limits, retention and proxy trust, is in
docs/settings.md; .env.example is the
same list as a commented file.
Security and privacy
Nothing is sent without a yes.
send_messageonly drafts: it returns the recipient and the exact text and touches no network. Onlyconfirm_sendsends, and a draft goes out at most once, even across a crash. Draft-then- confirm is a workflow, not proof of consent: an agent can call both tools unless your client makes you approve the second one.Read-only is a real switch. With
WAZAP_READ_ONLY=1,--read-onlyorwazap config writes off, the write tools are not registered, so the assistant cannot message anyone even by mistake. The Claude Desktop bundle ships with read-only ticked.Recipients can be pinned.
wazap config send allow +15550100,…limits an account to a list,denyrefuses the ones named; both are checked at draft and again at send (docs/send-rules.md).Writes are rate limited, 20 a minute per account by default, because sending faster than a human is how numbers get banned.
Your data stays on your machine. Credentials, messages, media and notes live in
~/.wazap(0700, credential files0600). No account, no telemetry. What leaves the machine: WhatsApp traffic; the npm registry, for the version check; Hugging Face, when you download a transcription or embedding model; a transcription API, only if you choseopenai; your own webhook, if you set one (docs/data.md).Some people can be kept out. Tag a contact
#privateand their words stay out of everything the assistant did not ask about them by name, and out of the webhook.#no-catchupkeeps their chat out ofcatch_up.What it does not do. No bulk send, no scheduler, no campaigns. It never marks anything read on its own, and sends text without link previews, so nothing fetches the pages you link.
Threat model, findings and the limits of each of these: docs/security-audit.md.
Known limitations
The protocol is unofficial. wazap is built on Baileys, a reverse-engineered implementation of WhatsApp's multi-device protocol. It is not the WhatsApp Business API and Meta does not support it. A protocol change can break wazap until Baileys catches up, and an account that sends in bulk or to people who did not ask can be restricted or banned. The safeguards above reduce that risk; they do not remove it, and the risk is yours.
Model behaviour is measured on Claude only. The evaluation in
eval/(58 cases, each run three times) has been run on Claude. Other clients get the same tools and the same server-side guards, but nobody has measured how their models use them. The manual protocol for ChatGPT iseval/chatgpt-protocol.md.History is what the phone syncs to a linked device, not your whole archive.
read_messageswithbeforeasks the phone for more, within what WhatsApp still keeps.Old media expires. WhatsApp drops old attachments from its servers;
get_mediathen returnsMEDIA_UNAVAILABLE, unless wazap kept a copy when it arrived. By default it keeps the photos, voice notes, audio and documents of unmuted chats, up to 16 MB each, 1 GB in all and 90 days, whilewazap serveruns; media that arrived and expired while nothing was keeping it cannot be brought back.Names come from the phone's address book, which WhatsApp only sends to a fresh connection. If contacts read as numbers (
contacts_named: 0inget_status),wazap contacts resyncasks again while no server runs.@lidids. Newer accounts are addressed by a privacy id; wazap maps it back to a number when it has learned the mapping.Calls are WhatsApp calls only, and a call that starts and ends while wazap is stopped may be missing. Cellular calls are never visible.
The phone must stay reachable. A linked device stops receiving once the phone has been offline too long;
get_statussays so.
What the 1.x line promises not to break is in docs/stability.md.
Documentation
| |
The 23 tools in full, the workflows, every error code | |
Several WhatsApp accounts, several MCP clients on one server | |
Voice notes as text: whisper.cpp locally, or an OpenAI-compatible API | |
Semantic search with a local embedding model | |
The data directory, | |
Read-only mode, per-account send rules, rate limits | |
HTTP mode, systemd, Docker, tunnels, proxy trust, OAuth | |
Static tokens in, signed webhook events out | |
Every | |
The security audit | |
What 1.0 promises to keep stable | |
Release by release |
Contributing
git clone https://github.com/razvangirgiz/wazap && cd wazap
npm ci
npm run check # lint, typecheck, then build and test
node test/smoke-stdio.mjs # drives the built binary over MCP stdio
npm run dev -- status # run from source with tsxThe tests need no WhatsApp account. CLAUDE.md is the contributor's map: layout, the rules that must never break, and the release procedure. Issues and pull requests are welcome at github.com/razvangirgiz/wazap.
License
MIT © Răzvan Girgiz
Available Tools
23 toolscatch_upCatch up on what the user missedARead-only
What the user missed, all accounts, within budget_tokens: waiting (every open ask of 14 days, whatever the window), mentions, calls, people, groups, stories. account_id narrows it to one account; get_status names them. The mark moves first; a lost answer is since: "previous". more.cursor: the rest.
Inputs: ids, hours, since, cursor, +3 more. Returns: more, notes, direct, footer, +9 more
confirm_sendSend a drafted WhatsApp messageAIdempotent
Send a draft the user approved — this text, this recipient: the only call that sends, once per draft. A yes about something else: show the preview again and ask. Expired, missing or stale: draft again, show the new preview, ask again. SEND_OUTCOME_UNKNOWN: read_messages, never redo it unasked.
Inputs: draft_id (required), account_id.
delete_messageDelete a WhatsApp messageADestructiveIdempotent
Delete a message; confirm with the user first. for_everyone: true retracts it for everyone within 2 days: the account's own message, or anyone's in a group where it is admin. for_everyone: false removes any message from the linked account's devices only.
Inputs: message_id (required), for_everyone (required), account_id. Returns: account_id, message_id, for_everyone
edit_messageEdit a WhatsApp message you sentADestructiveIdempotent
Replace the text of a message the linked account sent. WhatsApp allows it for 15 minutes after sending; later, send a correction instead.
Inputs: text (required), message_id (required), account_id. Returns: text, chat_id, timestamp, account_id, +1 more
find_contactFind who the user meansARead-onlyIdempotent
Who a name, nickname, relationship ("mama"), filed detail ("AP-123"), group, number or id means, before drafting. resolved: contact.chat_id, with number, note, tags, details and, when writing, context. ambiguous or not_found: ask the user; never guess. Several accounts: see fix. tag: its people.
Inputs: tag, kind, name, limit, +3 more. Returns: fix, next, notes, query, +11 more
get_group_infoGet WhatsApp group infoARead-onlyIdempotent
A group's name, description, owner and participants (up to 500), whether the account is admin, its settings (info_locked, member_add_mode, join_approval, disappearing_seconds), its community, and the invite link for an admin. Call it before manage_group.
Inputs: group_id (required), account_id. Returns: name, owner, chat_id, community, +12 more
get_mediaGet the media of a WhatsApp messageBRead-only
What a message's media holds: a voice note or audio as its transcript (kept once made; an API provider bills it); a photo or sticker as an image; a video as a sheet of frames; a document as its text and first page. A local call also saves the file (save_to). MEDIA_UNAVAILABLE: gone.
Inputs: pages, detail, save_to, language, +3 more. Returns: link, mime, path, size, +18 more
get_messageGet one WhatsApp message in fullBRead-onlyIdempotent
One message in full, its words never cut: the message it quotes, each reaction with who left it, poll votes and event answers by person, its media, and on the user's own messages who it reached and who read it.
Inputs: message_id (required), account_id. Returns: text, chat_id, timestamp, account_id, +1 more
get_statusGet the WhatsApp connection statusARead-onlyIdempotent
Whether the account works: status (connected, not_linked, linking with its pairing code…), sync, how fresh the history is, webhook delivery, versions. accounts lists every account, with default. Call it on NOT_CONNECTED, NOT_LINKED or SYNC_IN_PROGRESS.
Inputs: account_id, include_picture.
learnLearn how to use the WhatsApp toolsARead-onlyIdempotent
The guide, one topic at a time: ids (formats, several accounts, the message shape), workflows, errors (what to do about each code), or all. Call it when unsure about ids, several accounts or an error code; with no topic it lists the topics. Never touches WhatsApp.
Inputs: topic, account_id.
link_accountLink a WhatsApp accountA
Pair wazap with the user's WhatsApp when get_status says not_linked, logged_out, session_corrupt or auth_failure. Show the user the code it returns: WhatsApp → Settings → Linked devices → Link a device → Link with phone number instead. Then poll get_status every 10 s until connected.
Inputs: phone (required), account_id.
list_chatsList WhatsApp chatsBRead-onlyIdempotent
Conversations, most recently active first: chat_id, name, type, unread count, last message, and whether archived, pinned, muted or left. Use it to find a chat_id.
Inputs: tag, limit, cursor, filter, +2 more. Returns: tag, sync, chats, count, +3 more
list_contactsList the phone's address bookARead-onlyIdempotent
The phone's address book on one account, a page at a time: saved name, phone (E.164), chat_id, contact_id, and when the last direct message was and its direction. No message words; #private people left out. address_book_synced false: not arrived yet.
Inputs: limit, order, cursor, account_id.
manage_chatManage a WhatsApp chatADestructive
Preview archive, pin, mute, pin_message, star_message, clear, delete, block and undo. After approval repeat chat_id/action with confirmation_id, without options. Expires in 15m; one attempt. mark_read runs directly, only when the user asks.
Inputs: action (required), chat_id (required), pin_hours, account_id, +3 more.
manage_groupManage a WhatsApp groupADestructive
Create a group, join one from an invite (preview first, then confirm: true), or administer one: members, name, description, photo, invite link, join requests, settings, leave. Most actions need admin. Every change shows to all members at once: say what will change, wait for a yes.
Inputs: action (required), url, value, invite, +6 more. Returns: name, next, action, status, +10 more
react_to_messageReact to a WhatsApp messageAIdempotent
React to a message with one emoji, or pass "" to take your reaction off.
Inputs: emoji (required), message_id (required), account_id. Returns: emoji, account_id, message_id
read_messagesRead messages from a WhatsApp chatARead-onlyIdempotent
Read one chat, oldest to newest: the latest messages, older ones with before (wazap asks the phone when the local history runs out), or a window with since/until. Long texts are cut unless full_text. chat_id "status": the stories of the last hours (a day at most), shown nowhere else.
Inputs: chat_id (required), hours, limit, since, +6 more. Returns: sync, count, hours, notes, +13 more
rememberRemember something about a personAIdempotent
Keep what the user says about someone, locally, never on WhatsApp: a note, tags, details find_contact matches ({"relatie": "mama"}), or handled: true for an ask dealt with elsewhere. #private keeps their words out of what you did not ask about them by name; #no-catchup keeps them out of catch_up.
Inputs: chat_id (required), note, fields, handled, +4 more. Returns: name, note, tags, fields, +7 more
reminderSet, list or cancel a reminder about a chatA
The user's reminders about a chat, kept locally and posted to their webhook when due: create (chat_id, note, after_hours or due_at); condition "no_reply" fires only if nobody wrote there since ("if Ana has not answered in 2 days"). list, cancel. Nothing goes to WhatsApp.
Inputs: note, limit, action, due_at, +7 more. Returns: count, notes, action, cancelled, +2 more
scheduled_messagesList or cancel scheduled WhatsApp messagesAIdempotent
The account's scheduled messages: list (waiting ones soonest first, then the week's sent, missed, failed and cancelled ones) or cancel one by schedule_id before it goes. To schedule one, send_message with send_at, then confirm_send. Tell the user about every missed or failed one.
Inputs: limit, action, account_id, schedule_id, +1 more. Returns: count, action, cancelled, scheduled, +1 more
searchSearch WhatsApp messagesARead-onlyIdempotent
Find by meaning and words, with nearby source contexts. Use the question and known context, never guessed filters. Auto: exact codes/quoted literals; words: substrings. Check corrections; assessment flags ambiguity. Cite the supporting message.
Inputs: query (required), tag, from, limit, +8 more. Returns: mode, sync, count, index, +16 more
send_messageDraft a WhatsApp messageA
Drafts text, media, polls, locations, forwards; sends nothing. Call it as soon as you have recipient and text: it returns draft_id and preview (recipient, number, exact text). Show that preview; confirm_send only on a yes to this text and recipient — a send in the same request is that yes.
Inputs: text (required), chat_id (required), as, url, +15 more.
wait_for_messagesWait for new WhatsApp messagesARead-onlyIdempotent
Wait for messages from other people, up to timeout_seconds, and return them with a cursor: pass it to the next call so nothing that lands between calls is missed. addressed_to_me wakes only for direct messages, mentions and replies to the user. For agents that stay on the line.
Inputs: cursor, chat_id, account_id, addressed_to_me, +1 more. Returns: count, cursor, messages, timed_out, +2 more
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 23 tools
Most tools map to a distinct resource+action, and the descriptions actively separate the message-reading cluster (read_messages, get_message, catch_up, wait_for_messages, search) by scenario. The draft/confirm_send split and the manage_chat vs manage_group overlap are the only places where an agent could hesitate, but both are explicitly clarified.
The dominant pattern is verb_noun (list_chats, get_message, delete_message, manage_group), but several tools break it: bare verbs (learn, remember, search, catch_up) and bare nouns (scheduled_messages, reminder). The convention is readable but mixed enough to be noted.
23 tools is on the heavy side, but the server spans multiple accounts, chats, groups, media, drafts, scheduling and reminders, so each tool covers a distinct slice rather than duplicating scope. It is at the upper edge of well-scoped rather than bloated.
The surface covers the full message lifecycle (draft, confirm, edit, delete, react), reading/search/triage, contacts, groups, media, scheduling, account linking/status and local reminders. Only minor gaps remain, such as profile/settings management and a standalone read-marking call outside manage_chat.
Maintenance
Related MCP Connectors
Free WhatsApp MCP server for ChatGPT and Claude: read and search chats, every send you approve.
Read-only WhatsApp MCP for your AI agent: it reads the chats you choose. Try the public demo.
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.
Drive WhatsApp from any MCP client: pair devices, send text and media, manage contacts and groups.
Related MCP Servers
- AlicenseNot gradedqualityBmaintenanceWhatsApp MCP server that exposes messaging, groups, contacts, and profile management as tools and resources for AI agents, supporting Baileys and Meta Cloud API.79 npm29MIT
- AlicenseNot gradedqualityCmaintenanceA self-hosted WhatsApp bridge that exposes a stdio MCP server with ~20 tools for reading conversations, sending messages, managing groups, contacts, and aliases, enabling AI agents to operate WhatsApp directly.4MIT
- AlicenseNot gradedqualityDmaintenanceMCP server that connects AI agents to WhatsApp using the multi-device API, enabling messaging, group management, and more as a regular user.6 npm1MIT
- AlicenseNot gradedqualityBmaintenanceA native MCP server for SocialMate that gives your AI a WhatsApp, enabling it to send and read messages, manage contacts and groups, and more through 44 tools.46 npm1MIT