​

Calling Other Blueprints

When would you use this? Use the Call Node when you have logic that you want to reuse across multiple blueprints — like a tax calculation, a validation check, or a pricing formula. Instead of duplicating the logic, you build it once in its own blueprint and call it from wherever you need it. Think of it like delegating a task to a colleague: you give them the information they need, they do the work, and they give you the result back. The Call Node works exactly the same way — your blueprint hands off data to another blueprint, waits for it to finish, and then continues with the result.

​

What is a Call Node?

A Call Node is a special element in your blueprint that runs another blueprint as part of your logic flow. It has three parts:

1. Target Blueprint — which blueprint to call
2. Inputs — the values you pass to the called blueprint
3. Result Variable — where to store the result that comes back

When your blueprint reaches a Call Node during execution, it pauses, runs the called blueprint with the inputs you provided, captures the result, and then continues with the next element in your flow.

​

Adding a Call Node

To add a Call Node to your blueprint:

1. Click the + button on a connection point in your flow
2. Select Call another blueprint from the element palette

The Call Node appears in your flow as a distinct element. It looks different from other elements because it represents an entire blueprint, not a single operation.

​

Selecting the Target Blueprint

After adding a Call Node, you need to tell it which blueprint to call:

1. Click on the Call Node to select it
2. Click on the blueprint selector (it shows “Select blueprint…” initially)
3. A popover appears listing all blueprints in your project
4. Select the blueprint you want to call

Once selected, the Call Node displays the name of the target blueprint, so you can see at a glance which blueprint it calls.

​

Important Notes

• You can only call blueprints within the same project
• The called blueprint must already exist — create it first, then call it
• If you rename the called blueprint later, the Call Node updates automatically

​

Mapping Inputs

Most blueprints need input data to do their work. When you call a blueprint, you map values from your current blueprint to the inputs that the called blueprint expects. For example, if you are calling a “Calculate Tax” blueprint that expects an amount input, you provide an expression from your current scope — like orderTotal or price * quantity.

​

How Input Mapping Works

1. The Call Node shows the input parameters that the target blueprint expects
2. For each parameter, you enter an expression that provides the value
3. Expressions can be variable names, calculations, or literal values
4. Autocomplete helps you find available variables from your current scope

​

Examples of Input Expressions

​

Capturing the Result

After the called blueprint finishes, it returns a result. You store this result in a result variable so your blueprint can use it in subsequent elements. The input mapping and result variable are both configured in the same panel (shown above). For example, if you call a “Calculate Tax” blueprint, you might store the result in a variable called taxAmount. You can then use taxAmount in any element that comes after the Call Node — in decisions, assignments, or even as input to another Call Node.

​

Setting the Result Variable

1. In the Call Node configuration, find the result variable field
2. Enter a valid variable name (letters, numbers, underscores)
3. This variable becomes available in your blueprint from this point forward

​

Example

Here is a practical example of how a Call Node fits into a blueprint: Scenario: You have an order processing blueprint that needs to calculate tax. Instead of building the tax logic directly, you call a separate “Calculate Tax” blueprint. Main Blueprint — Process Order:

1. Assignment: subtotal = price * quantity
2. Call Node: Call “Calculate Tax” with amount = subtotal → result stored in taxResult
3. Assignment: total = subtotal + taxResult
4. Return: Return total

Called Blueprint — Calculate Tax:

• Input: amount (number)
• Logic: Applies the appropriate tax rate based on the amount
• Output: The calculated tax value

When the main blueprint runs:

1. It calculates the subtotal (e.g., subtotal = 50)
2. It calls “Calculate Tax” with amount = 50
3. “Calculate Tax” runs and returns 9.50
4. The result is stored in taxResult = 9.50
5. It calculates the total: total = 50 + 9.50 = 59.50
6. It returns 59.50

​

Use Cases

Call Nodes are essential for:

• Reusing common logic: Build validation, calculations, or formatting once and call from multiple blueprints
• Breaking down complexity: Split a large blueprint into smaller, focused blueprints that are easier to understand and test
• Standardizing business rules: Ensure the same tax calculation, discount logic, or compliance check is used consistently everywhere
• Team collaboration: Different team members can work on different blueprints independently, then connect them with Call Nodes

​

Best Practices

• Name blueprints clearly: The called blueprint’s name appears in the Call Node, so descriptive names like “Calculate Tax” or “Validate Customer” make your flow easier to read
• Keep called blueprints focused: A called blueprint should do one thing well. If it is doing too much, consider splitting it further
• Define inputs and outputs carefully: The called blueprint’s data contract (inputs and outputs) is the interface between your blueprints — keep it clean and well-documented
• Test called blueprints independently: Before calling a blueprint, make sure it works correctly on its own with the expected inputs
• Avoid deep nesting: While a called blueprint can call another blueprint (and so on), too many levels of nesting makes the logic hard to follow. Leapter limits call depth to 10 levels

In short: The Call Node lets you build reusable logic once and call it from anywhere in your project. You select the blueprint, map the inputs, capture the result — and your blueprints stay clean, focused, and easy to maintain.