WhatsApp Business API for proposal follow-up reminder

Use case overview

The scenario sends the prospect a personalised WhatsApp template message reminding them to review the commercial proposal. The message contains the prospect's name, the product or service discussed, and a clear recommended next step. A static URL button lets them open the proposal document directly.

Template example

Hi {{1}}, we wanted to follow up on the proposal we sent you for {{2}}. We would love to hear your thoughts - {{3}}. If you have any questions or need more details, feel free to reply to this message.

[View Proposal]

The proposal URL button is fixed in the Meta template — only body variables are sent via the API.

Variables and purpose

• {{1}} — prospect's name
• {{2}} — name of the product or service covered by the proposal
• {{3}} — recommended next step for the prospect (e.g. review, schedule a call, confirm)

Filled-in example

Hi Alex, we wanted to follow up on the proposal we sent you for cloud data storage service. We would love to hear your thoughts - schedule a quick call to discuss next steps. If you have any questions or need more details, feel free to reply to this message.

[View Proposal]

When to use it

• b2b and services
• e-commerce and saas
• agencies and small teams

Business value

• Prospect receives a WhatsApp reminder 1–2 days after the proposal is delivered
• Message is personalised with the prospect's name and the specific offer
• Static URL button lets the prospect open and review the proposal directly
• Recommended next step is communicated clearly in the message body
• Sales team tracks delivery status and can follow up based on the outcome

Workflow

1. The CRM or sales system detects that a commercial proposal was sent and the follow-up delay (1–2 days) has elapsed.
2. Prospect phone number, product or service context, and the recommended next step are retrieved from CRM.
3. A personalised template message is built with three body variables and a static URL button linking to the proposal.
4. The prospect receives the WhatsApp message and can follow the link to open and review the proposal.
5. Delivery result is logged for further follow-up in the CRM or sales pipeline.
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.
• Prospect phone number in international format (without + and spaces).
• Personalisation data: prospect name, product or service name, recommended next step.

Code examples

#!/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_PRODUCTORSERVICENAME = "___";    // {{2}} product or service name
const TEST_NEXTSTEP = "___";    // {{3}} next step

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, productOrServiceName, nextStep }) {
  assertConfigured({
    CHANNEL_ID,
    API_TOKEN,
    TEMPLATE_NAME,
    TEMPLATE_NAMESPACE,
    TEMPLATE_LANGUAGE,
    phone,
    customerName,
    productOrServiceName,
    nextStep,
  });

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

  // params carries body ONLY. Button text is fixed in the Meta template — no button param.
  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(productOrServiceName) }, // {{2}} product or service name
          { type: "text", text: String(nextStep) }, // {{3}} next step
        ],
      },
    ],
  };

  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;
}

if (require.main === module) {
  sendTemplateMessage({
    phone: TEST_PHONE,
    customerName: TEST_CUSTOMERNAME,
    productOrServiceName: TEST_PRODUCTORSERVICENAME,
    nextStep: TEST_NEXTSTEP,
  }).catch((err) => {
    console.error("Execution failed:", err.message);
    process.exit(1);
  });
}

module.exports = { sendTemplateMessage };

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.

Related

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