MCP Server: Connect WhatsApp to any AI

Help Center / Tutorials

MCP Server: Connect WhatsApp to any AI

ai automation agent mcp chatgpt claude antrophic openai

Table of contents

Introduction to MCP
MCP Server
Authentication
Installation & Usage
MCP Tools Supported

Wassenger’s MCP (acronym of Model Context Protocol) connector lets you hook any Wassenger connection into modern AI LLMs using the new Streamable HTTP transport protocol. Think of it as the autopilot for your messaging flows—you tell it where to send requests, and it handles the rest, so you can focus on innovation (or perfecting your coffee art).

Note: Our MCP server is currently in beta. It’s perfect for testing and prototyping, but hold off on sending it to your production-critical systems, at least until it graduates from beta school! 😉

Introduction to MCP

MCP (Model Context Protocol) is a standardized way for AI applications to connect with external data sources and tools. Think of it as a universal translator that allows AI models to safely access and interact with various systems like databases, APIs, file systems, and other services.

MCP is becoming de-facto industry standard to connect AI LLMs like ChatGPT, Gemini or Claude to third-party apps and APIs in order to augment their its capabilities. MCP is also particularly useful when building AI Agents automations using no-code tools n8n, Zapier, Make, Flowise, Dify, and more.

MCP Server

Wassenger provides it cloud MCP server available to anyone with existing account and API key.

URL: https://api.wassenger.com/mcp

Authentication

Every call to the Wassenger MCP server requires a token, which you can supply either:

As a query parameter: ?key={apikey}
As an HTTP header: Authorization: Bearer {apikey}

Authorization: Bearer {{apikey}}
``

## Example prompts

Chat with your WhatsApp conversations from any AI clients or agentic tool integration.

Here are various prompts you can use with any AI assistant to interact with WhatsApp through the Wassenger MCP connector:

### 📱 Basic Messaging & Communication
- "Send a WhatsApp message to +1234567890 saying 'Hello! How are you today?'"
- "Send a message to the contact named 'John Smith' with the text 'Meeting confirmed for 3 PM'"
- "Send an urgent message to +44123456789: 'Please call me back ASAP'"
- "Send a WhatsApp message with an image from [URL] to [phone-number]"
- "Reply to message [message-id] in chat [chat-id] with 'Thanks for your feedback!'"

### 📊 Conversation Analysis & Insights
- "Summarize my last 10 WhatsApp messages with +1555123456"
- "Analyze the conversation tone in my chat with the Marketing Team group"
- "Show me the key topics discussed in my conversation with Sarah over the past week"
- "Count how many messages I've received today from all contacts"
- "Search for messages containing 'invoice' in chat [chat-id]"
- "Generate chat activity report grouped by day for this month"

### 👥 Group & Team Management
- "Create a WhatsApp group called 'Team Updates' with participants +1234567890, +0987654321"
- "How many participants are in the 'Project Team Alpha' WhatsApp group?"
- "List all members of my 'Family Chat' group"
- "Add +1234567890 to WhatsApp group [group-id]"
- "Make +1234567890 an admin in group [group-id]"
- "Get the invite link for group [group-id]"

### ⏰ Message Scheduling & Automation
- "Schedule a message to +1234567890 saying 'Happy Birthday!' to be sent tomorrow at 9 AM"
- "Set up a reminder message for the team group about the meeting next Friday at 2 PM"
- "Set up auto-replies for messages received outside business hours (9 AM - 5 PM)"
- "Create a workflow: when someone messages 'INFO', automatically send our company brochure"

### 🔍 Contact & Device Management
- "Check if the phone number +1555987654 is a valid WhatsApp number"
- "What WhatsApp numbers do I have connected to Wassenger?"
- "Show me the status of all my WhatsApp devices"
- "Get the profile information for contact +1234567890"
- "Show me all my recent contacts from the past month"

### 📈 Analytics & Reporting
- "Generate a report of my most frequent WhatsApp contacts this month"
- "Show me my busiest WhatsApp conversation days this week"
- "Which agent responds fastest to customer inquiries?"
- "Show me chat volume trends over the last 30 days"
- "Count unread messages across all my chats"
- "Find customers who haven't interacted in the last 60 days"

