Send and receive WhatsApp Business messages

Reach 2+ billion WhatsApp users through Orbit’s WhatsApp Business API integration. Send template messages, start interactive sessions, and handle rich media — all through a single API. Connecting WhatsApp for the first time? Follow the first-WABA connect journey, which takes you from Meta Business Manager prerequisites to the first delivered message. For a labelled, tap-to-open link button on an in-window message — no template review, every tap tracked as a click event — see WhatsApp CTA-URL tap-to-open link buttons.

Send a Template Message

WhatsApp requires pre-approved templates for business-initiated conversations.

curl -X POST https://api.orbit.devotel.io/api/v1/messages/whatsapp \
  -H "X-API-Key: dv_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "to": "+14155552671",
    "type": "template",
    "template": {
      "name": "order_confirmation",
      "language": { "code": "en" },
      "components": [
        {
          "type": "body",
          "parameters": [
            { "type": "text", "text": "ORD-12345" }
          ]
        }
      ]
    }
  }'

import { Devotel } from '@devotel-orbit/node';

const orbit = new Devotel({ apiKey: process.env.ORBIT_API_KEY });

// Fully-typed per-channel method — prefer it over the generic send.
const message = await orbit.messages.sendWhatsApp({
  to: '+14155552671',
  type: 'template',
  template: {
    name: 'order_confirmation',
    language: { code: 'en' },
    components: [
      {
        type: 'body',
        parameters: [{ type: 'text', text: 'ORD-12345' }],
      },
    ],
  },
});

console.log(message.data.id);      // msg_wa_abc123
console.log(message.data.status);  // 'sent'

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

# The typed send_whatsapp helper covers text payloads only — a template
# send reaches the channel endpoint through the client.request escape
# hatch (raw JSON returned).
message = client.request(
    "POST",
    "/messages/whatsapp",
    json_body={
        "to": "+14155552671",
        "type": "template",
        "template": {
            "name": "order_confirmation",
            "language": {"code": "en"},
            "components": [
                {
                    "type": "body",
                    "parameters": [{"type": "text", "text": "ORD-12345"}],
                }
            ],
        },
    },
)

print(message["data"]["id"])       # msg_wa_abc123
print(message["data"]["status"])   # 'sent'

// The typed SendWhatsApp helper covers text payloads only — a template
// send reaches the channel endpoint through the client.Request escape
// hatch (raw JSON out).
var message map[string]any
err := client.Request(
    context.Background(),
    "POST",
    "/messages/whatsapp",
    nil,
    map[string]any{
        "to":   "+14155552671",
        "type": "template",
        "template": map[string]any{
            "name":     "order_confirmation",
            "language": map[string]any{"code": "en"},
            "components": []map[string]any{
                {
                    "type": "body",
                    "parameters": []map[string]any{
                        {"type": "text", "text": "ORD-12345"},
                    },
                },
            },
        },
    },
    &message,
    "",
)
if err != nil {
    panic(err)
}

fmt.Println(message["data"].(map[string]any)["id"])      // msg_wa_abc123
fmt.Println(message["data"].(map[string]any)["status"])  // 'sent'

Send a Session Message

Once a user messages you, a 24-hour session window opens for free-form replies. Use the window-status check to confirm the window is still open before sending. Sending a template does not open the window. Only a customer reply re-opens it — Meta’s own platform rule. Once the recipient replies, the composer’s window status flips back to free-form without a page reload, and free-form sends will be accepted again. For how the WhatsApp session compares with Meta DM messaging windows and the no-window channels, see Messaging windows and off-window sends.

curl -X POST https://api.orbit.devotel.io/api/v1/messages/whatsapp \
  -H "X-API-Key: dv_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "to": "+14155552671",
    "type": "text",
    "text": { "body": "Thanks for reaching out! How can we help?" }
  }'

import { Devotel } from '@devotel-orbit/node';

const orbit = new Devotel({ apiKey: process.env.ORBIT_API_KEY });

// Fully-typed per-channel method — prefer it over the generic send.
const message = await orbit.messages.sendWhatsApp({
  to: '+14155552671',
  type: 'text',
  text: { body: 'Thanks for reaching out! How can we help?' },
});

