WhatsApp Flows: build a booking or checkout inside the chat (UAE guide)
Every business that sells over WhatsApp in the UAE has the same leak: the customer is ready in the chat, an agent sends a link to a website to book a slot or pay, and a large share of those customers never come back. WhatsApp Flows close that gap by putting the booking form, the live slot list and the checkout inside the WhatsApp thread. This guide covers the three build routes (WhatsApp Manager, Flows JSON, the Flows API), the endpoint contract that makes live availability work, the webhook rules that stop you double-booking, and the completion-rate rules that decide whether the thing converts at all.
What you are building, and what it costs
A Flow is a small structured application that runs inside a WhatsApp chat. You send an interactive message with a Flow button; tapping it opens a series of screens built from dropdowns, radio buttons, date pickers, checkboxes and text inputs. The customer fills them in without leaving WhatsApp, and on submission your diary, CRM or order system receives validated data. Meta's framing is "interactive forms inside chat", and the Flow JSON guide defines the structure: screens with an id, a layout, optional dynamic data declared as JSON Schema, and a routing_model whenever an endpoint drives the navigation.
Building one comes down to four decisions:
- Which build route: WhatsApp Manager drag-and-drop, Flows JSON in the builder, or the Flows API.
- How many screens, and what each one collects. Three to five is the working rule.
- Whether you need an endpoint for live data (free slots, stock, prices) and for branching.
- What happens on completion: a webhook that writes the booking or order and sends the confirmation.
Cost first, because it is the first question we get. Meta does not charge for the Flows feature itself. You pay for the message that carries the Flow button, at normal WhatsApp Business API rates: on a UAE number, a marketing template costs $0.0576 per delivered message from 1 October 2026, a utility template $0.0157, and a reply inside the customer service window is free up to 1,000 messages per phone number per month before $0.0157 each. Inside the 72-hour window opened by a click-to-WhatsApp ad, every template category is free. The full rate card and the October 2026 changes are in our WhatsApp Business API pricing piece. The short version: the message fee is not why you build a Flow. The leak is.
When a Flow beats a web form
A Flow is not a replacement for your website. It is the right tool for one job: closing a structured transaction with someone who is already talking to you. The decision table we use with clients:
| Situation | Best option | Why |
|---|---|---|
| Customer is already in a WhatsApp chat and wants to book, order or register | WhatsApp Flow | One tap, no context switch, validated input |
| Click-to-WhatsApp ad or in-store QR brought them to the chat | WhatsApp Flow inside the 72-hour window | Zero message fees and no website drop-off |
| Choosing between many products with specs, images, comparisons | Web page | Screens are a poor catalogue; five or more options per control is already too many |
| High-consideration sale needing questions, negotiation, exceptions | Human agent, then a Flow to capture the outcome | Structure after the conversation, not instead of it |
| Complex document upload, multi-page applications, KYC beyond a photo | Web or branch visit | Flows are for short structured steps |
| Order or booking confirmation after payment | Utility template message | Cheaper and clearer than a Flow screen |
The pattern that works in the UAE for clinics, salons, hospitality and e-commerce is hybrid: the ad or the agent starts the conversation, the Flow finishes the structured part, a template confirms it. Influencer Marketing Hub's checkout guide draws the same line: click-to-WhatsApp campaigns open conversations, Flows complete structured actions. Do not send a Flow to a cold list as a first touch. It reads as a form, and forms do not start relationships.
Two practical qualifiers. First, if your customer is on desktop all day and the task involves reading, a web page still wins. Second, in-chat card payment inside a Flow is not the reliable route for a UAE business today. End the Flow with a payment link from your gateway (Telr, Network International, Checkout.com, Stripe, or a BNPL provider) and treat the paid webhook as the commit. Never collect card numbers in a Flow: the 8x8 Flows best practices are explicit that full card numbers, PINs and passwords stay out of Flows entirely.
Three build routes: Manager, Flows JSON, Flows API
Pepper Cloud's build walkthrough lays out the same three routes we see clients choose between:
| Route | What it is | Skill needed | Live data | Versioning | Use it when |
|---|---|---|---|---|---|
| WhatsApp Manager form template | Drag-and-drop screens inside WhatsApp Manager | None | No | Recreate to change | Lead capture, feedback, simple registration with fixed options |
| Flows Builder + Flows JSON | The builder UI with a code editor over the underlying Flow JSON | Comfortable with JSON | Yes, with an endpoint | Clone and edit the JSON | Bookings, checkout, anything with dynamic lists |
| Flows API | Create, publish and update Flows programmatically (clone_flow_id for new versions) | Engineering | Yes | Proper version control | Multiple flows, per-branch variants, CI-managed templates |
Three rules decide the route in practice:
- Start in the builder even if you will end in the API. Meta's appointment tutorial does exactly this: create the flow from the "Book an appointment" template in WhatsApp Manager (Account tools → Flows), then add the endpoint. The builder generates response snippets for you under "..." → Endpoint → Snippets → Responses, which you will want in your endpoint code.
- Finish the endpoint before you publish. The same tutorial is blunt: once a Flow is published you cannot edit it. Leave it in draft while you wire the data channel, run the health check, then publish. Plan later changes as a new version.
- Budget for template approval. If the Flow goes out as a template message rather than inside an open conversation window, the template carrying the Flow button needs Meta approval, typically 24 to 48 hours, and the category (utility or marketing) decides the per-message price. Choose utility for bookings and order actions and keep promotional lines out of it.
If the integration work (endpoint, diary API, webhook, CRM writes) is more than your team has hands for, that is the plumbing our AI engineering service builds and keeps working.
Worked example: a Dubai clinic, four screens, live slots
Take a two-branch aesthetics clinic in Dubai. Two dermatologists, 20-minute slots, open 09:00 to 13:00 and 16:00 to 20:00, Monday to Saturday. That is 24 slots per doctor per day, 48 a day across both, 288 a week. Existing bookings fill 62%, leaving roughly 109 free slots a week to sell. Two services: consultation at AED 450 and follow-up at AED 250. Today an agent answers each enquiry in chat and pastes a booking link.
The screens
Four screens, one topic each, matching the pattern in Watheta's appointment booking build:
| Screen | What the customer does | Where the data comes from | Endpoint call |
|---|---|---|---|
| SERVICE | Taps one of two services | Static data-source in the Flow JSON | None |
| DATE | Taps a date | Clinic diary: only days with free slots | data_exchange, cached 60 seconds |
| SLOT | Taps a time | Diary: free slots for that date, with the doctor's name | data_exchange |
| DETAILS | Types name, email, notes, taps "Confirm booking" | WhatsApp identity supplies the number; form values for the rest | data_exchange, final |
Note the ordering: commitment first, typing last. Dropdowns and date pickers are single taps; free text is where people abandon. Watheta's variant puts personal details first, and Meta's "Book an appointment" template runs appointment → details → summary → terms. Either works; what matters is that the screens are few and the inputs are constrained.
The journey, second by second
- Amina taps a click-to-WhatsApp ad for a skin consultation. WhatsApp opens and she sends the pre-filled message. That opens the 72-hour free entry point window.
- The agent auto-reply sends the Flow message immediately:
flow_action: "data_exchange"so the endpoint is called on open,flow_tokenset to a random session identifier, CTA "Book a slot".
{
"messaging_product": "whatsapp",
"to": "<msisdn>",
"type": "interactive",
"interactive": {
"type": "flow",
"body": { "text": "Let's find you a slot. It takes under a minute." },
"action": {
"name": "flow",
"parameters": {
"flow_id": "<FLOW_ID>",
"flow_message_version": "3",
"flow_token": "<UNPREDICTABLE_SESSION_TOKEN>",
"flow_cta": "Book a slot",
"flow_action": "data_exchange"
}
}
}
}
- She taps the CTA (10:12:11). The endpoint receives
action: "INIT"and returns the SERVICE screen. - She taps "Consultation, AED 450" (10:12:24).
data_exchangereturns the DATE screen with the next 14 days that have free slots. - She taps "Wed 18 Nov" (10:12:38).
data_exchangereturns the SLOT screen with seven free times. - She taps "17:20 with Dr Haddad" (10:12:49), types her name and email, and taps "Confirm booking" (10:13:03). The final
data_exchangecreates booking SK-2411-178, keyed on theflow_token, and returns the reservedSUCCESSresponse. - The completion webhook fires (
nfm_reply), deduplicates on the message id, writes the booking to the CRM and sends a utility confirmation template with the booking reference and directions.
Fifty-two seconds from ad tap to confirmed booking, with no agent typing and no website.
What that is worth
The clinic takes 600 inbound booking enquiries a month across ads, organic and referrals. The figures below are assumptions to show the method, not promises. Run your own.
| Step | Booking link in chat | WhatsApp Flow in chat |
|---|---|---|
| Enquiries in a month | 600 | 600 |
| Open the booking step | 62% → 372 | 82% → 492 |
| Complete a booking | 46% → 171 | 68% → 335 |
| Turn up (78% show rate) | 133 | 261 |
| Billed at AED 450 average | AED 59,850 | AED 117,450 |
On those assumptions the Flow adds 128 kept appointments and about AED 57,600 a month, roughly AED 691,000 a year, from the same lead volume and the same ad spend. The capacity check matters: 335 Flow bookings sit comfortably inside the roughly 470 slots the diary leaves free each month, so these are real bookings, not overbooking. Message fees are a rounding error either way: 600 Flow messages cost $34.56 as marketing templates (about AED 127), and inside the service window the first 1,000 per number per month are free, so the flow costs nothing in message fees at all.
The endpoint and the webhook: live availability without double-booking
The endpoint is what makes slot lists live. Meta's endpoint implementation guide is the contract you build to:
- One HTTPS
POSTroute with a valid TLS certificate. The body carriesencrypted_flow_data,encrypted_aes_keyandinitial_vector; you decrypt with your private key and passphrase, and encrypt the response with the AES key and IV from the request. You upload the matching public key through the Graph API. Check the request signature against your app secret first and return status 432 if it does not match. - Six kinds of request arrive:
INITon open,data_exchangeon screen submit,BACKifrefresh_on_backis set,on-select-actionwhen a control changes, an error notification withdata.error, and a health check withaction: "ping"that must answer{ "version": ..., "data": { "status": "active" } }before you can publish. - Data exchange payloads use
version: "3.0"and carryscreen,action,dataandflow_token. Newer flows (version 7.3 and above, withdata_api_version4.0 and above) also send aflow_token_signatureJWT that you can verify against the app secret. - Responses:
{ "screen": "<NEXT>", "data": { ... } }to advance (adderror_messageinsidedatato show a snackbar on the current screen), and the reservedSUCCESSscreen to close, carryingextension_message_response.params.flow_token.SUCCESScannot be used as a screen id. - Requests to the data endpoint time out after 10 seconds, per Meta's Flows best practices. Cache unchanged data and make slow third-party calls asynchronously.
// POST /flows/clinic: WhatsApp Flows data endpoint
app.post("/flows/clinic", async (req, res) => {
if (!isRequestSignatureValid(req)) return res.status(432).send();
const { aesKeyBuffer, initialVectorBuffer, decryptedBody } =
decryptRequest(req.body, PRIVATE_KEY, PASSPHRASE);
const { action, screen, data, version, flow_token } = decryptedBody;
let response;
if (action === "ping") {
response = { version, data: { status: "active" } };
} else if (data?.error) {
response = { version, data: { acknowledged: true } };
} else if (action === "INIT") {
response = { screen: "SERVICE", data: { services: SERVICES } };
} else if (action === "data_exchange" && screen === "SERVICE") {
response = { screen: "DATE", data: { dates: await freeDates(data.service) } };
} else if (action === "data_exchange" && screen === "DATE") {
response = { screen: "SLOT", data: { slots: await freeSlots(data.date) } };
} else if (action === "data_exchange" && screen === "SLOT") {
response = { screen: "DETAILS", data: { phone: await phoneFor(flow_token) } };
} else if (action === "data_exchange" && screen === "DETAILS") {
// Commit here, not in the webhook: the slot is time-critical.
// Idempotent on flow_token, so a replay cannot double-book.
const booking = await bookSlot({ ...data, flow_token });
response = {
screen: "SUCCESS",
data: {
extension_message_response: {
params: { flow_token, booking_ref: booking.ref }
}
}
};
}
res.send(encryptResponse(response, aesKeyBuffer, initialVectorBuffer));
});
Two performance habits from the same doc that matter more than they look. Do not call the endpoint when you do not need to: if the first screen's data is known when you send the message, omit flow_action and pass it in flow_action_payload.data instead, and use "name": "navigate" rather than data_exchange on a footer when the next screen is already known. And set flow_token expiry to two to three days so a customer who opens the message tomorrow can still finish.
The completion webhook is a separate channel, and its rules are stricter than people expect. On the Cloud API, a finished Flow arrives as an interactive message of type nfm_reply; through BSPs such as 8x8 it arrives as an inbound_message_received event of type nfmReply with responseJson as a JSON string you must parse. 8x8's webhook documentation requires a 200 OK within 5 seconds, retries failed deliveries with exponential backoff, and tells you to deduplicate on umid.
app.post("/webhooks/whatsapp", async (req, res) => {
res.status(200).send("OK"); // ACK inside 5 seconds, then work
const { payload } = req.body;
if (payload?.type !== "Interactive") return;
if (payload.content.interactive.type !== "nfmReply") return;
const submission = JSON.parse(payload.content.interactive.nfmReply.responseJson);
if (await isProcessed(payload.umid)) return; // retries re-deliver
await markProcessed(payload.umid);
await syncCrm(submission); // the booking already exists
await sendConfirmation(payload.user.msisdn, submission.booking_ref);
});
Completion-rate rules that decide the outcome
The difference between a Flow that books 335 appointments a month and one that books 171 is design discipline, not technology. These are the rules we hold clients to, drawn from the 8x8 best practices and Meta's Flows guidance:
- Three to five screens. Long flows get abandoned. Group related fields on one screen, collect only what the next action needs, and label progress ("Step 2 of 4").
- Atomic inputs over free text. Dropdown, radio group, checkbox group, date picker,
input-type: "email" | "phone" | "number",required: true,min-charsandmax-chars,min-dateandmax-date. Free text is for one field at most, with validation and a fallback if parsing fails. - Put the summary before the submit. Show the service, date, time, doctor and price on the terminal screen, with the booking as one button. Terminal screens must carry a Footer component.
- Idempotency is not optional. Webhooks re-deliver on exponential backoff and users re-tap submit. Key your writes on the message identifier (
umidormessage.id) and onflow_token, and persist flow state so a resumed session continues rather than restarts. - Respect both clocks. Acknowledge the completion webhook within 5 seconds and queue the real work. Answer the data endpoint well inside its 10-second timeout. A slow diary API is the most common cause of flows that "don't work".
- Validate on the server too. Client-side validation is convenience, not security. Treat submissions as untrusted input: check types, sanitise before storage, rate-limit, and log the raw payload for debugging.
- Test on real phones before you publish. Use "Send Test Message" in draft, complete the flow with valid and deliberately invalid data, confirm the webhook payload parses, and confirm the duplicate path is safe. 8x8's testing checklist is a good copy-and-tick list.
- Localise the form. UAE address capture wants an emirate dropdown, area, building or villa, and a landmark, not a generic "city, state, postcode". Arabic labels and error messages matter if your audience is mixed.
Measuring what the Flow earns
Flows are measurable in a way chat is not. Track four numbers per flow, weekly at first:
- Start rate: taps on the Flow button as a share of messages sent. Low means the CTA or the offer is weak, not the flow.
- Completion rate: submissions as a share of opens. Below 60% on a four-screen booking flow, look at screen length and free-text fields first.
- Abandonment by screen: where people drop out. This is the single most useful number in Flows analytics.
- Completion time: a median above about two minutes means you are asking for too much.
Then connect the two halves commercially. Pass the flow_token and the booking_ref or order id into your CRM and analytics, fire server-side events to the Conversions API so Meta can attribute the click-to-WhatsApp ad to the completed booking, and hold out a slice of your ad audience so you can see which bookings the ad actually caused. On the money side, keep splitting spend into push (marketing templates at $0.0576) and pull (inbound conversations where the Flow does the closing), as we set out in the pricing article. Flows make pull more valuable: every inbound conversation is a chance to complete a transaction at no message cost.
What to do next
- This week: pick one journey that leaks today (appointment booking, table reservation, reorder, salon slot). Map it as it runs in chat now, count the enquiries per month, and count how many become transactions. That number is the size of the prize.
- This month: build the four-screen version in WhatsApp Manager from the "Book an appointment" template, wire a minimal endpoint against your diary or order system, and run it with one branch or one agent's queue as a pilot. Measure start rate, completion rate and completion time from day one.
- This quarter: move the winner into the Flows API under version control, add the idempotent webhook and CRM writes, extend the same pattern to a second journey (checkout for repeat orders, or deposits for no-shows), and put the four measurement numbers on a monthly dashboard.
We are a UAE company based in Dubai, and our own team does the deployment and support here. If you want a hand choosing the journey, sizing the prize and building the flow end to end, that is where our digital transformation engagement starts.
Link to this article
Citing this in your own writing? Use the permanent link below.https://www.azrty.com/blog/whatsapp-flows-build-a-booking-or-checkout-inside-the-chat-uae-guide
<a href="https://www.azrty.com/blog/whatsapp-flows-build-a-booking-or-checkout-inside-the-chat-uae-guide">WhatsApp Flows: build a booking or checkout inside the chat (UAE guide)</a> (Azrty)
