Skip to main content
Glama
WhatsApp MCP for macOS

WhatsApp MCP for macOS

by kalki-kgp

Check it out on https://mcp.paperknife.app/

WhatsApp MCP for macOS

A Model Context Protocol server that connects Claude to your WhatsApp. Ask Claude to catch you up on unread chats, search your message history, or send a reply.

Reading works in about a minute with no QR scan and no Node.js. Sending is optional and needs one extra step.

Features

Search contacts by name or phone number. Read chat history with date filtering. List recent conversations with unread counts. Summarize everything you haven't read yet. Send replies and receive incoming messages once the bridge is connected.

Related MCP server: WhatsApp MCP Server

Requirements

  • macOS with the WhatsApp desktop app installed and logged in

  • Node.js 18+, only if you want to send messages

You don't need to install Python. uvx fetches a suitable version on its own.

Installation

Install uv if you don't have it:

curl -LsSf https://astral.sh/uv/install.sh | sh

That's the whole install. uvx downloads the server on first launch, so there's no virtualenv to create and no pip install step. Go to the next section to point Claude at it.

From source

git clone https://github.com/kalki-kgp/whatsapp-mcp.git
cd whatsapp-mcp
uv venv && uv pip install -e .

Connect to Claude Desktop

  1. Open config file:

    open ~/Library/Application\ Support/Claude/claude_desktop_config.json

    If it doesn't exist, create it.

  2. Find the full path to uvx:

    which uvx
  3. Add the WhatsApp MCP server, pasting that path as the command:

    {
      "mcpServers": {
        "whatsapp": {
          "command": "/Users/YOU/.local/bin/uvx",
          "args": ["whatsapp-mcp-macos"]
        }
      }
    }

    Use the absolute path, not bare uvx. Claude Desktop starts with a minimal PATH that doesn't include ~/.local/bin, so a bare command name is the most common reason the server never appears.

  4. Restart Claude Desktop with Cmd+Q, then reopen. Closing the window is not enough.

  5. Click the MCP tools icon in the chat input and check that "whatsapp" is listed.

  6. Start chatting:

    • "Show my recent WhatsApp chats"

    • "Search messages for dinner plans"

Connect to Cursor

Add to .cursor/mcp.json in your project:

{
  "mcpServers": {
    "whatsapp": {
      "command": "/Users/YOU/.local/bin/uvx",
      "args": ["whatsapp-mcp-macos"]
    }
  }
}

Restart Cursor and use WhatsApp tools in the AI chat.

Usage

Reading messages (works immediately)

Just ask Claude:

  • "Show my recent WhatsApp chats"

  • "Search for messages about dinner"

  • "What did John say yesterday?"

  • "Catch me up on unread messages"

Sending messages (requires bridge)

  1. Start the WhatsApp bridge:

    cd bridge && npm install && npm start
  2. Ask Claude to check connection:

    • "Check WhatsApp status"

  3. If it shows a QR code, open the data URL in a browser and scan with your phone

  4. Once connected, you can send:

    • "Send a message to Mom saying I'll be late"

    • "Reply to John with 'sounds good'"

Tools

Tool

Description

Requires Bridge

whatsapp_status

Check connection, get QR if needed

No

whatsapp_search_contacts

Search contacts by name/phone

No

whatsapp_list_chats

List recent conversations

No

whatsapp_get_messages

Get messages from a chat

No

whatsapp_search_messages

Search across all chats

No

whatsapp_unread

Get unread message summary

No

whatsapp_send

Send a message

Yes

whatsapp_incoming

Get real-time incoming messages

Yes

How it works

Claude ──MCP──▶ WhatsApp MCP Server
                       │
                       ├──▶ Local SQLite DBs (read messages)
                       │    ~/Library/Group Containers/group.net.whatsapp.WhatsApp.shared/
                       │
                       └──▶ WhatsApp Bridge (:3010) ──▶ WhatsApp Web
                            (for sending)

Read operations query the local WhatsApp database directly, so they work offline and need no bridge.

Send operations go through the bridge, which connects to WhatsApp Web using Baileys.

Development

# Clone
git clone https://github.com/kalki-kgp/whatsapp-mcp.git
cd whatsapp-mcp

# Install in dev mode
pip install -e ".[dev]"

# Run server
python -m whatsapp_mcp

Privacy

  • All data stays local. The server reads messages from your own WhatsApp database

  • No data is sent to external servers (except WhatsApp Web when sending)

  • The MCP server runs locally on your machine

