Chatbot Canvas Nodes: A Reference Guide to Every Node Type

TL;DR

The Mumble chatbot canvas is built from nodes. Each node is a step in the flow: a message to the customer, a choice based on a button or menu, a call to an external system, or a handoff to a human agent. This article covers every node type you can add to the canvas, what each one does, when to use it, and which fields it has. If you’re building a complex chatbot, keep this article open beside you.

How nodes are arranged on the canvas

The nodes live in the left-hand sidebar of the canvas. You drag a node onto the canvas, connect it to other nodes with arrows, and that’s how you build the flow. Each node receives input (what the customer said or tapped) and responds accordingly.

The main node (Main or Conversation Start) is a special node: it’s the entry point and receives every first message from the customer. In its Customer message field you’ll see *, a sign that it captures any input. Without a main node, the bot has no starting point.

The nine node types at a glance

The sidebar contains nine node types. You can group them into four categories by what they do in the flow: message nodes (send content to the customer), routing nodes (decide where the conversation continues), integration nodes (connect to external systems), and the AI node (uses Dolores AI for free-form handling).

Message nodes

The five nodes in this category handle everything the bot sends to the customer, from plain text to an interactive menu with media.

Standard message

A basic node that sends free-form text to the customer. The simplest form of bot communication.

Key fields:

• Message content. The text that will be sent. You can include dynamic variables in curly braces, for example {{first_name}}.
• Customer message. What the customer needs to type or tap to reach this node.

When to use it:

• A simple reply within an active conversation.
• A greeting after the customer has written something.
• A quick confirmation or update.

Important limitation: standard messages only work within the 24-hour conversation window. If the customer hasn’t replied for 24 hours, only a template message will work.

Template message

A node that sends a Meta-approved message template. You can use it at any time, including outside the 24-hour conversation window.

Fields:

• Select message template. From the approved templates in your account.
• Fill in the template variables. If the template includes {{1}}, {{2}}, you need to supply values (fixed text or a system variable).

When to use it:

• Opening a new conversation from the bot.
• Reminding a customer who hasn’t replied for a long time.
• A welcome message at the start of an automated flow.

Note the distinction between the two kinds of variables: a message template uses {{1}}, {{2}}, while canvas variables use names like {{first_name}}. They are not interchangeable and are a common source of confusion. See Message Templates: The Complete Guide.

Menu message

An interactive list with multiple items. The customer taps one of them.

Fields:

• Header text. What appears above the menu.
• Menu items. A list of options. Each one leads to the next node in the flow.

Important note on display: in the Mumble preview pane, the menu appears as plain text. In practice, on the customer’s WhatsApp it appears as a real, tappable interactive menu. Don’t be alarmed if it doesn’t look interactive in the preview.

When to use it:

• When you have four or more options. With fewer than that, use a button message.
• A service menu with many categories.
• Selecting a product from a catalog.

Button message

A message with 1 to 3 Quick Reply buttons. The customer taps one of them.

Fields:

• Message text.
• The buttons. Up to three buttons. Each one leads to the next node.

Meta limitation: a maximum of three Quick Reply buttons per message. This is a WhatsApp platform restriction, not a Mumble one. If you need more options, use a menu message.

When to use it:

• A binary choice: “Yes/No” or “Later/Now”.
• Three distinct options: “Support / Sales / General”.
• A call to action: “View offer / Ask a question / Not relevant”.

Media message

Sends visual content or a file to the customer.

Fields:

• Media type. Image, video, document, or audio.
• The file. Direct upload or a URL.
• Accompanying text (caption). A caption that appears below the image or above the file.

When to use it:

• Sending a logo or a product image.
• An order confirmation with a PDF receipt.
• An explainer video about a product.
• A welcome audio message (less common, but possible).

Maximum size: depends on the type. As of today, WhatsApp allows images up to 5MB, video up to 16MB, and documents up to 100MB. These limits are set by Meta and change from time to time, so it’s worth checking against the WhatsApp Business Platform documentation before relying on an exact number.

Routing nodes

The two nodes in this category handle moving the conversation to a different destination: a human agent or another chatbot.

Agent

A node that hands the conversation off to a human agent. The bot stops working on that conversation.

Fields:

• Specific agent or team. Choose which agent or team to route to.
• Pre-handoff message (optional). A message sent to the customer before they’re connected to an agent.

When to use it:

• At the end of a data-collection flow.
• When the bot can’t handle a specific topic.
• When the customer tapped “Talk to an agent”.

This is the node that ends the bot’s work and returns the conversation to the regular human-agent track.

Chatbot

A node that hands the conversation off to another chatbot. Useful when building multi-topic flows.

Fields:

• Select the target bot. From the existing bots in your account.

When to use it:

• Logical separation: a main bot that routes to dedicated bots (sales, support, onboarding).
• Reuse: a flow that appears in several bots is best extracted into a separate bot and called.
• Managing complexity: a large bot that tangles itself up with too many nodes becomes hard to maintain. It’s better to split it into small bots that talk to each other.

