How to Connect WhatsApp Business to OpenClaw

This is the official Meta approach. Go to developers.facebook.com, create a Meta App (select 'Business' type), and add the 'WhatsApp' product to your app. Meta will walk you through connecting a WhatsApp Business Account. In the WhatsApp app setup, Meta provides a temporary access token and a test phone number ID for immediate testing (no business verification required for testing). For production, you add a real business phone number — this requires Meta Business verification. Your credentials from the Meta developer console: 1. **Phone Number ID** — found in WhatsApp > Getting Started. Looks like `123456789012345`. 2. **Access Token** — for testing, use the temporary token in Getting Started. For production, generate a permanent System User token: Business Settings > System Users > Add System User > Generate New Token > select your WhatsApp app > whatsapp_business_messaging permission. 3. **WhatsApp Business Account ID (WABA ID)** — also on the Getting Started page. For webhook setup (required to receive messages): go to your app's WhatsApp > Configuration > Webhook. Enter your public HTTPS URL and a verification token (any string you choose). Meta will send a verification GET request to confirm the endpoint is accessible — OpenClaw must be running and the webhook path must be configured before completing this step.

1# Test Cloud API credentials:
2curl -X GET "https://graph.facebook.com/v18.0/YOUR_PHONE_NUMBER_ID" \
3  -H "Authorization: Bearer YOUR_ACCESS_TOKEN"
4
5# Expected response:
6# {"id": "123456789012345", "display_phone_number": "+1 555-0100", "verified_name": "OpenClaw Bot"}
7
8# Send a test message to a WhatsApp number:
9curl -X POST "https://graph.facebook.com/v18.0/YOUR_PHONE_NUMBER_ID/messages" \
10  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
11  -H "Content-Type: application/json" \
12  -d '{
13    "messaging_product": "whatsapp",
14    "to": "+15550001234",
15    "type": "text",
16    "text": {"body": "Test message from OpenClaw via WhatsApp Cloud API"}
17  }'

Baileys is an open-source Node.js library that connects to WhatsApp using the WhatsApp Web protocol. It requires a QR code scan to authenticate a WhatsApp account session. This is faster to set up than the Cloud API and works with any WhatsApp account (personal or business), but it is not officially supported by Meta and carries account risk if used for high-volume automation. To use Baileys with OpenClaw, you run a small session initialization script that generates a QR code. Scan the QR with your phone (WhatsApp > Linked Devices > Link a Device). Baileys saves session credentials to disk so you only scan once — the session persists across restarts. After scanning, Baileys provides OpenClaw with a running WhatsApp connection object. OpenClaw writes messages through this connection and receives incoming messages as events. Note: WhatsApp has a policy against third-party clients. Personal automation with Baileys at low volume (personal productivity bots, testing) is low risk. High-volume business use with Baileys risks account termination — use the Cloud API for production customer communications.

1# Baileys session initialization (run once to generate QR and save credentials):
2# ~/.openclaw/scripts/init-whatsapp-baileys.js
3const { default: makeWASocket, useMultiFileAuthState } = require('@whiskeysockets/baileys')
4
5async function initSession() {
6  const { state, saveCreds } = await useMultiFileAuthState('./whatsapp-session')
7  const sock = makeWASocket({ auth: state })
8  
9  sock.ev.on('creds.update', saveCreds)
10  sock.ev.on('connection.update', (update) => {
11    const { connection, lastDisconnect, qr } = update
12    if (qr) {
13      console.log('Scan this QR code with WhatsApp:')
14      require('qrcode-terminal').generate(qr, { small: true })
15    }
16    if (connection === 'open') {
17      console.log('WhatsApp connected successfully!')
18      process.exit(0)
19    }
20  })
21}
22initSession()
23
24# Run with:
25# node ~/.openclaw/scripts/init-whatsapp-baileys.js

Open `~/.openclaw/config.yaml` and add the WhatsApp integration block under `integrations`. The configuration differs based on whether you are using the Cloud API or Baileys. For Cloud API: add `phone_number_id`, `access_token`, and `waba_id` from your Meta developer console. The `webhook_verify_token` must match the token you entered in Meta's webhook configuration step. For Baileys: point OpenClaw to the session directory you created during initialization. OpenClaw loads the session from the saved credentials files and maintains the connection. After saving the config, run `clawhub reload`. For Cloud API, OpenClaw will verify the credentials by calling the phone number info endpoint. For Baileys, OpenClaw loads the session and reconnects to WhatsApp Web.

