Make.com Iterator How to Loop Through Arrays and Process Each Item

You’ve got output from a module that returns an array — a list of orders, rows from Google Sheets, API results. And you need to process each item separately. That’s where the Make.com iterator comes in.

The iterator is one of the most-used modules in Make.com. It’s also one where beginners get stuck the most. This article explains how it works, how to set it up, and which patterns work best in practice.

What Is the Make.com Iterator and How Does It Work

The iterator takes an array as input and outputs individual items one by one. Make.com then processes each item as a separate bundle.

Simple example: you have an array ["alice@example.com", "bob@example.com", "carol@example.com"]. The iterator turns that into three separate runs — one per email. Each run can send an email, create a CRM record, or whatever else you need.

Without the iterator, you’d have to process the entire array at once — which most modules don’t support, or gives wrong results.

When to Use the Iterator

Use the iterator whenever:

• A module returns an array and you need to work with each item individually
• You want to trigger an action for every row in Google Sheets
• You’re processing API results that return a list of objects
• You need to filter or transform each item individually

⚠️ Don’t use the iterator if you need to aggregate results back into an array — that’s what the Aggregator is for.

How to Set Up the Iterator Step by Step

Step 1: Identify the array in the previous module’s output

Look at the output of the module before the iterator. You’re looking for an Array type — in Make.com you’ll recognize it by the bracket notation [] in the data structure.

Example: an HTTP module returns a JSON response where data.items is an array of objects.

Step 2: Add the Iterator module

Click + after the module that returns the array. Select Flow Control, then Iterator.

In the iterator settings, you’ll find one field: Array. Map the array from the previous module — for example {{1.data.items}}.

Step 3: Map the iterator’s outputs

The iterator exposes each array item as a separate bundle. In the following modules, you work with:

• {{2.value}} — the full item (if it’s a primitive like a string or number)
• {{2.value.id}}, {{2.value.name}} etc. — object properties

Step 4: Set up processing

Add modules after the iterator to handle each item. Make.com automatically runs them for every bundle the iterator produces.

💡 Want to know how many items the iterator will process? Use {{2.total}} — that’s the total count of items in the array.

Most Common Patterns in Practice

Pattern 1: Simple per-item processing

The most basic case — for each item, do one action.

HTTP (returns array) → Iterator → Action per item

Example: Fetch orders from your store → Iterator → Create a record in Airtable for each order.

Pattern 2: Iterator with filter

Want to process only some items? Add a Router or Filter module after the iterator.

HTTP → Iterator → Filter (status=active only) → Action

Set the filter condition based on a property from {{2.value.status}}.

Pattern 3: Iterator with Aggregator

Need to process items and then combine the results back into one output? Add an Array Aggregator after the processing.

HTTP → Iterator → Transform → Array Aggregator → Further processing

Useful when you transform each item and want to send the results as a single array to the next system.

Pattern 4: Nested iterators

Have an array of arrays? For example, a list of orders where each order has an array of line items?

HTTP → Iterator (orders) → Iterator (order items) → Action

Nested iterators work — but watch your operation count. Every outer/inner item combination is a separate bundle.

Ready-Made Pattern Toolkit

I spent years collecting and refining these patterns in real scenarios. The result is the Make.com Iterator Patterns Toolkit — a set of ready-made blueprints you import into Make, remap the variables, and have a working scenario in minutes.

Instead of hours figuring out how to nest iterators or why the aggregator returns an empty array — grab the right pattern from the toolkit and you’re done.

Summary

The Make.com iterator is the key module for working with arrays. It takes an array and processes each item as a separate bundle — opening the door to dozens of use cases from API result processing to bulk actions on Google Sheets data.

Start with the simplest pattern — one iterator, one action after it. Once you’ve got that down, add a filter or aggregator and you’re ready to tackle more complex cases.