Process multiple items efficiently in N8N, Zapier, and Make
Looping allows you to process multiple items (arrays, lists, records) one at a time in your workflow. This is essential when working with bulk data, API responses with multiple results, or any scenario where you need to repeat actions for each item.
Get 20 new leads from database → Send personalized email to each
Analyze sentiment of each customer review individually
Process each row from spreadsheet to update CRM records
Extract data from multiple uploaded files one by one
N8N processes arrays automatically - each item flows through subsequent nodes
N8N's default behavior is to automatically loop through items. When a node outputs multiple items, the next node processes each one individually.
Example Flow:
For explicit loop control or when you need to process items in batches, use the Split In Batches node.
Configuration:
• Batch Size: Number of items to process per batch (e.g., 5)
• Options: Reset on each workflow execution
How It Works:
The Loop Over Items node provides more advanced control over iteration.
Airtable: Get all leads with status "New"
Split In Batches: Process 5 leads at a time (to respect API limits)
OpenAI: Generate personalized outreach for each lead
Wait: 2-second delay between API calls
Gmail: Send email to lead (loops back to step 2 until done)
Airtable: Update all leads to "Contacted" (from Done output)
Zapier uses the Looping by Zapier app for explicit iteration
Unlike N8N, Zapier doesn't automatically loop through arrays. You need to explicitly add the Looping by Zapier app to process multiple items.
Important:
Each loop iteration counts as a separate task in your Zapier billing. A loop processing 100 items = 100 tasks.
Step-by-Step:
Add Looping by Zapier Action
Choose "Create Loop from Line Items" action
Map Your Data
Select the field that contains your list of items (line items)
Add Actions for Each Item
Steps after the loop run once per item
Reference Loop Data
Use {{Loop Value}} to access the current item
Example Configuration:
Loop by Zapier: Create Loop from Line Items
↳ Values: {{1.emails}} (comma-separated list)
ChatGPT: Create Completion
↳ Prompt: Write email to {{Loop Value}}
Gmail: Send Email
↳ To: {{Loop Value}}
↳ Body: {{ChatGPT Output}}Some triggers naturally handle multiple items without needing the Loop app:
This approach is more efficient as each trigger = 1 task, rather than 1 task per loop iteration.
Google Sheets: New Row (triggers for each row)
ChatGPT: Generate personalized message for {{Name}}
Delay: Wait 5 seconds (respect rate limits)
Gmail: Send email to {{Email}}
Note: This Zap runs automatically for each new row added to the sheet. No explicit loop needed!
Make has powerful built-in tools for handling arrays and iteration
Like N8N, Make automatically processes arrays. When a module outputs multiple bundles (items), subsequent modules process each bundle individually.
Key Concept: Bundles
In Make, each item is called a "bundle". If a module outputs 10 bundles, the next module runs 10 times automatically.
Use the Iterator module when you have an array nested inside a bundle and need to process each array element.
When to Use Iterator:
Example Scenario:
API Response (1 bundle):
{
"order_id": "12345",
"items": [
{"product": "Widget A", "qty": 2},
{"product": "Widget B", "qty": 1},
{"product": "Widget C", "qty": 5}
]
}
Add Iterator Module:
↳ Array: {{items}}
Result: 3 bundles (one per product)
↳ Bundle 1: Widget A
↳ Bundle 2: Widget B
↳ Bundle 3: Widget CThe Array Aggregator does the opposite - it combines multiple bundles back into a single array.
Use Cases:
Pattern:
Iterator (split) → Process each item → Array Aggregator (combine) → Send combined result
The Repeater module repeats an action a specific number of times, like a traditional for-loop.
Google Sheets: Watch Rows (returns multiple rows)
OpenAI: Analyze sentiment (runs for each row automatically)
Array Aggregator: Combine all sentiment results
OpenAI: Generate summary report from aggregated data
Slack: Post summary to #customer-feedback channel
When looping through API calls (especially LLMs), add delays between iterations to avoid hitting rate limits.
For large datasets, process items in smaller batches to improve reliability and manage costs.
Example:
Instead of: Process 1,000 items at once
Do: Process 50 items, wait 1 minute, repeatDon't let one failed item break your entire loop. Implement error handling for individual items.
All platforms have execution time limits:
For long-running loops, split into multiple scenario runs or use async processing.
For long loops, track progress so you can resume if something fails:
Looping affects your usage differently on each platform:
Get list → Loop through contacts → Generate personalized message → Send email
Add delay between sends to avoid spam filters
Get documents → Loop through files → Extract data with LLM → Store in database
Process in batches of 10-20 for reliability
Get records from source → Loop and check if exists in destination → Create or update each
Track last sync timestamp to process only new items
Get items → Loop and analyze each → Aggregate results → Generate summary report
Use aggregator modules to combine individual results
Problem: Loop not executing
Check that previous step is returning an array. Use a debug step to inspect data structure.
Problem: Loop runs too many times
Verify your array isn't nested. You may need to use an iterator to access the actual array.
Problem: Loop times out
Process in smaller batches or split into multiple workflow runs. Consider async processing for large datasets.
Problem: High task/operation usage
Each loop iteration counts toward your limits. Consider if bulk operations or API batch endpoints would be more efficient.