console.log(message.data.id);      // msg_wa_xyz456
console.log(message.data.status);  // 'sent'

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

# Typed shorthand for a text payload.
message = client.messages.send_whatsapp(
    to="+14155552671",
    body="Thanks for reaching out! How can we help?",
)

print(message["data"]["id"])       # msg_wa_xyz456
print(message["data"]["status"])   # 'sent'

// Typed shorthand for a text payload — prefer it over the raw request.
msg, err := client.Messages().SendWhatsApp(context.Background(), orbit.SendWhatsAppInput{
    To:   "+14155552671",
    Body: "Thanks for reaching out! How can we help?",
})
if err != nil {
    panic(err)
}

fmt.Println(msg.Data.ID)      // msg_wa_xyz456
fmt.Println(msg.Data.Status)  // "sent"

Check the 24-Hour Window

Before composing a free-form (session) message, call the window-status endpoint to confirm the recipient is still inside Meta’s 24-hour re-engagement window. The send pipeline enforces the same check, but this pre-flight lets you gate the UI (force template-only when the window has closed) and avoid a wasted send attempt.

curl "https://api.orbit.devotel.io/api/v1/messages/whatsapp/window-status?to=+14155552671&from=+18005551234" \
  -H "X-API-Key: dv_live_sk_..."

import { Devotel } from '@devotel-orbit/node';

const orbit = new Devotel({ apiKey: process.env.ORBIT_API_KEY });

// Fully-typed helper on the messages resource.
const status = await orbit.messages.whatsappWindowStatus({
  to: '+14155552671',
  from: '+18005551234',
});

console.log(status.data.within_window);            // true
console.log(status.data.reason);                   // 'within_window'
console.log(status.data.hours_since_last_inbound); // 3

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

# No typed window-status method in the Python SDK — reach the endpoint
# through the client.request escape hatch (raw JSON returned).
status = client.request(
    "GET",
    "/messages/whatsapp/window-status",
    params={"to": "+14155552671", "from": "+18005551234"},
)

print(status["data"]["within_window"])            # True
print(status["data"]["reason"])                   # 'within_window'
print(status["data"]["hours_since_last_inbound"]) # 3

// No typed window-status method in the Go SDK — reach the endpoint
// through the client.Request escape hatch (raw JSON out).
query := url.Values{}
query.Set("to", "+14155552671")
query.Set("from", "+18005551234")

var status map[string]any
err := client.Request(
    context.Background(),
    "GET",
    "/messages/whatsapp/window-status",
    query,
    nil,
    &status,
    "",
)
if err != nil {
    panic(err)
}

data := status["data"].(map[string]any)
fmt.Println(data["within_window"])            // true
fmt.Println(data["reason"])                   // "within_window"
fmt.Println(data["hours_since_last_inbound"]) // 3

to (required) — the contact’s E.164 number.
from (optional) — the WABA number that will be the sender. When omitted, the check spans any of your WABA numbers; when supplied it is scoped to that sender pair (matching the send-time gate).

Response

{
  "data": {
    "within_window": true,
    "last_inbound_at": "2026-03-08T09:12:00Z",
    "hours_since_last_inbound": 3,
    "reason": "within_window"
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T12:12:00Z"
  }
}

reason is one of:

Reason	Meaning
`within_window`	An inbound was received in the last 24 hours — free-form replies are allowed.
`window_expired`	The last inbound is older than 24 hours — template-only.
`no_inbound_history`	The tenant has NEVER received any inbound WhatsApp message, and the narrow probe found none for this contact — first-contact provable; `last_inbound_at` and `hours_since_last_inbound` are `null`.
`unknown`	The check cannot confirm the window state (a probe blip, or a contact-scoped zero-row result on a tenant that has SOME inbound history). Meta stays authoritative — the send pipeline continues to fail open and lets Meta decide.

When the window is closed, within_window is false and you must fall back to an approved template message.

Send a Broadcast

