Loop Node

The Loop Node iterates over an iterable in the dictionary, runs a body per item, and continues the flow when every item has been processed.

What it serves

You point the node at a dictionary property that holds an iterable (an array, typically). The node walks that iterable item-by-item: for each item, it writes the value into another dictionary property and runs the body wired to its OUT edge. The body must wire back into the loop node's input — the loop's state machine only advances on re-entry, so returning to the node is what moves it to the next item. When the iterable is exhausted, the node exits via FINISH and the rest of the flow continues.

Visual — the dots

Under the hood the node exposes two edges: a body edge (next_2, fires once per item) and a finish edge (next_1, taken when iteration completes). On the canvas they read as:

Dot	Position	Role
IN	Top	Where execution enters the node — and where each iteration's body must return to advance the loop (re-entry input).
OUT	Right	Where each iteration's body starts (the next_2 body edge). Fires once per item.
FINISH	Bottom	Where the flow continues after all items have been processed (the next_1 finish edge), or immediately if the source isn't iterable.

There is no separate "next iteration" output edge: the loop advances only when the body wires back into the node's input. If the canvas shows a distinct return dot on the left, treat it as the loop's re-entry input — wiring the body there is the same as re-entering the node.

The empty-state label on the node reads "No Iterable Property".

Settings

Click the node to open Loop Node Settings. Three fields plus Apply:

Field	Purpose
Read from	The dictionary property to iterate over. Enter test → the node reads dictionary.test. This must hold an iterable (typically an array).
Set to	The dictionary property where each item is written before the body runs. Enter receivedValue → on each iteration the current item is assigned to dictionary.receivedValue.
Node Description	Free-text — for other developers. Doesn't affect execution.
Apply	Saves the settings.

How an iteration goes

IN ──► [Loop reads dictionary.<readFrom>]
         │
         ├─ not iterable? ──► FINISH (immediately, no iterations)
         │
         └─ iterable
              │
              ├─► assign item[0] to dictionary.<setTo> ──► OUT ─►  body  ─► back to IN ──┐
              │                                                                          │
              ├─► assign item[1] to dictionary.<setTo> ──► OUT ─►  body  ─► back to IN ──┤
              │                                                                          │
              ├─► …                                                                      │
              │                                                                          │
              └─► no more items ──────────────────────────────────────────────► FINISH  ─┘

Anything connected after OUT sees dictionary.<setTo> set to the current item. The body's terminal node must wire back into the loop node's input so the loop re-enters and advances. Anything connected after FINISH runs once, after the loop is done.

Important — non-iterable source

If dictionary.<readFrom> is missing, null, undefined, or otherwise not iterable, the node does not loop. It exits immediately via FINISH with zero iterations. The body wired to OUT never runs.

This makes the node safe to drop into a flow even when the source might be empty — it just no-ops through to FINISH.

Example wiring

        ┌───────────────────────────────────────────────┐
        │                                               │
        ▼                                               │  (body returns to IN)
   ┌─────────┐                                          │
   │  Loop   │                                          │
   │   IN    │                                          │
   │         │                                          │
   │   OUT   ├──► [Script body 1] ──► [Script body 2] ──┘
   │         │
   │ FINISH  ├──► [Jump Flow]
   └─────────┘

(That's the shape shown in the example screenshot for loop-node.)

The body can be one node or many — whatever you need. As long as the body's terminal output wires back into the Loop node's input, the loop re-enters and the iteration continues.

Tips

• Read from is just a property name — test, not dictionary.test. The node prepends dictionary. for you.
• Set to can be the same on every Loop in a flow if you don't reuse the value across loops, but pick distinct names if you nest loops — otherwise the inner loop overwrites the outer's current item.
• For independent parallel work over a collection (no dependency between iterations), reach for Parallel Flow instead — it fans out, where Loop processes serially.