License

MIT

Available Tools

8 tools
whatsapp_get_messagesA
Read-only

Get messages from a specific WhatsApp chat.

Args: chat_jid: JID of the chat (from whatsapp_search_contacts or whatsapp_list_chats). after: Only messages after this datetime (ISO 8601). Defaults to 24h ago. before: Only messages before this datetime (ISO 8601). Defaults to now. limit: Max messages to return (max 200). search_text: Optional text to filter messages.

Inputs: chat_jid (required), after, limit, before, +1 more. Returns: result

whatsapp_incomingA
Read-only

Get recent incoming WhatsApp messages from the live connection.

These are real-time messages, not from the local database. Useful for checking new messages that just arrived.

Args: since_minutes: Look back N minutes (default 5, max 60).

Inputs: since_minutes. Returns: result

whatsapp_list_chatsA
Read-only

List recent WhatsApp chats ordered by last message time.

Args: limit: Number of chats to return (max 50). chat_type: Filter by 'dm', 'group', or 'all'.

Inputs: limit, chat_type. Returns: result

whatsapp_search_contactsA
Read-only

Search WhatsApp contacts by name or phone number.

Returns matching contacts with their JID, display name, and phone number. Use this to find a contact before reading their messages or sending them a message.

Args: query: Name or phone number to search for (partial match supported).

Inputs: query (required). Returns: result

whatsapp_search_messagesA
Read-only

Search for messages containing specific text across all chats.

Args: query: Text to search for (case-insensitive). chat_jid: Optional - restrict search to a specific chat. limit: Max results (max 50).

Inputs: query (required), limit, chat_jid. Returns: result

whatsapp_sendA

Send a WhatsApp message.

IMPORTANT:

  1. First use whatsapp_status to ensure WhatsApp is connected.

  2. Use whatsapp_search_contacts to get the correct JID.

  3. Always confirm with the user before sending.

Args: recipient_jid: The JID from whatsapp_search_contacts. message: The text message to send.

Inputs: message (required), recipient_jid (required). Returns: result

whatsapp_statusA
Read-only

Check WhatsApp connection status.

Returns current status: 'connected', 'qr_pending', 'disconnected', or 'bridge_offline'. If QR code is needed, returns a data URL you can open in a browser to scan.

Call this before sending messages to ensure WhatsApp is connected.

Inputs: no named parameters. Returns: result

whatsapp_unreadA
Read-only

Get a summary of all unread WhatsApp messages.

Returns chats with unread messages and recent message previews. Great for "catch me up" or "what did I miss" requests.

Inputs: no named parameters. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 8 tools

    Disambiguation4/5

    Most tools have distinct purposes, but whatsapp_get_messages and whatsapp_search_messages could cause confusion as both retrieve messages with text filtering. whatsapp_get_messages focuses on a specific chat with time filters, while whatsapp_search_messages searches across all chats, but the overlap in functionality might lead to misselection by agents.

    Naming Consistency5/5

    All tools follow a consistent 'whatsapp_verb_noun' pattern with snake_case throughout. The naming is predictable and clear, making it easy for agents to understand the action and target resource without ambiguity.

    Tool Count5/5

    With 8 tools, this server is well-scoped for managing WhatsApp interactions on macOS. It covers essential operations like checking status, listing chats, searching contacts, retrieving messages, and sending messages, which is appropriate for the domain without being overly complex or sparse.

    Completeness4/5

    The toolset provides good coverage for core WhatsApp workflows, including status checks, contact search, message retrieval, and sending. However, there are minor gaps such as the inability to delete messages or manage group settings, which agents might need to work around, but the surface supports most common use cases effectively.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      Not graded
      maintenance
      Enables seamless integration with WhatsApp through the Model Context Protocol, featuring multi-user support and Supabase cloud storage for persistent message history and media. Users can send messages, search chat records, and manage contacts across platforms like Claude Desktop, Cursor, and OpenClaw.
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      Enables Claude to interact with WhatsApp: read chats, search messages, send messages with a mandatory confirmation step, and transcribe voice notes locally, all with encrypted storage and prompt-injection scrubbing.
      7
      MIT
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables Claude to read, search, and reply to your personal WhatsApp messages by linking as an extra device, with support for chat history, full-text search, media downloads, and sending messages or files.
      39 npm
      MIT