1# ~/.openclaw/config.yaml — Cloud API configuration
2integrations:
3  whatsapp_business:
4    mode: cloud_api
5    phone_number_id: "123456789012345"
6    access_token: "EAAxxxxxxxxxxxxxxx"
7    waba_id: "987654321098765"
8    webhook_verify_token: "my-webhook-secret-token"
9    webhook_path: /whatsapp/webhook
10    default_messaging_product: whatsapp
11
12# OR: Baileys configuration
13# integrations:
14#   whatsapp_business:
15#     mode: baileys
16#     session_path: ~/.openclaw/whatsapp-session
17#     auto_reconnect: true
18#     reconnect_interval: 5000  # ms between reconnect attempts

The Cloud API distinguishes between two message types with different rules: **Session messages** (free-form text, within 24-hour window): can only be sent in response to a customer-initiated message within the past 24 hours. This is the natural back-and-forth support conversation model. **Template messages** (outside 24-hour window or proactive outreach): must use a pre-approved message template. Templates are approved by Meta and contain fixed text with optional variable placeholders. Submit templates in Meta Business Suite > WhatsApp > Message Templates. For session messages, send any text within the 24-hour window. For template messages, reference the template name and fill in variables. For Baileys, there are no template restrictions — any message can be sent at any time to any contact who has your number saved (or has previously messaged you). RapidDev recommends building your template library early (3-5 key templates: order confirmation, appointment reminder, support acknowledgment, general notification) since template approval takes 24-48 hours and you cannot send outside session windows until templates are approved.

1# Send a session message (within 24-hour conversation window):
2curl -X POST "https://graph.facebook.com/v18.0/YOUR_PHONE_NUMBER_ID/messages" \
3  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
4  -H "Content-Type: application/json" \
5  -d '{
6    "messaging_product": "whatsapp",
7    "to": "+15550001234",
8    "type": "text",
9    "text": {"body": "Thanks for reaching out! How can we help you today?"}
10  }'
11
12# Send a template message (proactive or outside 24-hour window):
13curl -X POST "https://graph.facebook.com/v18.0/YOUR_PHONE_NUMBER_ID/messages" \
14  -H "Authorization: Bearer YOUR_ACCESS_TOKEN" \
15  -H "Content-Type: application/json" \
16  -d '{
17    "messaging_product": "whatsapp",
18    "to": "+15550001234",
19    "type": "template",
20    "template": {
21      "name": "order_confirmation",
22      "language": {"code": "en_US"},
23      "components": [{
24        "type": "body",
25        "parameters": [
26          {"type": "text", "text": "#ORD-12345"},
27          {"type": "text", "text": "3 items"},
28          {"type": "text", "text": "March 28, 2026"}
29        ]
30      }]
31    }
32  }'

To receive incoming WhatsApp messages (not just send), configure a webhook endpoint. For the Cloud API, Meta delivers incoming messages by POSTing to your webhook URL. OpenClaw must be accessible at a public HTTPS URL for this to work. Verify the webhook setup: Meta first sends a GET request with `hub.mode=subscribe`, `hub.verify_token` (your configured token), and `hub.challenge`. Your endpoint must respond with the `hub.challenge` value. OpenClaw handles this automatically when `webhook_verify_token` is configured. After verification, Meta sends POST requests with message payloads for every incoming message. Each payload contains the sender's phone number, message type (text, image, audio, etc.), and message content. For Baileys, no webhook configuration is needed — messages arrive as events on the Baileys connection object that OpenClaw listens to directly. For local development without a public URL, use Cloudflare Tunnel or ngrok to expose your local OpenClaw instance temporarily during testing.

1# Incoming Cloud API webhook payload format:
2{
3  "object": "whatsapp_business_account",
4  "entry": [{
5    "id": "WABA_ID",
6    "changes": [{
7      "value": {
8        "messaging_product": "whatsapp",
9        "metadata": {"phone_number_id": "PHONE_ID"},
10        "messages": [{
11          "id": "wamid.xxx",
12          "from": "+15550001234",
13          "timestamp": "1709123456",
14          "type": "text",
15          "text": {"body": "Hello, I need help with my order"}
16        }]
17      }
18    }]
19  }]
20}
21
22# Subscribe to webhook events in Meta console, or via API:
23curl -X POST "https://graph.facebook.com/v18.0/YOUR_WABA_ID/subscribed_apps" \
24  -H "Authorization: Bearer YOUR_SYSTEM_USER_TOKEN" \
25  -H "Content-Type: application/json"