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

Node	Type ID	v1	v2
Start	`start`	Yes	Yes
Send Message	`message`	Yes	Yes
Show Buttons	`interactive_buttons`	Yes	Yes
Show List	`interactive_list`	Yes	Yes
Wait for Input	`wait_for_input`	Yes	Yes
Extract Text	`extract_text`	—	Yes
Condition	`condition`	Yes	Yes
Advanced Condition	`advanced_condition`	Yes	Yes
API Call	`api_call`	Yes	Yes
Database Action	`database_action`	Yes	Yes
Human Handoff	`human_handoff`	Yes	Yes
End Flow	`end`	Yes	Yes
Send Media	`send_media`	—	Yes
Switch/Case	`switch`	—	Yes
Set Variable	`set_variable`	—	Yes
Delay	`delay`	—	Yes
Loop	`loop`	—	Yes
Chatbot Flow	`flow_selector`	—	Yes
Flow Design Form	`whatsapp_flow`	—	Yes
Template Message	`template_message`	—	Yes
WhatsApp Notify	`whatsapp_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.

Field	Required	Notes
Message Content	Yes	Supports 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.

Field	Required	Notes
Body Text	Yes	Message shown above the buttons. Same WhatsApp markup and line breaks as Send Message; builder preview matches the phone.
Buttons	Yes	Up to 3; each has a title/label
Variable Name	No	Store the selection for later conditions/messages. Empty uses default response variables
Button Mode (v2)	No	Static buttons or Dynamic from an API data source
Data Source / Title Field / ID Field (v2 dynamic)	If dynamic	Variable holding options array; field names for title and id

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).

Show List (`interactive_list`)

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

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

Field	Required	Notes
Header Text	No	Optional list header
Body Text	Yes	Main prompt. Supports WhatsApp markup (`bold` `_italic_`) and line breaks; header stays plain text on WhatsApp.
Button Text	Yes	Label on the list open button (default often “View Options”)
List items / rows	Yes (static)	Title + optional description; max 10
Variable Name	No	Store selection; empty may default to `button_response` / list response vars
List Mode (v2)	No	Static or Dynamic (from API variable)
Data Source / Title / Description / ID fields (v2)	If dynamic	Map API array fields; optional pagination checkbox

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

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.

Field	Builders	Notes
Prompt Message	v1 + v2	Question sent to the customer
Save / Store Response In (variable name)	v1 + v2	v1 empty default: `last_input`
Validation Type	v1 + v2	v1: any, email, phone, number, date (DD/MM/YYYY), regex. v2: any, number, email, phone
Min / Max (number), custom regex + error message	v1	Shown when validation is number or regex
Max Retry Attempts	v1	Default 3 (range 1–10)
Retry Message / Error Node ID	v1	Custom fail message; optional node after max retries
Timeout minutes / seconds	v2	Optional. Leave blank for unlimited wait. Max 60 minutes total.
If no reply, go to	v2	Required 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.

Field	Notes
Source Variable	Text to parse (default `last_input` from Wait for Input)
Extraction Rules	One or more rules; all must match. Each rule has type, length/value checks, and target variable.
Extract Type	`digits`, `alphanumeric`, `letters`, `keyword` (value after phrase), `custom_regex` (uses capture group 1 if present)
Min / Max / Exact length	Validate extracted value length; exact length overrides min/max
Exact value	Optional — extracted text must equal this value
Store in variable	Required per rule — use `{{name}}` in later messages
No Match Message	Optional text sent when extraction fails
True Path / False Path	Required — 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.

Field	Notes
Variable to Check	Variable name from Wait for Input / buttons (braces optional)
Operator	equals, not_equals, contains, not_contains, greater_than, less_than, greater_or_equal, less_or_equal
Value	Comparison value
True Path	Required — next node when the condition matches
False Path	Required — 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).

Field	Notes
Logic Operator	AND (all true) or OR (any true)
Conditions list	Each 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 Path	Required — next node when the combined result is true
False Path	Required — 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.

Field	Notes
Method	GET, POST, PUT, PATCH, DELETE
API URL	Required; may embed `{{user_phone}}` or `{user_phone}`
Save response as	Variable for the full JSON string. Default `api_response`. Prefer extract rows for WhatsApp text.
Extract fields	Repeatable rows: Variable name + Path (e.g. `title` / `data.price` / `items.0.name`). Saved as `extractFields` object.
Headers	Optional key/value rows (not raw JSON in the primary UI)
Request Body	Shown for POST/PUT/PATCH; JSON with optional variables
Timeout (ms)	Default 10000
Success / Error Message	Optional; can use `{{extracted_var}}` and `{{_api_status}}`
Continue on Error	If 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.

Field	Notes
Handoff / Transfer Message	Text sent when transferring (v2 default: “Transferring you to a human agent...”)
Department	v2; default `general`
Priority / notify options	v1 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.

Field	Notes
Final / End Message	Optional 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.

Field	Notes
Media Type	image, video, or document
Media File	Optional upload from the properties panel
Media URL / Meta Media ID	Required; public URL or Meta media ID
Caption / Text	Optional

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).

Field	Notes
Variable to Check	Required
Cases	Each case: value, label, target node
Default Case	Node if no case matches

Set Variable (`set_variable`)

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

Field	Notes
Variable Name	Required
Operation	set, append, increment, decrement
Value	Required for set/append; can reference `{{other_variable}}`

Delay (`delay`)

Purpose: Pause before continuing.

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

Loop (`loop`)

Purpose: Repeat a section of the flow.

Field	Notes
Loop Type	count (N times), array (iterate items), condition (while true)
Max Iterations	For count; default 5 (max 100)
Array Variable	For array type
Condition Variable / Operator / Value	For condition type
Loop Back Node	Node to return to each iteration
Exit Node	Node when the loop finishes

Chatbot Flow (`flow_selector`)

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

Field	Notes
Chatbot automation	Required; choose from saved chatbot flows
Pass Variables	Default on — share current session variables
Return to Current Flow After Completion	Optional; continue parent flow after child ends
Return To Node	Where 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.

Field	Notes
Published Flow Design Form	Required; list from Flow Design (`PUBLISHED` only; value is Meta `meta_flow_id`)
Header / Body / CTA	Optional message copy; supports `{{variables}}`
Variable prefix	Default `flow_`. Each answer key becomes `{{prefix}field_name}}`

Wait behavior: The node sends the form and pauses (like Wait for Input). When the customer submits, webhook nfm_reply resumes the same node.

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).

Field	Notes
Approved WhatsApp Template	Required. Dropdown lists all `APPROVED` templates for this WABA. Carousel templates are excluded. Selecting a template auto-fills language and creates variable inputs.
Language	Auto-filled from the selected template (read-only).
Template Variables	One 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).

Field	Notes
Recipient Numbers	Required; one per line or comma/semicolon separated
Notification Message	Required; can include variables
Parse Variables	Checkbox; default on

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

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.

Nodes Reference

Quick index

Shared nodes (v1 + v2)

Start

Send Message (message)

Show Buttons (interactive_buttons)

Show List (interactive_list)

Wait for Input (wait_for_input)

Extract Text (extract_text)

Condition / Simple Condition (condition)

Advanced Condition (advanced_condition)

API Call (api_call)

Database Action / Save to Database (database_action)

Human Handoff / Transfer to Human (human_handoff)

End Flow (end)