Nodes Reference

Every node available in ChatYug Chatbot Builder (v1) and Trial Chatbot Builder V2. Shared nodes work in both builders; v2-only nodes appear only in the V2 palette.

Quick index

NodeType IDv1v2
StartstartYesYes
Send MessagemessageYesYes
Show Buttonsinteractive_buttonsYesYes
Show Listinteractive_listYesYes
Wait for Inputwait_for_inputYesYes
Extract Textextract_text—Yes
ConditionconditionYesYes
Advanced Conditionadvanced_conditionYesYes
API Callapi_callYesYes
Database Actiondatabase_actionYesYes
Human Handoffhuman_handoffYesYes
End FlowendYesYes
Send Mediasend_media—Yes
Switch/Caseswitch—Yes
Set Variableset_variable—Yes
Delaydelay—Yes
Looploop—Yes
Chatbot Flowflow_selector—Yes
Flow Design Formwhatsapp_flow—Yes
Template Messagetemplate_message—Yes
WhatsApp Notifywhatsapp_notify—Yes
Template Notifywhatsapp_template_notify—Yes

Shared nodes (v1 + v2)

Start

Purpose: Entry point of every flow. The conversation begins here when a customer message matches the flow’s trigger keywords.

When to use: Always present — do not remove. Configure keywords on the flow (v1 save prompt / flows list, or v2 Flow Settings), not as a separate palette node.

  • v1: Start step shows “Triggered when customer sends keyword”
  • v2: Fixed START node on the canvas

Send Message (message)

Purpose: Send plain text to the customer.

When to use: Greetings, confirmations, instructions, or any single text reply.

FieldRequiredNotes
Message ContentYesSupports variables (v1: {variable_name}; v2 commonly {{variable_name}}). WhatsApp markup: *bold* _italic_ ~strike~ `mono`; line breaks are preserved. The builder phone preview matches the phone.

Example: Hi {{customer_name}}, your order is confirmed.

Next: Connect to one following node.

Show Buttons (interactive_buttons)

Purpose: WhatsApp interactive reply buttons (max 3).

When to use: Small menus where the customer must pick one option.

FieldRequiredNotes
Body TextYesMessage shown above the buttons. Same WhatsApp markup and line breaks as Send Message; builder preview matches the phone.
ButtonsYesUp to 3; each has a title/label
Variable NameNoStore the selection for later conditions/messages. Empty uses default response variables
Button Mode (v2)NoStatic buttons or Dynamic from an API data source
Data Source / Title Field / ID Field (v2 dynamic)If dynamicVariable holding options array; field names for title and id
Toggle Timer (v2)NoOff (default) = wait indefinitely for a button tap. On = require Time (seconds) and a timeout target node.
Time (seconds)If Toggle Timer onMax 3600 (60 minutes). If the customer does not tap a button in time, the flow jumps to the timeout node.
If no response, go toIf Toggle Timer onSeparate from per-button “Goes to” routes. Used only when the timer expires.

Auto variables (v1): selections can populate button_response, last_selection, last_selection_title, or your custom variable name.

Next: Each button routes to a different next node (branching).

Wait behavior: The node sends buttons and pauses. When the customer taps a button, the flow continues on that button’s route (or the primary next). With Toggle Timer on, expiry uses the same session deadline poller as Wait for Input / Flow Design Form and sets _input_timed_out.

Show List (interactive_list)

Purpose: WhatsApp list message (up to 10 rows).

When to use: Longer menus than three buttons (services, products, categories).

FieldRequiredNotes
Header TextNoOptional list header
Body TextYesMain prompt. Supports WhatsApp markup (*bold* _italic_) and line breaks; header stays plain text on WhatsApp.
Button TextYesLabel on the list open button (default often “View Options”)
List items / rowsYes (static)Title + optional description; max 10
Variable NameNoStore selection; empty may default to button_response / list response vars
List Mode (v2)NoStatic or Dynamic (from API variable)
Data Source / Title / Description / ID fields (v2)If dynamicMap API array fields; optional pagination checkbox
Toggle Timer (v2)NoOff (default) = wait indefinitely for a list selection. On = require Time (seconds) and a timeout target node.
Time (seconds)If Toggle Timer onMax 3600 (60 minutes). If the customer does not select an option in time, the flow jumps to the timeout node. Pagination re-sends the list and restarts the timer.
If no response, go toIf Toggle Timer onSeparate from per-row “Goes to” routes. Used only when the timer expires.

