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:

  1. Which build route: WhatsApp Manager drag-and-drop, Flows JSON in the builder, or the Flows API.
  2. How many screens, and what each one collects. Three to five is the working rule.
  3. Whether you need an endpoint for live data (free slots, stock, prices) and for branching.
  4. 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:

SituationBest optionWhy
Customer is already in a WhatsApp chat and wants to book, order or registerWhatsApp FlowOne tap, no context switch, validated input
Click-to-WhatsApp ad or in-store QR brought them to the chatWhatsApp Flow inside the 72-hour windowZero message fees and no website drop-off
Choosing between many products with specs, images, comparisonsWeb pageScreens are a poor catalogue; five or more options per control is already too many
High-consideration sale needing questions, negotiation, exceptionsHuman agent, then a Flow to capture the outcomeStructure after the conversation, not instead of it
Complex document upload, multi-page applications, KYC beyond a photoWeb or branch visitFlows are for short structured steps
Order or booking confirmation after paymentUtility template messageCheaper 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:

RouteWhat it isSkill neededLive dataVersioningUse it when
WhatsApp Manager form templateDrag-and-drop screens inside WhatsApp ManagerNoneNoRecreate to changeLead capture, feedback, simple registration with fixed options
Flows Builder + Flows JSONThe builder UI with a code editor over the underlying Flow JSONComfortable with JSONYes, with an endpointClone and edit the JSONBookings, checkout, anything with dynamic lists
Flows APICreate, publish and update Flows programmatically (clone_flow_id for new versions)EngineeringYesProper version controlMultiple flows, per-branch variants, CI-managed templates

Three rules decide the route in practice:

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:

ScreenWhat the customer doesWhere the data comes fromEndpoint call
SERVICETaps one of two servicesStatic data-source in the Flow JSONNone
DATETaps a dateClinic diary: only days with free slotsdata_exchange, cached 60 seconds
SLOTTaps a timeDiary: free slots for that date, with the doctor's namedata_exchange
DETAILSTypes name, email, notes, taps "Confirm booking"WhatsApp identity supplies the number; form values for the restdata_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

  1. 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.
  2. The agent auto-reply sends the Flow message immediately: flow_action: "data_exchange" so the endpoint is called on open, flow_token set 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"
      }
    }
  }
}
  1. She taps the CTA (10:12:11). The endpoint receives action: "INIT" and returns the SERVICE screen.
  2. She taps "Consultation, AED 450" (10:12:24). data_exchange returns the DATE screen with the next 14 days that have free slots.
  3. She taps "Wed 18 Nov" (10:12:38). data_exchange returns the SLOT screen with seven free times.
  4. 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_exchange creates booking SK-2411-178, keyed on the flow_token, and returns the reserved SUCCESS response.
  5. 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.

StepBooking link in chatWhatsApp Flow in chat
Enquiries in a month600600
Open the booking step62% → 37282% → 492
Complete a booking46% → 17168% → 335
Turn up (78% show rate)133261
Billed at AED 450 averageAED 59,850AED 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:

// 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:

  1. 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").
  2. Atomic inputs over free text. Dropdown, radio group, checkbox group, date picker, input-type: "email" | "phone" | "number", required: true, min-chars and max-chars, min-date and max-date. Free text is for one field at most, with validation and a fallback if parsing fails.
  3. 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.
  4. Idempotency is not optional. Webhooks re-deliver on exponential backoff and users re-tap submit. Key your writes on the message identifier (umid or message.id) and on flow_token, and persist flow state so a resumed session continues rather than restarts.
  5. 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".
  6. 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.
  7. 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.
  8. 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:

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

  1. 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.
  2. 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.
  3. 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.

WhatsApp FlowsWhatsApp Business APIconversational commercebooking systemsdigital marketingUAE
Found this useful? Share it.

Link to this article

Citing this in your own writing? Use the permanent link below.
Permalink
https://www.azrty.com/blog/whatsapp-flows-build-a-booking-or-checkout-inside-the-chat-uae-guide
HTML
<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)
Get a readiness assessmentOne call to find where AI will pay off in your business.
Related
WhatsApp Flows: build a booking or checkout inside the chat (UAE guide) | Azrty