WhatsApp Business API for client confirmation request

Use case overview

The scenario sends the client a personalised WhatsApp template asking them to confirm or cancel a planned action. The message includes the client name, action label, date and time, and address. Quick-reply buttons «Confirm» and «Cancel» route the client's choice via webhook to your backend.

Template example

Hello, {{1}}! Please confirm {{2}}. Date and time: {{3}}. Address: {{4}}. If you need help — just reply to this message and we will assist.

[Confirm]

Quick-reply button labels are fixed in the Meta template — only body variables are sent via the API; taps return via webhook.

Variables and purpose

• {{1}} — customer name
• {{2}} — action or subject to confirm (e.g. consultation booking, home delivery)
• {{3}} — date and time (e.g. 15 July, 14:00)
• {{4}} — address or location (e.g. street address or pickup point)

Filled-in example

Hello, Andrey! Please confirm consultation appointment. Date and time: July 15, 2:00 PM. Address: 10 Example Street. If you need help — just reply to this message and we will assist.

[Confirm]

When to use it

• appointments and field service
• logistics
• agencies

Business value

• Back office or workflow triggers a confirmation request event
• System resolves recipient phone and confirmation details
• Template message is built with four body variables and two quick-reply buttons
• Client receives the WhatsApp confirmation request
• Confirm or cancel tap is processed via webhook to update the booking or process

Workflow

1. The scheduling system, CRM, or workflow emits a confirmation-request event.
2. The system resolves the recipient phone number and confirmation fields.
3. A personalised template message is built with four body variables and two quick-reply buttons.
4. The client receives the WhatsApp confirmation request.
5. When the client taps Confirm or Cancel, the webhook delivers the event for backend processing.
6. Delivery progress is reported asynchronously — typically sent, then delivered (or failed/undelivered).
7. Your system receives status via webhook (hooks[]) or polls GET …/hookInfo?messageId=<id> and handles failures if needed.

Technical implementation

Prerequisites

• A 1MSG account with WhatsApp Business API connected and an approved message template with two quick-reply buttons.
• Customer phone number in international format (without + and spaces).
• Confirmation payload: customer name, action label, date/time, address.
• HTTPS webhook endpoint to receive quick-reply button events.

Code examples

Node.js

#!/usr/bin/env node

// === Configuration (replace "___" placeholders) ===

const API_BASE_URL = "https://api.1msg.io"; // production 1MSG API base URL
const CHANNEL_ID = "___";                   // channel ID from 1MSG dashboard
const API_TOKEN = "___";                    // channel JWT token (Bearer)

const TEMPLATE_NAME = "___";                // approved template name
const TEMPLATE_NAMESPACE = "___";           // template namespace (422 without it)
const TEMPLATE_LANGUAGE = "___";            // template language code, e.g. "en"



// === Test data ===
const TEST_PHONE = "___";            // client phone in international format
const TEST_CUSTOMERNAME = "___";    // {{1}} customer name
const TEST_ACTION = "___";    // {{2}} action name
const TEST_DATE = "___";    // {{3}} date or time
const TEST_ADDRESS = "___";    // {{4}} address or location

function normalizePhone(phone) {
  return String(phone).replace(/\D/g, "");
}

function assertConfigured(values) {
  for (const [key, value] of Object.entries(values)) {
    if (value === "___" || value === "" || value === undefined || value === null) {
      throw new Error(`Missing configuration value: ${key}`);
    }
  }
}