Next: Customer row selection continues the flow (and can branch by stored variable + condition).

Wait behavior: Same pause pattern as Show Buttons. With Toggle Timer on, expiry uses the shared input-wait poller and sets _input_timed_out.

Wait for Input (wait_for_input)

Purpose: Ask a question and store the customer’s free-text reply in a variable.

When to use: Collect name, email, phone, order ID, or any typed answer.

FieldBuildersNotes
Prompt Messagev1 + v2Question sent to the customer
Save / Store Response In (variable name)v1 + v2v1 empty default: last_input
Validation Typev1 + v2v1: any, email, phone, number, date (DD/MM/YYYY), regex. v2: any, number, email, phone
Min / Max (number), custom regex + error messagev1Shown when validation is number or regex
Max Retry Attemptsv1Default 3 (range 1–10)
Retry Message / Error Node IDv1Custom fail message; optional node after max retries
Timeout minutes / secondsv2Optional. Leave blank for unlimited wait. Max 60 minutes total.
If no reply, go tov2Required when timeout > 0 — node to run if the customer does not reply in time

Next: Continues to the next node after a valid reply (or error path in v1 after max retries).

Wait timeout: After the prompt is sent, if a timeout is configured and the customer stays silent until the deadline, a background processor resumes the flow at the timeout node (does not treat silence as user input). This is separate from the flow’s session idle Timeout_Minutes, which only expires abandoned sessions without continuing to a node. On timeout, session var _input_timed_out is set to true.

Extract Text (extract_text)

Purpose: Find numbers, codes, or patterns inside free-form user text and store them in variables.

When to use: After Wait for Input when customers reply in sentences instead of a bare value — e.g. My number is 8545698547 or serial number is 999999.

FieldNotes
Source VariableText to parse (default last_input from Wait for Input)
Extraction RulesOne or more rules; all must match. Each rule has type, length/value checks, and target variable.
Extract Typedigits, alphanumeric, letters, keyword (value after phrase), custom_regex (uses capture group 1 if present)
Min / Max / Exact lengthValidate extracted value length; exact length overrides min/max
Exact valueOptional — extracted text must equal this value
Store in variableRequired per rule — use {{name}} in later messages
No Match MessageOptional text sent when extraction fails
True Path / False PathRequired — success vs no valid match

Example flow: Wait for Input → Extract Text (digits, length 10 → user_phone) → Send Message Thanks! Saved {{user_phone}}.

Example inputs:

  • My number is 8545698547 + digits rule (length 10) → 8545698547
  • serial number is 999999 + keyword rule (serial number is, digits, length 6) → 999999

Built-in var: _extract_success is set to true or false after the node runs.

Condition / Simple Condition (condition)

Purpose: Branch true/false on a single variable comparison.

When to use: Simple yes/no or value checks.

FieldNotes
Variable to CheckVariable name from Wait for Input / buttons (braces optional)
Operatorequals, not_equals, contains, not_contains, greater_than, less_than, greater_or_equal, less_or_equal
ValueComparison value
True PathRequired — next node when the condition matches
False PathRequired — next node when the condition does not match

Next: True path and false path must both be set in the node properties (v1 edit modal or v2 properties panel). Canvas lines alone without True/False path selection are not enough.

Advanced Condition (advanced_condition)

Purpose: Multiple conditions combined with AND or OR.

When to use: Multi-rule eligibility (e.g. plan is Premium AND age > 18).

FieldNotes
Logic OperatorAND (all true) or OR (any true)
Conditions listEach row: variable, operator, value. Operators include equals, not_equals, greater/less (and or equal), contains, starts_with, ends_with, is_empty, is_not_empty, in_list, regex_match
True PathRequired — next node when the combined result is true
False PathRequired — next node when the combined result is false

Next: True / false branches like Simple Condition — both paths are required.

API Call (api_call)

Purpose: Call an external HTTP API and store response fields as session variables for later messages.

When to use: CRM lookups, order status, pricing, ERP, or any live data.

3 steps: (1) Enter HTTPS URL and method. (2) Add extract rows (variable name + JSON path). (3) In the next Send Message use {{title}} / {title} for extracted names.

