Build a WhatsApp Order-Bot for a Sweet Shop in One Weekend (Hindi + GST-Ready)

A sweet shop in Kanpur was taking Diwali orders on a personal WhatsApp number — one cousin typing replies, losing track of who ordered what, and hand-writing bills with the wrong GST. Over one weekend in August 2025 we built a WhatsApp bot that takes the order in Hindi, confirms quantities, shows a GST-correct bill, and drops every order into a Google Sheet the counter watches. WhatsApp Cloud API for messaging, OpenAI for understanding the Hindi, a tiny GST calculator for the bill. Here's the full build — including the festive-load gotcha that nearly broke it. ## The 60-Word Answer Use the WhatsApp Cloud API to receive and send messages via webhook. Pass each incoming Hindi message to OpenAI with a system prompt and an order-taking function, so the model extracts items and quantities from natural language. Run the items through a small GST calculator (most packaged mithai is 5%), reply with an itemised bill, and log confirmed orders to a Google Sheet. The whole thing is one webhook handler. ## Why a Bot, Not Just a Person on WhatsApp A person on WhatsApp works until festive rush, when 200 messages arrive in an hour and orders get lost between "2 kg kaju katli" and "wait make it 1.5." A bot reads every message, never loses an order, and produces a consistent, GST-correct bill — which matters because hand-written festive bills are where small shops get GST wrong and where buyers who want input credit walk away. The bot doesn't replace the shop's warmth; it replaces the dropped orders and the wrong arithmetic during the three weeks a year that decide the shop's revenue. ## What You'll Need ## Step 1: Receive WhatsApp Messages via Webhook The Cloud API calls your webhook on every incoming message. You verify the webhook once, then handle message events.

// webhook.js
  import express from "express";
  const app = express();
  app.use(express.json());
  
  // Meta verifies your webhook once with a GET
  app.get("/webhook", (req, res) => {
    const VERIFY = process.env.WA_VERIFY_TOKEN;
    if (req.query["hub.verify_token"] === VERIFY) {
      return res.send(req.query["hub.challenge"]);
    }
    res.sendStatus(403);
  });
  
  // Incoming messages arrive as POST
  app.post("/webhook", async (req, res) => {
    res.sendStatus(200); // ACK immediately — process async
    const msg = req.body?.entry?.[0]?.changes?.[0]?.value?.messages?.[0];
    if (!msg || msg.type !== "text") return;
    await handleMessage(msg.from, msg.text.body);
  });

## Step 2: Understand the Order With OpenAI A function-calling prompt turns messy Hindi into structured items. The model extracts; it does not price.

// understand.js
  import OpenAI from "openai";
  const openai = new OpenAI();
  
  const MENU = "kaju katli, soan papdi, motichoor ladoo, gulab jamun, barfi";
  
  const tools = [{
    type: "function",
    function: {
      name: "record_order_items",
      description: "Record the sweets the customer wants, with quantity and unit.",
      parameters: {
        type: "object",
        properties: {
          items: {
            type: "array",
            items: {
              type: "object",
              properties: {
                name: { type: "string", description: one of: ${MENU} },
                qty:  { type: "number" },
                unit: { type: "string", enum: ["kg", "box", "piece"] }
              },
              required: ["name", "qty", "unit"]
            }
          }
        },
        required: ["items"]
      }
    }
  }];
  
  export async function understand(history) {
    const system = You take sweet-shop orders on WhatsApp for a Kanpur mithai shop.
  Customers write in Hindi or Hinglish. Menu: ${MENU}.
  Extract items, quantity and unit. Ask a short clarifying question if unclear.
  Reply warmly in the customer's language. Do NOT calculate prices — that is done separately.;
    return openai.chat.completions.create({
      model: "gpt-4o-mini",
      messages: [{ role: "system", content: system }, ...history],
      tools, tool_choice: "auto", temperature: 0.3
    });
  }

## Step 3: The GST-Correct Bill (Code, Not the Model) This is the part you must keep out of the LLM. Tax math goes in a small, testable function. Most packaged Indian sweets fall under 5% GST, split as 2.5% CGST + 2.5% SGST for an intra-state sale — but always confirm rates with the shop's CA, since some items differ.

