WhatsApp Business API for session reply — incoming client request

Use case overview

This scenario sends a free-text WhatsApp message with sendMessage inside the 24-hour customer service window after the client wrote first about a product or service.

Template example

Hello, {{1}}! We received your request about «{{2}}». {{3}} is reviewing it and will reply shortly.

sendMessage works only when the 24-hour session window is open.

Variables and purpose

• {{1}} — client name
• {{2}} — request topic or product area
• {{3}} — assigned sales manager name

Filled-in example

Hello, Alexey! We received your request about «CRM for a sales team». Manager Anna is reviewing it and will reply shortly.

When to use it

• sales inbound

Business value

• Client inbound message arrives via webhook and opens or continues the session
• CRM maps the chat to a lead and extracts the request topic
• Session text message confirms receipt and names the assigned manager
• Client stays engaged until the sales manager sends a detailed answer
• Lead status updates in CRM from first response timestamp

Workflow

1. An inbound client message arrives via webhook.
2. Your backend maps the chat to a lead and extracts the request topic.
3. A session text message acknowledges the request and names the manager.
4. The manager continues the dialog with a detailed answer in the same session.
5. Delivery progress is reported asynchronously — typically sent, then delivered (or failed/undelivered).
6. Your system receives status via webhook (hooks[]) or polls delivery status and handles failures if needed.

Technical implementation

Prerequisites

• An open WhatsApp session window (client wrote first or replied within 24 hours).
• 1MSG channel with sendMessage access and webhook configured for inbound 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)



// === Test data ===
const TEST_PHONE = "___";            // client phone in international format · requires open 24-hour session window
const TEST_CUSTOMERNAME = "___";    // {{1}} customer name
const TEST_TOPIC = "___";    // {{2}} topic or subject
const TEST_MANAGERNAME = "___";    // {{3}} manager name

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 sendSessionTextMessage({ phone, customerName, topic, managerName }) {
  assertConfigured({
    CHANNEL_ID,
    API_TOKEN,
    phone,
    customerName,
    topic,
    managerName,
  });

  const url = `${API_BASE_URL}/${CHANNEL_ID}/sendMessage`;
  const requestBody = {
    phone: normalizePhone(phone),
    body: `Hello, ${customerName}! We received your request about «${topic}». ${managerName} is reviewing it and will reply shortly.`,
  };

  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) {
  sendSessionTextMessage({
    phone: TEST_PHONE,
    customerName: TEST_CUSTOMERNAME,
    topic: TEST_TOPIC,
    managerName: TEST_MANAGERNAME,
  }).catch((err) => {
    console.error("Execution failed:", err.message);
    process.exit(1);
  });
}

module.exports = { sendSessionTextMessage };

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

• Session window closed (no client message within 24 hours)
• Invalid or non-normalized phone number
• Missing or invalid message body / media URL
• Delivery failure — check status webhook and retry policy

FAQ

• Do I need a template? No — this scenario uses a session message inside the 24-hour customer service window.
• When does the session window close? If the client has not written or replied within 24 hours, sendMessage will fail until a template reopens the chat.
• How do I check delivery? sent: true only confirms acceptance. Track delivery via webhook hooks[] or polling.
• What if the message is not delivered? Log the failed/undelivered hook, verify the session window, then retry or use a template.
• Can I connect this to my CRM or backend? Yes — trigger the API call from your inbound webhook or workflow engine.

CTA

Ready to use session reply — incoming client request? Connect your 1MSG channel and run the code examples above.

Related

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