FieldNotes
MethodGET, POST, PUT, PATCH, DELETE
API URLRequired; may embed {{user_phone}} or {user_phone}
Save response asVariable for the full JSON string. Default api_response. Prefer extract rows for WhatsApp text.
Extract fieldsRepeatable rows: Variable name + Path (e.g. title / data.price / items.0.name). Saved as extractFields object.
HeadersOptional key/value rows (not raw JSON in the primary UI)
Request BodyShown for POST/PUT/PATCH; JSON with optional variables
Timeout (ms)Default 10000
Success / Error MessageOptional; can use {{extracted_var}} and {{_api_status}}
Continue on ErrorIf unchecked, HTTP 4xx/5xx ends the flow
Test API Call (builder)v2 panel button posts to /api/chatbot/flows/test-api-call and shows status + JSON preview

Built-in vars after the call: _api_status, _api_ok (true/false), _api_error on failure.

Example URL: https://jsonplaceholder.typicode.com/todos/1 → extract title from path title → next message: Todo: {{title}}

Database Action / Save to Database (database_action)

Purpose: Persist conversation data.

When to use: Capture leads/tags (v1) or write structured fields to a table (v2).

v1 fields: Contact Phone (default {customer_phone}), Contact Name, Email, Company, Tags (comma-separated), Success Message, Error Message, Continue on Error.

v2 fields: Action Type (e.g. INSERT), Table Name, Fields (JSON object of column → value).

UI labels differ slightly (“Save to Database” in v1 vs “Database Action” in v2) but share type id database_action.

Human Handoff / Transfer to Human (human_handoff)

Purpose: Stop bot automation for the conversation and hand off to a human agent.

When to use: “Talk to agent”, escalations, or failed self-serve paths.

FieldNotes
Handoff / Transfer MessageText sent when transferring (v2 default: “Transferring you to a human agent...”)
Departmentv2; default general
Priority / notify optionsv1 exposes transfer configuration (e.g. priority) in the edit modal

End Flow (end)

Purpose: Finish the session.

When to use: Terminal step after a successful path or goodbye.

FieldNotes
Final / End MessageOptional closing text (v2 default: “Thank you! Conversation ended.”)

Next: None — conversation ends.

v2-only nodes

Send Media (send_media)

Purpose: Send image, video, or document in the session.

FieldNotes
Media Typeimage, video, or document
Media FileOptional upload from the properties panel
Media URL / Meta Media IDRequired; public URL or Meta media ID
Caption / TextOptional

Session media still requires an open WhatsApp customer service window when sending free-form media.

Switch/Case (switch)

Purpose: Multi-way branch on one variable (like a switch statement).

FieldNotes
Variable to CheckRequired
CasesEach case: value, label, target node
Default CaseNode if no case matches

Set Variable (set_variable)

Purpose: Assign or update a session variable without waiting for customer input.

FieldNotes
Variable NameRequired
Operationset, append, increment, decrement
ValueRequired for set/append; can reference {{other_variable}}

Delay (delay)

Purpose: Pause before continuing.

FieldNotes
Delay (Seconds)0–3600; default 5
Delay (Minutes)Optional 0–60
Show Wait MessageOptional “Please wait...” style message

Loop (loop)

Purpose: Repeat a section of the flow.

FieldNotes
Loop Typecount (N times), array (iterate items), condition (while true)
Max IterationsFor count; default 5 (max 100)
Array VariableFor array type
Condition Variable / Operator / ValueFor condition type
Loop Back NodeNode to return to each iteration
Exit NodeNode when the loop finishes

Chatbot Flow (flow_selector)

Purpose: Jump execution into another saved chatbot automation (modular flows).

FieldNotes
Chatbot automationRequired; choose from saved chatbot flows
Pass VariablesDefault on — share current session variables
Return to Current Flow After CompletionOptional; continue parent flow after child ends
Return To NodeWhere to resume in the parent flow

This is not a Flow Design form (Meta form). Use Flow Design Form to send a customer-fillable form.

Flow Design Form (whatsapp_flow)

Purpose: Send a published Flow Design form (Meta WhatsApp Flow) to the customer, wait until they submit, then store every answered field as session variables for later nodes.

When to use: Lead capture, surveys, booking, or any structured form inside an automation. Distinct from Chatbot Flow, which runs another chatbot automation.