Fan a single approved template out to up to 256 recipients in one operation (Meta’s documented broadcast-list cap). Each recipient receives a normal 1:1 conversation — there is no shared thread, so per-recipient STOP / opt-out handling is preserved. The endpoint is persist-then-attempt: every recipient is pre-inserted as a pending row in one transaction before the per-recipient send pipeline runs, so a pre-create rejection (template not approved, parameter-count mismatch, 24-hour-window block, fraud guard, quota, sender validation) flips that row to failed rather than throwing without persisting a record.

curl -X POST https://api.orbit.devotel.io/api/v1/messages/whatsapp/broadcast \
  -H "X-API-Key: dv_live_sk_..." \
  -H "Content-Type: application/json" \
  -d '{
    "template_name": "order_confirmation",
    "template_language": "en",
    "from": "+18005551234",
    "template_params": { "1": "Acme Co" },
    "recipients": [
      { "to": "+14155552671", "template_params": { "1": "Alice" } },
      { "to": "+14155552672" }
    ]
  }'

import { Devotel } from '@devotel-orbit/node';

const orbit = new Devotel({ apiKey: process.env.ORBIT_API_KEY });

// orbit.request is the escape hatch for endpoints the typed resources
// don't wrap yet — broadcast has no first-class helper.
const batch = await orbit.request(
  'POST',
  '/messages/whatsapp/broadcast',
  {
    template_name: 'order_confirmation',
    template_language: 'en',
    from: '+18005551234',
    template_params: { '1': 'Acme Co' },
    recipients: [
      { to: '+14155552671', template_params: { '1': 'Alice' } },
      { to: '+14155552672' },
    ],
  },
);

console.log(batch.data.batch_id);     // batch_abc123
console.log(batch.data.summary);      // { total: 2, succeeded: 2, failed: 0, scheduled: 0 }

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

# No typed broadcast method in the Python SDK — reach the endpoint
# through the client.request escape hatch (raw JSON returned).
batch = client.request(
    "POST",
    "/messages/whatsapp/broadcast",
    json_body={
        "template_name": "order_confirmation",
        "template_language": "en",
        "from": "+18005551234",
        "template_params": {"1": "Acme Co"},
        "recipients": [
            {"to": "+14155552671", "template_params": {"1": "Alice"}},
            {"to": "+14155552672"},
        ],
    },
)

print(batch["data"]["batch_id"])   # batch_abc123
print(batch["data"]["summary"])    # { 'total': 2, 'succeeded': 2, ... }

// No typed broadcast method in the Go SDK — reach the endpoint through
// the client.Request escape hatch (raw JSON out).
var batch map[string]any
err := client.Request(
    context.Background(),
    "POST",
    "/messages/whatsapp/broadcast",
    nil,
    map[string]any{
        "template_name":     "order_confirmation",
        "template_language": "en",
        "from":              "+18005551234",
        "template_params":   map[string]string{"1": "Acme Co"},
        "recipients": []map[string]any{
            {"to": "+14155552671", "template_params": map[string]string{"1": "Alice"}},
            {"to": "+14155552672"},
        },
    },
    &batch,
    "",
)
if err != nil {
    panic(err)
}

fmt.Println(batch["data"].(map[string]any)["batch_id"])  // batch_abc123
fmt.Println(batch["data"].(map[string]any)["summary"])   // { total: 2, succeeded: 2, failed: 0, ... }

recipients (required) — 1–256 entries, each with a to (E.164) and optional per-row template_params / metadata. Per-row template_params override the batch-level shared template_params. Duplicate numbers in one request are rejected (422).
template_name (required) — an approved WhatsApp template.
template_language, from, template_params, scheduled_at, webhook_url, metadata (optional) — shared across the batch. With scheduled_at set, every recipient lands as scheduled for the worker queue.

Response

Returns a per-recipient result array plus a summary. Inspect summary.failed and each results[].status — the HTTP status code signals whether to look at the body.