// gst.js
  const PRICES = {                 // per unit, in ₹
    "kaju katli":      { kg: 900 },
    "soan papdi":      { box: 250, kg: 500 },
    "motichoor ladoo": { kg: 400 },
    "gulab jamun":     { box: 200 },
    "barfi":           { kg: 450 }
  };
  const GST_RATE = 0.05;           // 5% on packaged mithai (confirm per item)
  
  export function buildBill(items) {
    const lines = items.map(it => {
      const unitPrice = PRICES[it.name]?.[it.unit] ?? 0;
      const amount = unitPrice * it.qty;
      return { ...it, unitPrice, amount };
    });
    const subtotal = lines.reduce((s, l) => s + l.amount, 0);
    const gst   = +(subtotal * GST_RATE).toFixed(2);
    const cgst  = +(gst / 2).toFixed(2);
    const sgst  = +(gst / 2).toFixed(2);
    const total = +(subtotal + gst).toFixed(2);
    return { lines, subtotal, cgst, sgst, total };
  }

## Step 4: Reply, Confirm, and Log to the Sheet

// handle.js
  import { understand } from "./understand.js";
  import { buildBill } from "./gst.js";
  
  export async function handleMessage(from, text) {
    const history = loadHistory(from);
    history.push({ role: "user", content: text });
  
    const res = await understand(history);
    const m = res.choices[0].message;
  
    if (m.tool_calls) {
      const { items } = JSON.parse(m.tool_calls[0].function.arguments);
      const bill = buildBill(items);
      const reply =
        bill.lines.map(l => ${l.qty}${l.unit} ${l.name} — ₹${l.amount}).join("\n")
        + \nSubtotal: ₹${bill.subtotal}
        + \nCGST 2.5%: ₹${bill.cgst}  SGST 2.5%: ₹${bill.sgst}
        + \nTotal: ₹${bill.total}\n\nConfirm karein? (haan/nahi);
      await sendWhatsApp(from, reply);
      saveDraftOrder(from, bill);
    } else if (/haan|yes|confirm|ha\b/i.test(text)) {
      const bill = getDraftOrder(from);
      await appendToSheet(from, bill);       // log confirmed order
      await sendWhatsApp(from, "Order confirm! Aapka order taiyaar ho raha hai. Dhanyavaad 🙏");
    } else {
      await sendWhatsApp(from, m.content);   // a clarifying question
    }
  }

## Step 5: Verify Before Diwali ## The Festive-Load Gotcha ## When NOT to Build This ## Real Example: The Kanpur Mithai Shop We shipped the bot above on a weekend. It took orders in Hindi and Hinglish, produced GST-correct bills the shop's CA had pre-approved, and logged confirmed orders to a Sheet the counter watched. The festive-load dedupe fix earned its keep on day one of the rush, when traffic tripled and the naive version would have double-booked. The cousin went back to packing sweets instead of typing. We later generalised this into a full WhatsApp + OpenAI order bot writeup and paired it with a Tally sync that closes the books daily. The same WhatsApp Cloud API foundation runs under our GSTR-3B reminder workflow for a CA firm, and the Hindi-understanding piece reuses the patterns behind TalkDrill, our in-house English-speaking app. Our AI automation team ships these vernacular commerce bots for Indian retailers regularly. ## Frequently Asked Questions ### Is the WhatsApp Cloud API free? The Cloud API itself is free to set up, and service conversations (where the customer messages you first) are free within a rolling window under Meta's current pricing. Business-initiated template messages are charged. For an order bot where customers message first, most conversations cost nothing — but check Meta's latest pricing, which changes. ### Can the WhatsApp bot understand orders written in Hindi? Yes. Passing the message to OpenAI with a function-calling prompt lets the model extract items, quantities, and units from natural Hindi or Hinglish — including corrections like "make it 1.5 kg instead." The model handles the language; a separate code function handles the pricing and GST. ### What GST rate applies to sweets and mithai? Most packaged Indian sweets (mithai) attract 5% GST, split as 2.5% CGST and 2.5% SGST for an intra-state sale. Some items and packaging can differ, so always confirm the exact rate per product with the shop's chartered accountant before wiring it into the billing code. ### Should the AI calculate the GST bill? No. Keep all tax arithmetic in a small, testable code function, never in the language model. Models can be confidently wrong at multi-step math, and an incorrect tax figure on a real bill is a compliance issue. The model extracts the order; deterministic code computes the money. ### How do I stop duplicate orders during a festive rush? Acknowledge Meta's webhook with a 200 response instantly, process the order asynchronously, and dedupe on the message ID (store seen IDs for a few minutes). Meta retries the webhook if you respond slowly under load, which is what causes the same order to land in your log twice. ### How long does it take to build a WhatsApp order bot? A focused engineer can ship a working v1 over a weekend: a few hours for the webhook and WhatsApp send/receive, a few for the OpenAI extraction and the GST calculator with tests, and a few for the Google Sheet logging and a dedupe pass. Menu setup with the shop takes additional coordination time. As Hrishikesh, our CTO, puts it: let the AI read the Hindi, let the code do the maths, and let the shopkeeper pack the sweets. Everyone does what they're good at.