FieldNotes
Published Flow Design FormRequired; list from Flow Design (PUBLISHED only; value is Meta meta_flow_id)
Header / Body / CTAOptional message copy; supports {{variables}}
Variable prefixDefault flow_. Each answer key becomes {{prefix}field_name}}
Toggle TimerOptional. Off (default) = wait indefinitely for submit. On = require Time (seconds) and a timeout target node.
Time (seconds)Shown when Toggle Timer is on. Max 3600 (60 minutes). If the customer does not submit in time, the flow jumps to the timeout node.
If no submit, go toRequired when Toggle Timer is on. Separate from the primary “next” connection used after a successful submit.

Wait behavior: The node sends the form and pauses (like Wait for Input). When the customer submits, webhook nfm_reply resumes the same node and continues on the primary next connection. With Toggle Timer on, expiry uses the same session deadline poller as Wait for Input and sets _flow_timed_out.

Variables written on submit:

  • Each form field → {prefix}{field_name} (skips flow_token, source, screen)
  • Always: flow_token, flow_response (full JSON), last_flow_submit

Example: After a lead form with field customer_name, next message: Thanks {{flow_customer_name}}!

Note: Meta requires an open 24-hour customer window (or a prior template) to send the interactive Flow message.

Template Message (template_message)

Purpose: Send a Meta-approved WhatsApp message template from inside the automation.

When to use: Outside the 24-hour session window, or whenever you need an approved template format (e.g. re-engage a lapsed contact, send an order confirmation).

FieldNotes
Approved WhatsApp TemplateRequired. Dropdown lists all APPROVED templates for this WABA. Carousel templates are excluded. Selecting a template auto-fills language and creates variable inputs.
LanguageAuto-filled from the selected template (read-only).
Template VariablesOne field per {{1}}, {{2}}, … placeholder found in the template body. Values support {{session_variable}} substitution — e.g. Hi {{flow_customer_name}}.
Header media (IMAGE / VIDEO / DOCUMENT)Shown only when the template has a media header. Upload the file via Upload to Meta — the returned numeric Meta media ID is stored on the node and sent at run time. Re-upload if you get a media-expired error.

Variable substitution: All variable values support {{variable_name}} from the current session — for example a value set by a preceding Set Variable node or collected by a Flow Design Form node.

Note: Meta media IDs expire. If a send fails with a media error, re-open the node, re-upload the file, and save the flow again.

This node sends an already-approved WhatsApp template — it does not create or modify templates. This is also different from chatbot flow templates (pre-built chatbot graphs). See Templates & Facilities.

WhatsApp Notify (whatsapp_notify)

Purpose: Send an internal/alert WhatsApp message to staff numbers (parallel to the customer conversation).

FieldNotes
Recipient NumbersRequired; one per line or comma/semicolon separated
Notification MessageRequired; can include variables
Parse VariablesCheckbox; default on

Example: Alert sales: New lead {{customer_phone}} requested callback.

Limitation: Free-form text requires an open 24-hour customer-care window with each recipient. For alerts outside that window, use Template Notify.

Template Notify (whatsapp_template_notify)

Purpose: Send a Meta-approved WhatsApp template to configured staff/recipient numbers (parallel to the customer conversation). Works outside the 24-hour window.

When to use: Admin/ops alerts when recipients may not have messaged the business recently. Distinct from WhatsApp Notify (free text) and Template Message (sends to the customer).

FieldNotes
Recipient NumbersRequired; one per line or comma/semicolon separated. Staff/alert numbers — not the customer chat.
Approved WhatsApp TemplateRequired. Same APPROVED (non-carousel) picker as Template Message.
LanguageAuto-filled from the selected template (read-only).
Template VariablesOne field per {{1}}, {{2}}, …. Values may be hardcoded or {{session_variable}}.
Header mediaShown only when the template has a media header. Upload via Upload to Meta.

Behavior: Side-effect only — does not create a bubble in the customer conversation. Soft-fails (logs + continues) if recipients or template are missing or media ID is invalid.

NodeRecipientMessage type24h window
whatsapp_notifyConfigured numbersFree-form textRequired
whatsapp_template_notifyConfigured numbersApproved templateNot required
template_messageCustomer in conversationApproved templateNot required

Connecting nodes

  • v1: Steps are ordered in the list; conditions and buttons define branches in node config.
  • v2: Drag connection handles between nodes on the canvas; condition/switch/loop nodes expose multiple targets (true/false, cases, loop/exit).

Always end every path with End Flow or Human Handoff so sessions do not hang without a terminal state.