### 🔔 Status & Monitoring
- "Check the delivery status of my last message to +1234567890"
- "Show me all failed message deliveries from today"
- "Monitor if my contact +1555123456 has read my recent messages"
- "Post 'Working on exciting new features!' as my WhatsApp status"

### 🔄 Bulk Operations & Campaigns
- "Send the same announcement to all members of my 'Team Updates' group individually"
- "Broadcast a holiday greeting to my top 10 most contacted numbers"
- "Create a campaign called 'Welcome Series' to send 'Welcome to our service!' to multiple contacts"
- "Start campaign [campaign-id] and check its delivery status"

### 🎯 Smart Business Automation
- "Create a label called 'VIP Customer' with red color and apply it to important chats"
- "Assign chat [chat-id] to agent [agent-id]"
- "Show me all chats with the 'support' label"
- "Analyze sentiment in customer support conversations and flag negative ones"
- "Generate a CSV report of all chats with their last activity"
- "Find all unread messages in my WhatsApp chats"

### 🔐 Account & File Management
- "Show me my current Wassenger account usage and limits"
- "Upload an image from [image-url] to use in WhatsApp messages"
- "List all uploaded files tagged as 'marketing'"
- "Export all contacts from device [device-id] to JSON"

These prompts cover real-world scenarios for businesses using WhatsApp for customer service, marketing, team collaboration, and automation through the Wassenger platform.

## MCP streaming usage

If your MCP client supports [**HTTP streaming**](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports#streamable-http) (previously known as Server-Sent Events or SSE transport), you can connect directly to the Wassenger MCP server without installing this package. This is the preferred method as it's faster and requires no local setup.

### Supported Clients

Most modern MCP clients support HTTP streaming, including:

- **Claude Desktop** (latest versions)
- **Claude.ai** (web interface with custom integrations)
- **VS Code Copilot** with MCP extension
- **Cursor** (v0.48.0+)
- **Windsurf**
- **OpenAI Responses API**
- **ChatGPT** (Pro users, rolling out to all users)
- **GitHub Copilot** (integrated MCP support)
- **Anthropic API** (direct integration)
- **Google Gemini API** (function declarations)
- **Perplexity Pro** (beta access)
- **Poe** (custom bots with MCP)
- **Codeium** (enterprise plans)
- **Continue.dev** (open-source code assistant)
- **Aider** (AI pair programming)
- **Zed Editor** (built-in AI features)

### Claude Desktop Configuration

Add this to your `claude_desktop_config.json`:

```json
{
  "mcpServers": {
    "wassenger": {
      "type": "http",
      "url": "https://api.wassenger.com/mcp?key={{apikey}}"
    }
  }
}

Or using environment variables:

{
  "mcpServers": {
    "wassenger": {
      "type": "http",
      "url": "https://api.wassenger.com/mcp?key=${API_KEY}",
      "env": {
        "API_KEY": "{{apikey}}"
      }
    }
  }
}

VS Code Copilot Configuration

For VS Code with MCP extension, add this to your VS Code settings (JSON format):

{
  "mcp.servers": {
    "wassenger": {
      "url": "https://api.wassenger.com/mcp?key={{apikey}}",
      "transport": "http-streaming"
    }
  }
}

Or using environment variables:

{
  "mcp.servers": {
    "wassenger": {
      "url": "https://api.wassenger.com/mcp?key=${API_KEY}",
      "transport": "http-streaming",
      "env": {
        "API_KEY": "{{apikey}}"
      }
    }
  }
}

Benefits of HTTP Streaming

✅ No local installation required
✅ Faster connection times
✅ Automatic updates - always uses the latest server version
✅ Better reliability - no Node.js dependency
✅ Simpler configuration - just a URL

Usage as a tool in OpenAI

Here's how you can use the Wassenger MCP server as a tool with the OpenAI JavaScript client:

import OpenAI from 'openai';

const apiKey = process.env.WASSENGER_API_KEY || '{{apikey}}'

const openai = new OpenAI({
  apiKey: process.env.OPENAI_API_KEY,
});

// Example: Send a WhatsApp message using OpenAI's new Responses API with MCP
const response = await openai.responses.create({
  model: 'o4-mini',
  tools: [
    {
      type: 'mcp',
      server_label: 'wassenger',
      server_url: `https://api.wassenger.com/mcp?key=${apiKey}`,
      require_approval: 'never'
    }
  ],
  input: 'Send a WhatsApp message to +1234567890 saying "Hello from AI!"'
});

