WaliChat’s MCP (acronym of Model Context Protocol) connector lets you connect your WaliChat WhatsApp numbers into modern AI LLMs and chat with your WhatsApp data, analyze conversation, send messages, or perform any other WhatsApp action directly from your favorite AI chat or code tool.

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.

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

• URL: https://api.wali.chat/mcp

Every call to the WaliChat 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}}

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 WaliChat MCP connector:

• "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!'"

• "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"

• "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]"

• "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"

• "Check if the phone number +1555987654 is a valid WhatsApp number"
• "What WhatsApp numbers do I have connected to WaliChat?"
• "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"

• "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"

• "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"

• "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"

• "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"

• "Show me my current WaliChat 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 WaliChat platform.

If your MCP client supports HTTP streaming (previously known as Server-Sent Events or SSE transport), you can connect directly to the WaliChat MCP server without installing this package. This is the preferred method as it's faster and requires no local setup.

Most modern MCP clients support HTTP streaming, including:

• n8n (using MCP Servers or LangChain MCP)
• Claude Desktop (latest versions)
• Claude Code
• Claude.ai (web interface with custom integrations)
• VS Code Copilot
• OpenCode
• Gemini CLI
• Antigravity
• Cursor (v0.48.0+)
• Windsurf
• Trae
• 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

Add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "wassenger": {
      "type": "http",
      "url": "https://api.wali.chat/mcp?key={{apikey}}"
    }
  }
}

Or using environment variables:

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

To add the WaliChat MCP server to Claude Code, run the following command in your terminal:

claude mcp add wassenger "https://api.wali.chat/mcp?key={{apikey}}"

In OpenCode settings, add the following MCP server configuration:

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

To use with Gemini CLI, add the MCP server using this command:

gemini-cli --mcp wassenger "https://api.wali.chat/mcp?key={{apikey}}"

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

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

Or using environment variables:

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

In Cursor settings, go to General > MCP and add a new MCP server with the following URL:

https://api.wali.chat/mcp?key={{apikey}}

Add the following to your ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "wassenger": {
      "type": "http",
      "url": "https://api.wali.chat/mcp?key={{apikey}}"
    }
  }
}

To add to Antigravity, use the following command:

antigravity mcp add wassenger "https://api.wali.chat/mcp?key={{apikey}}"

Add the following to your ~/.continue/config.json:

{
  "mcpServers": [
    {
      "name": "wassenger",
      "url": "https://api.wali.chat/mcp?key={{apikey}}"
    }
  ]
}

In Zed's settings.json, add:

{
  "context_providers": {
    "mcp": [
      {
        "name": "wassenger",
        "url": "https://api.wali.chat/mcp?key={{apikey}}"
      }
    ]
  }
}

To start Aider with the WaliChat MCP server:

aider --mcp "https://api.wali.chat/mcp?key={{apikey}}"

Trae is a VS Code fork by ByteDance. You can use the same configuration as VS Code Copilot in the settings.

GitHub Copilot supports MCP via the VS Code MCP extension. Follow the instructions in the VS Code Copilot Configuration section.

For integration with ChatGPT, you can use the OpenAI Responses API which natively supports MCP tools. See the OpenAI API section for details and code examples.

Perplexity Pro users can use the WaliChat MCP server through custom AI agents or by bridging the MCP server to tools that Perplexity can call via API.

Poe supports custom bots that can be integrated with MCP servers. You can use the WaliChat MCP URL as a base for your bot's tool definitions.

Codeium's enterprise plans and advanced tools (like Windsurf) support MCP. For Windsurf, see the Windsurf Configuration section.

• ✅ 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

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

import OpenAI from 'openai';

const apiKey = process.env.WALICHAT_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.wali.chat/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 WALICHAT_API_KEY="{{apikey}}"

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

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

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.wali.chat/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

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": "WaliChat",
        "server_url": "https://api.wali.chat/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.wali.chat/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 supports inline MCP tools in chat-completions. First, fetch the tool list:

tools = client.messages.create_tools(
    server_url="https://api.wali.chat/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 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 */ }
      }
    }
  ]
}

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

• Desktop:

Edit claude_desktop_config.json:

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

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

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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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

• 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! 🚀