List - Map

Type identifier: list:map Category: List Operations

Description

Iterates over each item in a list and runs the nodes connected to the trigger output for each one. Creates a scoped context for each iteration where the current item is available. Collects results from all iterations into an output list. Supports both parallel and sequential modes.

Input Handles

Input Handle Details

list

• Type: array

• Notes:

  • Must be an array
  • Can contain at most 1,000 items
  • Each item is processed in a scoped context
  • Empty arrays result in empty output list

return

• Type: Varies

• Notes:

  • Receives the mapped value for each iteration
  • Connected from the nodes in the iteration back to this node
  • Each value is collected into the list output at the original input position
  • Runs with expandable iteration history collect missing return values as null

Output Handles

Output Handle Details

item

• Type: Same as input array item type
• Notes: Available within the iteration context

index

• Type: number
• Notes: Zero-based index of current item

list

• Type: array

• Notes:

  • Contains all return values in order
  • Completion order does not change the result order
  • An empty input produces an empty output

Configuration Options

Configuration Details

sequential

• Type: boolean
• Default: New nodes have Sequential? selected. If the property is omitted from a saved definition, the node uses parallel mode.

• Notes:

  • false: Iterations may overlap within the run's available concurrency
  • true: Iterations run one at a time in order
  • Parallel mode does not guarantee simultaneous starts; available concurrency can allow only one item at a time

Behaviour

Execution Flow

1. Reads the list input
2. Validates input is an array
3. Runs the nodes connected to the trigger output for each item, with that item's item and index available
4. Collects return values from all iterations
5. Outputs collected results as list
6. Continues through success after successful control-triggered mapping

When the node is used only as a data source, it resolves the values needed for return without starting the iteration's control route or emitting success.

Parallel vs Sequential

Context Scoping

Each iteration runs separately with its own:

• item: Current array element
• index: Current position (0-based)
• Results are isolated between iterations
• return values are collected into list

Runs with expandable iteration history resolve data from outside the iteration once and share it with the items. Item results remain isolated. Nested maps have their own iterations rather than overwriting the parent item's values.

Run History

In run histories with recorded iteration details, List - Map appears as an expandable group with the node label, iteration count, mode, status, and duration. The map group starts expanded; individual iterations start collapsed.

Iteration labels start at Iteration 1 and follow input-list order, even when iterations run in parallel. Each iteration contains its own node events, nested maps, and child Flow runs. Expanding an iteration makes its events available for inspection.

Groups show running, succeeded, failed, abandoned, or incomplete as applicable. Duration is shown only when both start and end events are available. When a loaded map or iteration is incomplete, has missing iterations, or lacks duration details, the timeline automatically retrieves subsequent pages until those details are complete or no more history is available. A loading error stops automatic retrieval and is displayed in the timeline; Load more events remains available to retry. Filtered or unavailable history can still show incomplete and duration unavailable even after a run has finished. Events remain visible without grouping when the loaded history does not identify their iteration.

Expansion choices are retained while viewing the same run and reset when opening another run.

Trigger Handles

The incoming and outgoing error handles are distinct. Graphs using the incoming error route may use run histories without expandable iteration details. The outgoing route is not a catch-all handler for failures inside the iteration.

Error Handling

Examples

Transform Array Items

{
  "type": "list:map",
  "data": {
    "label": "Process Orders",
    "sequential": false
  }
}

Connect: list ← array source, item → processing nodes, processing result → return, list → downstream node.

Sequential Processing

{
  "type": "list:map",
  "data": {
    "label": "Sequential API Calls",
    "sequential": true
  }
}

Iterations run one at a time, so their operations do not overlap.

Extract Properties

{
  "type": "list:map",
  "data": {
    "label": "Extract Names"
  }
}

Map over an array of objects, extract a property with Object - Pick, return extracted value.