{
  "data": {
    "batch_id": "batch_abc123",
    "results": [
      { "message_id": "msg_1", "to": "+14155552671", "status": "sent" },
      {
        "message_id": "msg_2",
        "to": "+14155552672",
        "status": "failed",
        "error_code": "TEMPLATE_NOT_APPROVED",
        "error_message": "Template is not approved"
      }
    ],
    "summary": { "total": 2, "succeeded": 1, "failed": 1, "scheduled": 0 }
  },
  "meta": {
    "request_id": "req_xyz789",
    "timestamp": "2026-03-08T00:00:00Z"
  }
}

Status	When
`200`	Every recipient succeeded.
`207`	At least one recipient failed (partial or all-failed) — always inspect the body.
`402`	Org balance can’t cover the broadcast floor.
`429`	The recipient count would breach the WABA’s daily `messaging_limit_tier` cap.
`500`	Bulk pre-insert failed — no recipients were processed.

Broadcasts are rate-limited to 30 requests/minute per tenant. Larger or recurring sends belong in the campaigns module.

The Visual Flow Builder

Build a Flow in the dashboard without writing JSON: Messages → WhatsApp → Flows opens a canvas editor where each screen is a node. Drag screens from the component palette — text inputs, dropdowns, radio groups, checkboxes, date pickers, photo pickers, opt-in consent, rich text, images, embedded links, navigation lists — and connect a non-terminal screen’s Continue button to the next screen. Selecting a screen opens a drawer to edit its copy, options, and validation. A View JSON toggle exposes the raw Meta Flow JSON for power users; edits there sync back to the canvas on commit, with parse errors guarded. Export a Flow as JSON for version control, or import a Meta Flow JSON document — the builder preserves every screen it recognises and falls back to a text input for a shape it does not, so an imported Flow is still editable and re-saveable. Start blank, from one of the built-in templates, or from the AI generator’s draft (the AI Flow generator is covered in Getting started with WhatsApp). Once the Flow is published, pair the funnel view with the submissions list below: the funnel shows where customers drop off, the list shows what each completer answered.

Flow Submissions Write to the Contact Profile

When a customer completes a Meta Flow sent over WhatsApp — a lead-capture form, a survey, a self-service questionnaire — the answers they submitted are written onto their contact profile as custom-field values, in addition to the conversation log. Segments and automations built on custom fields see the contact right after they submit. Define a custom field under Settings → Custom Fields with a key that matches the Flow screen’s field id (snake_case, e.g. email, company_size) and the answer lands there on completion. The write-back is additive lead capture, not a sync:

Blank answers (null or empty strings) are ignored — a returning customer re-running a Flow with an optional field skipped never wipes the value they set on an earlier submission.
A Flow field id with no matching custom-field definition is skipped, never invented as a new field.
One invalid answer (wrong type, out of range, disallowed option) is skipped without blocking the rest of the submission.

Browse Individual Flow Submissions

The funnel view tells you where customers drop off; the submissions list tells you what the completers actually answered. Every completed submission gets its own row, available over the API:

curl "https://api.orbit.devotel.io/api/v1/whatsapp/flows/YOUR_FLOW_ID/submissions?limit=50" \
  -H "X-API-Key: dv_live_sk_..."

import { Devotel } from '@devotel-orbit/node';

const orbit = new Devotel({ apiKey: process.env.ORBIT_API_KEY });

// orbit.request is the escape hatch for endpoints the typed resources
// don't wrap yet.
const submissions = await orbit.request(
  'GET',
  '/whatsapp/flows/YOUR_FLOW_ID/submissions?limit=50',
);

console.log(submissions.data[0].submitted_at); // ISO timestamp of the completion

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

# No typed flow-submissions helper in the Python SDK — reach the endpoint
# through the client.request escape hatch (raw JSON returned).
submissions = client.request(
    "GET",
    "/whatsapp/flows/YOUR_FLOW_ID/submissions?limit=50",
)

print(submissions["data"][0]["submitted_at"])  # ISO timestamp

// No typed flow-submissions helper in the Go SDK — reach the endpoint
// through the client.Request escape hatch (raw JSON out).
var submissions map[string]any
err := client.Request(
    context.Background(),
    "GET",
    "/whatsapp/flows/YOUR_FLOW_ID/submissions?limit=50",
    nil,
    nil,
    &submissions,
    "",
)
if err != nil {
    panic(err)
}