console.log('Response:', response);

Make sure to install the required dependencies:

npm install openai

And set your environment variables:

export OPENAI_API_KEY="your-openai-api-key"
export WASSENGER_API_KEY="{{apikey}}"

This approach uses OpenAI's new Responses API with MCP integration, which automatically handles tool discovery, execution, and communication with the Wassenger MCP server without requiring manual MCP client setup.

Python MCP Client

You can also use the Wassenger MCP server with Python using the mcp library:

Python with HTTP Streaming

For Python clients that support HTTP streaming, you can connect directly without the Node.js package:

import httpx
import json

class MCPClient:
  def __init__(self, api_key):
    self.api_key = api_key
    self.base_url = f"https://api.wassenger.com/mcp?key={api_key}"

  async def call_tool(self, tool_name, arguments):
    async with httpx.AsyncClient() as client:
      response = await client.post(
        f"{self.base_url}/call",
        json={
          "method": "tools/call",
          "params": {
            "name": tool_name,
            "arguments": arguments
          }
        }
      )
      return response.json()

  async def list_tools(self):
    async with httpx.AsyncClient() as client:
      response = await client.post(
        f"{self.base_url}/list",
        json={"method": "tools/list"}
      )
      return response.json()

# Usage example
async def main():
  mcp_client = MCPClient("your-api-key-here")

  # Send a WhatsApp message
  result = await mcp_client.call_tool(
    "manage_whatsapp_messages",
    {
      "action": "text",
      "phone": "+1234567890",
      "message": "Hello from Python MCP client!"
    }
  )
  print("Message sent:", result)

asyncio.run(main())

Install dependencies:

pip install httpx

Installation & Usage

OpenAI API

OpenAI’s chat-completion endpoint natively supports remote MCP. Just point it at our Streamable HTTP URL:

resp = client.responses.create(
    model="gpt-4.1",
    tools=[{
        "type": "mcp",
        "server_label": "Wassenger",
        "server_url": "https://api.wassenger.com/mcp?key=API_KEY_HERE",
        "require_approval": "never",
        "allowed_tools": [], # all by default
    }],
    input="Send a WhatsApp message to number +1234567890 saying: Hello from the AI world!",
)

You can also pull the full list of tools first, then let OpenAI decide which to call:

tools = client.responses.create_tools(server_url="https://api.wassenger.com/mcp?key=API_KEY_HERE")
resp = client.responses.create(
    model="gpt-4.1",
    tools=tools,
    input="Send a WhatsApp message to number +1234567890 saying: Hello from the AI world!",
)

Anthropic API

Anthropic supports inline MCP tools in chat-completions. First, fetch the tool list:

tools = client.messages.create_tools(
    server_url="https://api.wassenger.com/mcp?key=API_KEY_HERE"
)
resp = client.messages.create(
    model="claude-4-sonnet",
    tools=tools,
    input="Send a WhatsApp message to number +1234567890 saying: Hello from the AI world!",
)

Anthropic will return a tool_use block like:

[
  {
    "type": "tool_use",
    "id": "toolu_01EXAMPLE",
    "name": "list_sessions",
    "input": { "limit": "50" }
  }
]

Call the tool, then send back:

[
  {
    "type": "tool_result",
    "tool_use_id": "toolu_01EXAMPLE",
    "content": "..."
  }
]

Google Gemini API

Google Gemini treats MCP tools as function declarations. Declare your functions using the /tools endpoint, then include them in your function_declarations list. When the model invokes one, respond with:

{
  "role": "user",
  "parts": [
    {
      "functionResponse": {
        "name": "generate_report",
        "response": { /* your tool output */ }
      }
    }
  ]
}

