WhatsApp in Make on the official API, with ZapClaw

In short: ZapClaw posts each WhatsApp message to a Make Custom webhook, and your scenario replies with one HTTP module. Messages go through Meta's official Cloud API, and the number keeps working in the WhatsApp Business app on your phone. No Meta app of your own and no extra app to install in Make: two modules and a filter.

What you need to connect

• The WhatsApp Business app on the number, version 2.24.17 or newer, in regular use.
• Two-factor authentication on the personal Facebook account that authorizes the connection.
• The number not connected to another provider. If it is, disconnect it there first.
• A computer to run the connection, with your phone at hand to confirm it in the app.

You do not need a company tax ID or a verified business to connect. The full checklist.

Why the official API in Make

• No unofficial library behind your scenario. Integrations that imitate WhatsApp Web go against WhatsApp's terms and put the number at risk. ZapClaw uses Meta's Cloud API, and Meta's policies apply as they do to any business on it.
• The app stays on the phone. Through Coexistence your team keeps answering in the WhatsApp Business app while Make works the same number.
• Plain HTTP on both sides. A Custom webhook in, the HTTP app out, with your key in an X-API-Key header. Moving a scenario from another WhatsApp API means changing the URL, the key and a few field names.
• Deliveries you can check. Make answers ZapClaw the moment a request is queued, each event is signed with HMAC-SHA256, and an event Make does not accept gets up to 3 delivery attempts and can be replayed from the ZapClaw dashboard.

Set it up in six steps

1. In Make, create a scenario and add Webhooks > Custom webhook. Next to Webhook, click Add, give it a name and save. Leave API Key authentication empty: Make expects that key in an x-make-apikey header, which ZapClaw does not send. Copy the URL Make generates.
2. In ZapClaw, connect your number, paste that URL under Webhook and create an API key. Under Events to receive, leave only Inbound messages checked: every delivery status is a separate request, and each one runs the scenario and uses a credit.
3. Make is now listening. Send a WhatsApp message to your number from another phone, so Make learns the fields of a real message. If the module caught the dashboard's test event first, click Detect new values and send the message again.
4. Add HTTP > Make a request after the webhook and fill it in as shown below. Your ZapClaw key goes into an API key keychain, sent in the X-API-Key header.
5. Click the line between the two modules to add a filter with two conditions: event equal to message.received, and data > type equal to text. The test event and anything else that is not an incoming text stop there, so your own replies never loop.
6. Save and activate the scenario. Send another WhatsApp message from the other phone: the scenario receives it and replies.

The HTTP module, field by field

The values for Make a request. In the mappings, 1 is the number of the Custom webhook module; you can also pick the same items in the mapping panel.

• Authentication type: API key. Under Credentials, create a keychain: Key is your ZapClaw key, API key placement is the header, and API key parameter name is X-API-Key.
• URL: https://api.zapclaw.app/api/v1/send/text, with Method set to POST.
• Body content type: application/JSON, with Data structure as the body input method. Create the structure with Make's generator from the sample below. Make then escapes the quotes and line breaks in each message for you.
• from: {{1.account.display_phone_number}}, your connected number.
• to: {{ifempty(1.data.from; 1.data.user_id)}}, the customer's number, or the user ID of a contact who shows only a username.
• text: {{1.data.text.body}} answers with the text received, which proves the round trip. Replace it with the output of an AI module, a lookup in your CRM or a fixed answer.
• Parse response: Yes, so later modules can read ZapClaw's answer.

{
  "from": "15551617409",
  "to": "15555550100",
  "text": "Hello from Make"
}

Free text works within 24 hours of the customer's last message. Outside that window Meta accepts only an approved template: call POST /api/v1/send/template instead.

To try your key before you build the scenario, send the same call from a terminal. A sent message answers 201.

