Build a WhatsApp AI Assistant for Your Salon: The API Layer You Build On

Your front desk answers the same five questions every day:

"Do you have openings this week?" "How much is a balayage?" "Can I ask a few questions before I book?" "What time do you close?" "Do you do keratin treatments?"

They answer them on WhatsApp. They answer them on Instagram. They answer them in between checking people in, mixing color, and trying to eat lunch. And at 9pm, when a new client messages about Saturday, nobody replies. By morning, that client has gone somewhere else.

This is a first-contact problem, and you can solve it with software you build yourself. Not a hire. Not a packaged "bot service" you rent and hope it fits. With Wabery, you get the messaging primitives, a unified WhatsApp + Instagram + Messenger API, signed event webhooks, native WhatsApp Flows (in-chat forms), automations, a CLI and an MCP server, and you assemble the exact assistant your salon needs.

This post walks through what that assistant looks like and how you build it.

What You're Actually Building

The job breaks into three moving parts, and Wabery gives you a primitive for each:

You don't have to build all three on day one. A single auto-reply on a webhook is a useful afternoon. A full qualify-and-hand-off loop is a weekend. Either way, you own it and can change it whenever your menu or pricing changes.

1. Receive Every Message in One Place

WhatsApp and Instagram have different APIs. Wabery normalizes them so you subscribe once. Point a signed webhook at your server and you get a clean, channel-agnostic event for every inbound message:

// POST /webhooks/wabery
app.post("/webhooks/wabery", verifyWaberySignature, async (req, res) => {
  const event = req.body;
  if (event.type === "message.received") {
    await handleInbound(event.conversationId, event.channel, event.text);
  }
  res.sendStatus(200);
});

The signature check means you can trust the payload came from Wabery and nobody else. From here, handleInbound is your code, you decide what a "balayage pricing" message should do.

2. Answer the Obvious Questions Yourself

You know your menu better than any vendor's default bot. Wire your reply logic to whatever you like, a lookup table for fast facts, or an LLM call with your service list in the prompt for natural conversation:

async function handleInbound(conversationId, channel, text) {
  const reply = await draftReply(text); // your function: rules, LLM, whatever
  await wabery.messages.send({ conversationId, text: reply });
}

A pricing question gets a real answer, not "visit our website." A service comparison ("highlights vs balayage?") gets explained the way a stylist would, because you control the knowledge that goes into the reply. Build it with a few canned answers first, swap in an LLM when you want it more conversational. The send API is the same either way.

3. Collect What Your Team Needs with a WhatsApp Flow

This is the piece most "chatbot" tools can't do well. A WhatsApp Flow is a native in-chat form, the client fills it out inside WhatsApp, no link-outs, no web forms. You define it once as JSON and trigger it when a conversation looks like a real lead:

{
  "name": "new_client_intake",
  "screens": [{
    "title": "Quick questions",
    "fields": [
      { "type": "text",    "name": "hair_length", "label": "Roughly how long is your hair now?" },
      { "type": "boolean", "name": "box_dye",     "label": "Box dye in the last 6 months?" },
      { "type": "date",    "name": "preferred",   "label": "When were you hoping to come in?" },
      { "type": "phone",   "name": "phone",        "label": "Best number to reach you?" }
    ]
  }]
}

When the client submits, Wabery fires a flow.completed webhook with the structured answers. Now you have hair length, a box-dye red flag, a timeline, and a phone number, clean data, not a paragraph you have to re-read. You decide where it goes next: your inbox, a Slack ping, a row in your booking sheet, a record in your CRM.

if (event.type === "flow.completed" && event.flow === "new_client_intake") {
  const lead = event.responses;
  await notifyTeam(lead);          // your own "hot lead" alert, however you want it
  await saveToWherever(lead);      // your CRM, sheet, DB, whatever you already use
}

That's lead qualification, built by you, in an afternoon. No vendor deciding what "qualified" means. You wrote the questions and the routing.

A Full Conversation, Powered by What You Built

New Client: "Hi! Love the color transformations on your Instagram. Thinking about a full balayage, how much and how soon could I come in?"

Your assistant: "Thank you! Balayage starts at $185 for medium-length hair, $225 for long. Mind answering a couple of quick questions so we can match you with the right stylist?" (then triggers the new_client_intake Flow)

New Client: (fills out the in-chat form: past shoulders, no box dye, next week, 555-0123)

Your assistant: "Perfect, that's $185. Our team will reach out tomorrow morning with a couple of options for next week. Talk soon!"

By morning, your front desk opens a tidy lead, service, price range, hair length, timeline, phone, and spends five minutes booking it in whatever scheduler you already use (Fresha, Boulevard, Vagaro). Every step there is code you wrote on primitives Wabery provides.

The After-Hours Win Comes for Free

Roughly 35-40% of inquiries land outside business hours. Because your webhook handler runs whenever a message arrives, the assistant you built replies at 10:30pm on a Tuesday whether or not anyone's awake. You don't operate it. It just runs on the infrastructure.

Instagram DMs Too, Same Code

Because Wabery's channels API is unified, the handler you wrote for WhatsApp also handles Instagram DMs, same event shape, same send call. (Instagram is DM-only; story replies arrive as DMs and flow through the same handler.) You write the logic once and it covers every channel you connect.

Where to Draw the Line

Build the repetitive first-contact part. Leave the rest to people:

• Your stylists' expertise in real consultations
• Your booking software. Wabery doesn't touch your calendar; you keep Fresha/Boulevard/Vagaro and write whatever integration (or none) you want.
• Complaints and judgment calls. Detect them in your handler ("unhappy with the color") and route straight to a human with full context.

The point isn't removing people. It's that you, the builder, get to decide exactly what gets automated and how, instead of accepting a packaged tool's opinion.

Speed It Up with the CLI and MCP Server

You don't have to start from a blank file. The Wabery CLI scaffolds webhook handlers, registers Flows, and tails events locally so you can iterate fast:

wabery flows deploy new_client_intake.json
wabery events tail            # watch live webhook events while you build

And the MCP server lets you build and debug all of this from inside your AI coding tool, ask it to draft a Flow or a handler and it has Wabery's primitives in context.

What It Costs

Free: Includes 5 monthly credits so you can build against real inbound conversations and validate your assistant before committing.

Pro ($29/month): Higher volume for production use, no contract.

All plans give you the same API across WhatsApp, Instagram, and Messenger.

How to Start

1. Create a project and connect your WhatsApp Business number (5 minutes)
2. Point a webhook at your handler, reply to your first message
3. Add a WhatsApp Flow for intake, route the responses where you want them

You ship a useful assistant the first afternoon, then keep shaping it as you learn what your clients actually ask.

---

Related reads:

• WhatsApp AI Assistant for Free in 2026, what you can build on the free plan
• Set Up a WhatsApp AI Agent in 10 Minutes, a fast first-build walkthrough