fmt.Println(submissions["data"].([]any)[0].(map[string]any)["submitted_at"])

Submissions are returned newest-first. YOUR_FLOW_ID accepts either the id in the flow’s dashboard URL or the Meta flow id. Query parameters: since / until (ISO timestamps — the default window is the trailing 90 days), and limit (up to 200) / offset for pagination. Each row carries:

Field	What it tells you
`id`	The submission record’s id
`submitted_at`	When the customer completed the Flow
`payload`	The raw answers, exactly as WhatsApp handed them back
`contact_id`	The resolved contact, or `null` when the submitter couldn’t be identified (a submission never creates a contact)
`contact_label` / `contact_phone`	A readable label and E.164 number for the resolved contact, when there is one
`conversation_id`	The Meta conversation the submission arrived with, when present
`landed_in_cdp`	`true` once the submission has landed on the contact’s CDP profile as a `whatsapp_flow_submitted` event — see below

The `landed_in_cdp` Marker and the CDP Event

In addition to the custom-field write-back, every completed submission lands on the contact’s CDP profile as a whatsapp_flow_submitted event. Segments, computed traits, and event-triggered journeys built on CDP events (see The CDP event model) can react to a Flow completion the same way they react to any other behavioral event. landed_in_cdp on a submissions row is true when that event exists for the submission — use it to confirm a Flow the journeys depend on is really feeding them. It can be false for submissions recorded before this wiring shipped; those rows still carry all their answers. Retried WhatsApp delivery of the same submission collapses onto one event, so the count you see matches the number of actual completions. Both landing paths coexist deliberately: the write-back above keeps the latest answers on the contact’s custom fields (additive — blanks never wipe), while the CDP event preserves every submission verbatim in the event stream. Point real-time triggers at the event; use the custom fields when you need the current value.

Features

Template messages — pre-approved message templates for outbound notifications
Session messaging — free-form replies within the 24-hour conversation window, with a pre-flight window-status check
Broadcast lists — fan one approved template out to up to 256 recipients with per-recipient results
Rich media — images, videos, documents, audio, stickers, and location sharing
Interactive messages — buttons, list pickers, quick replies, plus tap-to-share location-request and structured delivery-address prompts
Read receipts — know when messages are delivered and read
Catalog & product messages — share product listings directly in chat
Flows — send Meta Flows and capture completed submissions onto the contact’s custom fields (see Flow Submissions Write to the Contact Profile)

Media Support

Send images, video, documents, audio, and stickers over WhatsApp. Each media type has its own size limit, set and enforced by WhatsApp (Meta) at the Graph API — there is no single blanket ceiling. Orbit forwards your media to WhatsApp, so keep each file within the limit for its type or WhatsApp rejects the send.

Type	Max Size	Formats
Image	5 MB	JPEG, PNG
Video	16 MB	MP4, 3GPP
Audio	16 MB	AAC, MP3 (MPEG), MP4, AMR, OGG
Document	100 MB	PDF, DOC, DOCX, PPT, PPTX, XLS, XLSX, TXT
Sticker	100 KB	WebP

Limits are per type, not shared: a 90 MB PDF is accepted as a document but rejected if the same file is sent as an image, and a sticker must stay under 100 KB. Check each file against the limit for its media type before sending.

Platform WABA credentials (operators)

Tenants connect their own WhatsApp Business Account through the dashboard Embedded Signup flow, and Orbit uses that tenant’s stored credentials at send time. The variables below configure Orbit’s own platform-owned WABA — used today only for operator-side platform operations (platform-initiated template management and WhatsApp Calling registration). The old shared fallback send path for unverified organizations was removed on 2026-10-08: there is no longer any send that rides the platform WABA on a tenant’s behalf. Set all three in Secret Manager (or .env for local dev). They are optional at boot: when DEVOTEL_WHATSAPP_ACCESS_TOKEN is set, messaging-bootstrap.ts registers one platform-wide WhatsApp provider; when it is unset, only per-tenant connections resolve at send time.