curl -X POST https://api.zapclaw.app/api/v1/send/text \
  -H "X-API-Key: zc_live_..." \
  -H "Content-Type: application/json" \
  -d '{ "from": "15551617409", "to": "15555550100", "text": "Hello from Make" }'

What reaches the Custom webhook

Each message comes as a message.received event, and Make breaks the JSON into items you can map: the text in data.text.body, the sender in data.from, the contact's name in data.contact_name and your number in account.display_phone_number. A media message carries a media_url you download with your API key.

{
  "event": "message.received",
  "sequence": 1042,
  "timestamp": "2026-05-21T14:00:00.000Z",
  "data": {
    "from": "15555550100",
    "user_id": "US.1A2B3C4D5E6F7G8H9I0J",
    "contact_name": "Maria Silva",
    "contact_username": "maria_lima",
    "message_id": "wamid.HBg...",
    "type": "text",
    "timestamp": "1747836000",
    "text": { "body": "Hello" }
  },
  "account": {
    "phone_number_id": "964283400112599",
    "display_name": "My Business",
    "display_phone_number": "+1 555 161-7409"
  }
}

Every request carries an X-ZapClaw-Signature header, an HMAC-SHA256 of the raw body keyed with your signing secret: how to verify it. To read that header in a scenario, set Get request headers to Yes in the webhook's advanced settings.

Good to know

• Leave the webhook's data structure empty. With a data structure in its advanced settings, Make rejects with a 400 every request that does not match it, and ZapClaw also posts status updates and account events. The filter does the sorting instead.
• No Webhook response module needed. Without one, Make answers 200 Accepted as soon as the request is queued, well within ZapClaw's 10 second timeout.
• Replies in order. By default, Make runs the scenarios of an instant webhook in parallel. If answers must follow the order the messages arrived in, turn on Process data in order in the scenario settings.
• Keep the webhook in a scenario. Make deactivates a webhook that has not been connected to any scenario for more than 5 days, and it then answers 410 Gone, which ZapClaw's delivery log shows as failed.
• Keep one failed send from stopping the scenario. Make turns off a scenario that starts with a webhook at its first error, and the replies stop until you turn it back on. ZapClaw's delivery log shows what Make's webhook accepted, not what the scenario did. Turn on Store incomplete executions in the scenario settings, or right-click the HTTP module and add an error handler such as Skip or Resume.

What it costs

• Free: 500 messages a month and 1 number, with no card and no end date. At the limit, sending pauses and new messages are held until you subscribe.
• Business: US$ 29 per month, with 20,000 messages included and unlimited numbers.
• Agency: US$ 49 per month for agencies, with 3 clients and 60,000 messages included and unlimited numbers.

Meta bills its WhatsApp message fees to you directly, with no ZapClaw markup. Every plan and price.

Who it is for

Make users who automate WhatsApp for their own business or for clients: AI replies, leads sent to a CRM, order updates, support triage. Agencies connect their clients' numbers on the Agency plan, each client isolated from the others. It does not fit bulk broadcasting.

Go further

• The official WhatsApp API with ZapClaw: what you get, the price and the requirements.
• The same setup in n8n, with a flow you can import.
• WhatsApp in Dify, when the answer comes from an AI app.
• The webhook reference, with every event and field.
• Leaving an unofficial WhatsApp API: what changes.

Sources

Checked on 15 October 2026. Make updates its modules from time to time, so if a field looks different, check the source.

• Make Help Center, Webhooks: queues, default responses, parallel processing and the deactivation of unused webhooks.
• Make apps documentation, Webhooks: the Custom webhook module, API key authentication, data structures, request headers and Detect new values.
• Make apps documentation, HTTP: the Make a request module and its JSON body.
• Make apps documentation, API key authentication type: the keychain fields.
• Make Help Center, Filtering, and General functions for ifempty.
• ZapClaw: webhooks, signature verification and sending a text in the docs.
• Make Help Center, Scenario settings and Overview of error handling: deactivation at the first error, incomplete executions and the Skip and Resume handlers.