Skip to main content
Loop

​
Overview

The Loop node processes arrays of data - iterate through lists of customers, orders, files, or any collection, applying the same logic to each item.
Best for: Batch processing, processing multiple records, generating individual reports, and iterating over lists.

​
Configuration

Input Array: Select the array to loop over 
{{ trigger.output.customers }}
{{ api_response.output.items }}
{{ google_sheets.output.rows }}
Max Iterations: Safety limit (default: 200, max: 2000)

​
Advanced Options

Concurrency: Enable parallel processing of loop iterations When enabled, all iterations run simultaneously instead of one after another. This significantly speeds up loops but requires that iterations don’t depend on each other.
ConcurrencyBehaviorBest For
Off (default)Sequential - each iteration waits for the previous one to completeDependent operations, rate-limited APIs
OnParallel - all iterations run at the same timeIndependent operations, faster processing
With concurrency enabled, iterations may complete in any order. Don’t use concurrency if later iterations depend on results from earlier ones.
Collect Outputs: Gather all iteration results into a single array When enabled, the loop end node outputs an array containing results from every iteration. This is useful for aggregating data processed in the loop. 
{{ loop_end.output.iterations }}            → Array of all iteration data
{{ loop_end.output.iterations[0].item }}    → First iteration's input item
{{ loop_end.output.iterations[0].executions }}  → Nodes executed in first iteration
{{ loop_end.output.total }}                 → Total number of iterations
Collected Output Structure: 
{
  "iterations": [
    {
      "index": 0,
      "item": { "original": "data" },
      "executions": [
        {
          "nodeId": "abc123",
          "nodeSlug": "agent",
          "nodeType": "agent",
          "input": { ... },
          "output": { "result": "processed" }
        }
      ]
    }
  ],
  "total": 10
}
Use Collect Outputs when you need to aggregate results, create reports from all iterations, or pass loop results to a downstream node for final processing.

​
Inside the Loop

The loop node’s slug becomes your variable name. Access the current item and iteration info: 
{{ customer.output.currentItem }}           // The full current item
{{ customer.output.currentItem.name }}      // Access item properties
{{ customer.output.currentItem.email }}
{{ customer.output.currentIndex }}          // Current iteration (0-based)
{{ customer.output.total }}                 // Total items in array

​
Example Use Cases

​
Process Customer List

Loop over {{ trigger.output.customers }}
  Loop node slug: customer

  → Agent: Analyze {{ customer.output.currentItem.feedback }}
  → Condition: Check {{ customer.output.currentItem.score }}
    → High: Send thank you email
    → Low: Create follow-up task

​
Batch Update Records

Loop over {{ api_response.output.records }}
  Loop node slug: record

  → Code: Transform {{ record.output.currentItem.data }}
  → HTTP Request: Update record {{ record.output.currentItem.id }}

​
Generate Individual Reports

Loop over {{ trigger.output.team_members }}
  Loop node slug: member

  → HTTP Request: Fetch {{ member.output.currentItem.id }} data
  → Agent: Generate report for {{ member.output.currentItem.name }}
  → Action: Email report to {{ member.output.currentItem.email }}

​
Parallel Image Processing (Concurrency)

Loop over {{ trigger.output.images }}
  Loop node slug: image
  Parallel Execution: On

  → Agent: Analyze {{ image.output.currentItem.url }}
  → Code: Extract metadata
All images are analyzed simultaneously, completing much faster than sequential processing.

​
Aggregate Results (Collect Outputs)

Loop over {{ trigger.output.documents }}
  Loop node slug: doc
  Collect Outputs: On

  → Agent: Summarize {{ doc.output.currentItem.content }}
  → Code: Extract key points

→ Agent: Create master summary from {{ loop_end.output.iterations }}
→ Action: Send combined report
The final Agent receives all summaries at once to create a comprehensive report.

​
Best Practices

Prevent infinite loops and runaway costs. Set a reasonable maximum.
Instead of 100 individual agent calls, batch items into groups of 10.
Add a condition before the loop to check if array has items.
Loops with AI agents can be expensive. Calculate: cost per item × number of items.

​
Cost Warning

Loops can consume significant credits when processing many items with AI agents. A loop with 100 items and an agent call at 0.10each=0.10 each = 10 per run.

​
Next Steps

Agent Node

Process items with AI

Cost Management

Optimize loop costs