Variable	Required	Purpose
`DEVOTEL_WHATSAPP_ACCESS_TOKEN`	To enable the platform path	Graph API access token for the platform-owned WABA. Presence of this token is what registers the platform WhatsApp provider at boot.
`DEVOTEL_WHATSAPP_PHONE_NUMBER_ID`	With the access token	Phone-number id of the platform WABA’s sender, used by platform-initiated template management and WhatsApp Calling registration.
`DEVOTEL_WHATSAPP_BUSINESS_ACCOUNT_ID`	With the access token	The platform WABA id. Used to scope template management and to match inbound webhooks routed to the platform account.

Inbound webhook HMAC for WhatsApp still uses the shared DEVOTEL_META_APP_SECRET / DEVOTEL_META_VERIFY_TOKEN regardless of whether the platform credentials are set. The dashboard’s WhatsApp Embedded Signup card and the Meta Ads channel card load Meta’s JS SDK in the browser, so they need a Meta App ID and an Embedded Signup configuration ID available on the client. Two NEXT_PUBLIC_* variables carry those values. Because they are NEXT_PUBLIC_*, they are baked into the dashboard when it is built — changing them requires rebuilding the dashboard, not just updating a server environment variable. Both are optional. Leave them unset for standard production deployments; the defaults connect tenants to Orbit’s production Meta app.

Variable	Required	Purpose
`NEXT_PUBLIC_META_APP_ID`	Optional	Meta App ID used by every Meta channel card (WhatsApp Embedded Signup, Instagram, Messenger, Meta Ads) to initialise the Facebook JS SDK. When unset, the SDK loader and the Meta Ads card fall back to Orbit’s built-in production Meta app. In the WhatsApp Embedded Signup card the effective app ID is normally taken from the server-side WhatsApp status (`DEVOTEL_META_APP_ID`); this build-time value only backs the in-tab OAuth fallback before that status resolves.
`NEXT_PUBLIC_META_CONFIG_ID`	Optional	Embedded Signup configuration ID for the WhatsApp Embedded Signup flow. Unlike the App ID, it has no built-in production fallback: the effective value is normally taken from the server-side WhatsApp status, and this build-time value only backs the brief window before that status resolves. When both the server value and this variable are empty, the Connect action surfaces a misconfiguration message instead of opening Meta’s signup dialog with an empty config.

Override both when you build the dashboard against a non-production Meta app — a staging / preview environment pointed at a test Meta app and Embedded Signup config, or a white-label deployment that runs its own Meta app rather than Orbit’s. Provide both as build-time variables when you build the dashboard, and set the matching server-side DEVOTEL_META_APP_ID so the runtime and build-time values agree.

Template Management

Manage templates through the Orbit dashboard under Channels > WhatsApp > Templates, or via the API:

curl https://api.orbit.devotel.io/api/v1/whatsapp/templates \
  -H "X-API-Key: dv_live_sk_..."

import { Devotel } from '@devotel-orbit/node';

const orbit = new Devotel({ apiKey: process.env.ORBIT_API_KEY });

// Fully-typed sub-resource on the WhatsApp namespace.
const templates = await orbit.whatsapp.templates.list();

for (const t of templates.data) {
  console.log(t.name, t.status);  // e.g. 'order_confirmation APPROVED'
}

from orbit_sdk import OrbitClient

client = OrbitClient.from_env()  # reads ORBIT_API_KEY

# No typed template list in the Python SDK — reach the endpoint through
# the client.request escape hatch (raw JSON returned).
templates = client.request("GET", "/whatsapp/templates")

for t in templates["data"]:
    print(t["name"], t["status"])  # e.g. 'order_confirmation APPROVED'

// No typed template list in the Go SDK — reach the endpoint through the
// client.Request escape hatch (raw JSON out).
var templates map[string]any
err := client.Request(
    context.Background(),
    "GET",
    "/whatsapp/templates",
    nil,
    nil,
    &templates,
    "",
)
if err != nil {
    panic(err)
}

for _, t := range templates["data"].([]any) {
    tpl := t.(map[string]any)
    fmt.Println(tpl["name"], tpl["status"])  // e.g. "order_confirmation" "APPROVED"
}