Integration nodes

This category contains one node that connects the bot to external systems.

HTTP request

A node that communicates with an external system. It sends a request and waits for a response.

Fields:

• Method. GET, POST, PUT, DELETE.
• URL. The address of the receiving system.
• Headers. For example Content-Type or Authorization.
• Body. The request content in JSON; can include canvas variables.
• Response mapping. How to parse the response and save it into variables that will be available in the following nodes.

When to use it:

• Fetching an order status from an e-commerce system.
• Verifying details against a CRM.
• Saving a lead to an external system.
• Reaching out to an external service for data that doesn’t exist in Mumble.

Debugging: the Logs button in the bottom bar of the canvas shows all the HTTP requests the bot has sent, along with their responses. Especially useful when something isn’t working.

This is different from a webhook in an automation, because it is two-way (it receives a response) and runs during the live conversation. See Webhooks in Mumble: The Complete Guide.

AI node

This category contains one node that embeds artificial intelligence directly into the flow.

AI

A node that runs Dolores AI as a step inside the flow. The bot hands off to the AI to handle a specific part and then continues with the regular flow.

Fields:

• Step-specific prompt. What the AI needs to do at this point.
• Exit condition. When to return to the regular flow.

When to use it:

• A single part of the flow that requires judgment (for example, classifying a lead as hot or cold based on what the customer said).
• Free-form questions in the middle of a structured flow (after the chatbot has collected details, the AI handles open-ended questions).
• Understanding intent before routing.

The AI node is available on the Pro plan and above. See Dolores AI: Getting Started Guide.

Accompanying actions on every node

Every response node has an “Actions” panel that lets you define additional actions that run when the node is triggered:

• Continue to the next message? If yes, the bot moves to the next node without waiting for a reply from the customer. Useful for sequences of consecutive messages.
• Add customer to a list. Adds the customer to a list upon reaching the node.
• Change customer status. Updates the conversation status.
• Turn off the bot for the customer. Ends the bot’s work on this customer. Useful at the end of a flow.
• Save point. If the bot is reset, it returns to this node instead of the beginning. Useful for long flows you don’t want to restart after a timeout.
• Save the message. Saves the customer’s reply into a variable you can use in the following nodes. This is the core mechanism for “ask the customer something and use the answer later in the flow”.

Billing by nodes

Every time a node runs, it counts as one operation for billing purposes. This means:

• A flow of 5 nodes that runs in full for one customer = 5 operations.
• Monthly allowances by plan: Standard 25, Pro 100, Scale 500, Enterprise 1,000 operations.
• Overage cost: one dollar per additional operation. This is the most expensive overage in Mumble.
• HTTP and AI nodes count as regular operations, with no surcharge.

The takeaway: short, focused flows are cheaper than long ones. It’s worth confirming the current numbers on the Plans and Pricing page before relying on them.

Best practices

• Plan the flow before you start building. Ten minutes with pen and paper saves an hour of canvas editing.
• Keep nodes short. One node = one idea. If you need a lot of text, split it into two.
• Add save points at strategic spots. After collecting important information, before a complex step, and before an agent handoff.
• Always save important answers into variables. Name, email, order number. Otherwise the information is lost once the conversation moves on.
• Plan an “I don’t know” path at every decision point. Wherever there’s a choice, make sure there’s a “I didn’t find what I was looking for” path that leads to an agent.
• Use the AI bot check before going live. The AI Checker button in the sidebar detects loops, unconnected nodes, and dead-end paths.
• Save the canvas regularly. The Save button is essential after every significant change. A long editing session without saving can be lost if you refresh the page without saving.

Common issues and troubleshooting

• The menu doesn’t look interactive in the preview. This is normal. In Mumble’s internal preview, menus appear as text, but on the customer’s WhatsApp they appear as real buttons.
• A standard message isn’t sending. The customer is most likely outside the 24-hour conversation window. Switch to a template message.
• An HTTP node returns an error. Open Logs in the bottom bar and check the status code and the response body. In most cases it’s a wrong header or an invalid URL.
• The bot returns to the beginning every time. A save point is missing. Add one at the node from which you want the flow to continue after a reset.
• A template message doesn’t appear in the list. The template isn’t in “approved” status, or it’s in a different language from the one set for the bot.
• The bot hands off to an agent too soon. Check whether one of the agent-handoff keywords (default: “agent”) appears in the text the customer sent.

Related articles

• Building a Chatbot in Mumble: The Canvas Guide
• Chatbot Settings in Mumble
• Dolores AI: Getting Started Guide
• Message Templates: The Complete Guide

The bottom line

The nine node types cover everything a Mumble chatbot can do: send messages, route, connect to external systems, and run AI. Success in chatbot design depends not only on knowing what each node does, but on when to use it and in what order. Planning before building is the difference between a bot that works and a bot that breaks down on the third message.