Claude.ai (Web & Desktop)

Web: Go to Settings → Integrations → Add Custom Integration and paste: https://api.wassenger.com/mcp?token={workspaceID}-{nonce}-{signature}
Desktop:

Edit claude_desktop_config.json:

{
  "mcpServers": {
    "wassenger-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "mcp-remote",
        "https://api.wassenger.com/mcp?token={workspaceID}-{nonce}-{signature}",
        "--allow-http"
      ]
    }
  }
}

Cursor

In Cursor’s settings, under MCP, add:

{
"mcpServers": {
  "wassenger-mcp": {
    "url": "https://api.wassenger.com/mcp?key={{apikey}}"
  }
}
}

And just like that, your favorite coding notebook can chat with WhatsApp through LLM magic.

MCP Tools Supported

The Wassenger MCP server provides comprehensive WhatsApp automation tools organized into functional categories. All tools use action-based parameters for LLM-friendly interactions:

📱 Core Messaging & Communication

manage_whatsapp_messages - Universal message sending with 11 action types: text, media, location, contact, poll, event, scheduled, live, expiring, agent, and template messaging
manage_whatsapp_message_interactions - Message interactions: reply, forward, reaction, and poll voting
get_whatsapp_chat_messages - Comprehensive message retrieval: recent, search, date range, by sender, by type, by ID, advanced search, thread context, and media filtering
analyze_whatsapp_chat_messages - Message analytics: statistics, delivery status tracking, and data export in multiple formats

💬 Chat & Conversation Management

get_whatsapp_chats - Universal chat retrieval with 9 actions: recent, unread, by status, assigned, by contact type, by ID, search, archived, and date range filtering
analyze_whatsapp_chats - Chat analytics and export with comprehensive statistics and data export capabilities
search_whatsapp_chats_by_name - Quick chat search by contact name, group name, or channel name

👥 Group & Team Management

manage_whatsapp_groups - Complete group operations: search, create, update, join, leave, invite management with 8 action types
manage_whatsapp_group_participants - Participant management: add, remove, promote, demote, approval workflow with 7 action types
manage_whatsapp_team - Team member management: search, create, update, delete, device access control with 7 action types
manage_whatsapp_departments - Department organization: list, create, update, delete with agent assignments and visual customization

📺 Channel & Broadcasting

manage_whatsapp_channels - Channel lifecycle management: list, create, update, search, join, leave, image updates with 9 action types
manage_whatsapp_channel_messages - Channel message retrieval with filtering and pagination
manage_whatsapp_status - WhatsApp Status (Stories) management: get, publish, schedule with media support and advanced timing

🔄 Campaign & Bulk Operations

manage_whatsapp_campaigns - Bulk messaging campaigns: search, create, update, start, stop, delete with 7 action types
manage_whatsapp_campaign_contacts - Campaign recipient management: search, add, remove contacts with filtering options
manage_whatsapp_queue - Message queue control: status monitoring, queue management, bulk deletion with 3 action types

📱 Device & Account Management

get_whatsapp_devices - Device listing with advanced filtering: status, session, search, active/online filtering
get_whatsapp_device_details - Detailed device information: configuration, session status, metrics, and insights
health_check - Comprehensive system health check for MCP server and connected WhatsApp devices

👤 Contact & Label Management

manage_whatsapp_contacts - Contact CRUD operations: list, get, create, update, delete, bulk operations, metadata management with 8 action types
manage_whatsapp_contact_actions - Contact blocking: block and unblock operations
manage_whatsapp_labels - Label management: list, create, update, delete with color-coded organization

📁 File & Media Management

search_whatsapp_outbound_files - Uploaded file search with advanced filtering by type, size, date, tags, and metadata
search_whatsapp_chat_files - Received file search from WhatsApp chats with comprehensive filtering options

🔧 System & Utilities

ping - Basic connectivity test with server status and response time measurement

MCP is evolving at light speed—expect new transports, tighter integrations, and maybe even self-healing error handling in the next release. Stay tuned, and happy automating! 🚀