New templates are created and submitted for Meta review the same way: POST to /whatsapp/templates (Node: orbit.whatsapp.templates.create(...), then orbit.whatsapp.templates.submitForReview(id)). To measure how a template performs once campaigns start sending it, read its cross-campaign rollup — sends, deliveries, opens, and clicks consolidated across every campaign that used it — in the template analytics guide. Templates go through Meta’s approval process (typically 1–24 hours).

Your WABA is required to send

The shared Devotel test account — a shared WABA that used to carry real sends to a verified phone number before your own WABA was approved — was retired on 2026-10-08. Your own WhatsApp Business Account, connected through Embedded Signup (see the WABA setup guide), is now the only send path on this channel. What you meet today when no WABA is connected:

Sends — POST /api/v1/whatsapp/send (and every other WhatsApp send entry point) refuses up front with 422 CHANNEL_NOT_CONFIGURED, before a message row is written. Connect your WABA and the same call passes; nothing about your send code changes.
Demo-account endpoints — the retired OTP / verification endpoints (sendOtp, verifyOtp, changeNumber, and the test-account send admission) answer 410 GONE with a connect-your-own message. There is no admin override or allowOverwrite bypass; the retirement is absolute.
Status reads stay readable — GET /api/v1/whatsapp/get-status continues to render a coherent state for a previously verified organization: retired: true and verified: false, so legacy dashboards show “retired, connect your own account” rather than erroring.

The channel test-account model now describes per-channel applicability: Telegram still ships the shared ladder, RCS uses it during agent approval, and WhatsApp’s participation ended with the 2026-10-08 retirement.

Troubleshooting

Jump straight to the symptom you are seeing; each page below is the drill-down for it.

Send fails immediately — a send rejected before it leaves Orbit or refused by Meta. Work the template gates in WhatsApp template issues, or the WHATSAPP_ACCOUNT_LOCKED recovery flow in WhatsApp connection issues.
Session vs template window — a free-form reply refused while a template send works. Re-check the window state in Session window expired, and review the rules in the 24-hour window guide (the window-status check is the pre-flight).
Quality and tier — sends rejected at the per-WABA tier ceiling, or quality posture degrading. See the Messaging Tier entry in the glossary and the template gate drill-down in WhatsApp template issues.
Migration between providers — moving WhatsApp traffic without losing the WABA or its approved templates. Follow WhatsApp migration.
WABA billing — conversation pricing, WABA-level charges, or a billed send you did not expect. Work WhatsApp billing issues.

Getting Started

Channels

Channels (Voice)

AI Agents

Campaigns

Flows

Numbers & Verify

Concepts

Features

Billing

Webhooks

Security & SSO

Compliance

Legal

Brand & press

Tutorials

Changelog

WhatsApp

Send a Template Message

Send a Session Message

Check the 24-Hour Window

Response

Send a Broadcast

Response

The Visual Flow Builder

Flow Submissions Write to the Contact Profile

Browse Individual Flow Submissions

The `landed_in_cdp` Marker and the CDP Event

Features

Media Support

Platform WABA credentials (operators)

Template Management

Your WABA is required to send

Troubleshooting

​WhatsApp

​Send a Template Message

​Send a Session Message

​Check the 24-Hour Window

​Response

​Send a Broadcast

​Response

​The Visual Flow Builder

​Flow Submissions Write to the Contact Profile

​Browse Individual Flow Submissions

​The landed_in_cdp Marker and the CDP Event

​Features

​Media Support

​Platform WABA credentials (operators)

​Dashboard Embedded Signup (build-time client config)

​Template Management

​Your WABA is required to send

​Troubleshooting

WhatsApp

Send a Template Message

Send a Session Message

Check the 24-Hour Window

Response

Send a Broadcast

Response

The Visual Flow Builder

Flow Submissions Write to the Contact Profile

Browse Individual Flow Submissions

The `landed_in_cdp` Marker and the CDP Event

Features

Media Support

Platform WABA credentials (operators)

Dashboard Embedded Signup (build-time client config)

Template Management

Your WABA is required to send

Troubleshooting