async function sendTemplateMessage({ phone, customerName, action, date, address }) {
  assertConfigured({
    CHANNEL_ID,
    API_TOKEN,
    TEMPLATE_NAME,
    TEMPLATE_NAMESPACE,
    TEMPLATE_LANGUAGE,
    phone,
    customerName,
    action,
    date,
    address,
  });

  const url = `${API_BASE_URL}/${CHANNEL_ID}/sendTemplate`;

  // params carries body and button blocks (dynamic buttons).
  const requestBody = {
    phone: normalizePhone(phone),
    template: TEMPLATE_NAME,
    namespace: TEMPLATE_NAMESPACE,
    language: {
      policy: "deterministic",
      code: TEMPLATE_LANGUAGE,
    },
    params: [
      {
        type: "body",
        parameters: [
          { type: "text", text: String(customerName) }, // {{1}} customer name
          { type: "text", text: String(action) }, // {{2}} action name
          { type: "text", text: String(date) }, // {{3}} date or time
          { type: "text", text: String(address) }, // {{4}} address or location
        ],
      },
    ],
  };

  const res = await fetch(url, {
    method: "POST",
    headers: {
      "Content-Type": "application/json",
      Authorization: `Bearer ${API_TOKEN}`,
    },
    body: JSON.stringify(requestBody),
  });

  const raw = await res.text();
  let data;
  try {
    data = JSON.parse(raw);
  } catch {
    data = null;
  }

  if (!res.ok || !data || data.sent !== true) {
    console.error("Send failed. API response:");
    console.error(raw);
    process.exit(1);
  }

  console.log("Message sent to client.");
  console.log("API response:", raw);
  return data;
}

function handleIncomingMessage(message) {
  const text = (message && (message.text || message.body || "")).trim();
  // Meta quick_reply label (from template.txt) → route key (code_contract.ref) "confirm"
  if (text === "Подтвердить") {
    console.log("Reply received: confirm");
    return { status: "confirm" };
  }
  // Meta quick_reply label (from template.txt) → route key (code_contract.ref) "cancel"
  if (text === "Отменить") {
    console.log("Reply received: cancel");
    return { status: "cancel" };
  }
  console.log("Free-text reply — handle separately.");
  return { status: "other" };
}

if (require.main === module) {
  sendTemplateMessage({
    phone: TEST_PHONE,
    customerName: TEST_CUSTOMERNAME,
    action: TEST_ACTION,
    date: TEST_DATE,
    address: TEST_ADDRESS,
  }).catch((err) => {
    console.error("Execution failed:", err.message);
    process.exit(1);
  });
}

module.exports = { sendTemplateMessage, handleIncomingMessage };

Immediate API response (synchronous)

• HTTP 2xx and JSON "sent": true mean 1MSG accepted the message for sending — not that it already reached the customer's phone.
• Save the `id` field from the response (value looks like wamid.…). Use it to correlate delivery callbacks or polling.
• The response may also include message and description — informational only.

Delivery status (asynchronous)

• Register a webhook (POST …/webhook) so 1MSG POSTs delivery updates to your HTTPS endpoint in a separate `hooks[]` payload (sent, delivered, read, or failed/undelivered when applicable).
• Optionally poll: GET {base}/{channel}/hookInfo?messageId=<id from sendTemplate>.
• In practice, delivery often completes within a few seconds — but that is not guaranteed by the API contract.

Common errors

• Invalid or non-normalized phone number
• Unapproved or missing template name / namespace
• No customer opt-in for WhatsApp business messages
• Template variable count mismatch (422 from API)
• Delivery failure — check status webhook and retry policy

FAQ

• Do I need an approved template? Yes — cold-start WhatsApp messages require a Meta-approved template.
• Can I customize the message text? Body variables are dynamic; fixed text and button labels are set in the Meta template.
• How do I check delivery? sent: true only confirms acceptance. Track delivery via webhook hooks[] or GET …/hookInfo?messageId=<id>.
• What if the message is not delivered? Log the failed/undelivered hook, verify opt-in and template status, then retry or fall back to another channel.
• Can I connect this to my CRM or backend? Yes — trigger the API call from your platform webhook or event handler.

CTA

Ready to use client confirmation request? Connect your 1MSG channel and run the code examples above.

Related

• Knowledge base
• Creating a template
• Sending a template
• SDK