How to use the Iterator module in Make.com

The Iterator module in Make.com lets you process items in an array one by one, turning a collection of values into individual bundles you can work with in your scenarios.

This step-by-step guide explains what an Iterator is, how it behaves in a scenario, and how to configure it safely so you avoid common issues such as lost data or infinite loops.

What the Iterator in Make.com does

The Iterator module processes arrays by splitting them into separate bundles. Each item in the array becomes its own bundle that continues through the rest of the scenario.

You usually use an Iterator in Make.com when:

• A previous module outputs an array (such as a list of records, emails, or files).
• You want to perform the same set of actions on every item in that list.
• You need to map each item’s fields into later modules.

Important behavior details:

• An Iterator consumes the input bundle and produces new bundles, one per item.
• Downstream modules run once per item emitted by the Iterator.
• The order of items in the output matches the order in the input array.

Key Iterator concepts in Make.com

Before configuring the module, it is useful to understand these core concepts from the original Make.com Iterator documentation.

Array input in Make.com Iterator

The Iterator input must be an array. This typically comes from:

• A search or list module that returns multiple records.
• A webhook or data structure that includes an array field.
• A previous transformation (for example, aggregating items and then iterating them later in the scenario).

If the value you map to the Iterator is not an array, the module will not be able to produce bundles correctly.

Bundles produced by the Iterator

Each item in the array becomes a separate bundle. These bundles each contain:

• The fields of the current item.
• Any additional values that the Iterator exposes (depending on the configuration of the module in Make.com).

Subsequent modules receive these bundles one by one and execute once per bundle.

How to configure an Iterator in Make.com

Follow these steps to add and configure an Iterator module in your scenario.

1. Add the Iterator module

1. Open your scenario in Make.com.
2. Click the plus icon on the route where you want to iterate items.
3. Search for and select the Iterator module.

Place the Iterator after a module that outputs an array, such as a list or search operation.

2. Map the array field

1. Open the Iterator module configuration.
2. In the Array field, select or map the array you want to split.
3. Use the data picker to choose the exact array field from the previous module’s output.

Be careful to select the array itself, not a single property inside the array. For example, map items[], not items[1].name.

3. Review output fields

After you save the Iterator, run the scenario in a test mode so you can see what bundles it produces. The output of the Iterator should show one bundle per item.

Use the output to verify:

• All expected items are present.
• The fields you need are available for mapping into the next modules.
• The bundle structure is stable and predictable for later use.

Mapping Iterator output in Make.com

Once the Iterator is working, every module after it will execute once for every item. You can now map the fields from each bundle into later modules.

Example mapping pattern in Make.com

A typical pattern is:

1. Trigger module receives a payload with an array field.
2. An Iterator splits that array into individual bundles.
3. A processing module (for example, a database insert or email send) uses the fields from each bundle.
4. Optional: an aggregator module at the end collects the results back into a single array.

This pattern lets you handle complex data structures while still controlling execution bundle by bundle.

Iterator best practices in Make.com

When you work with Iterators in Make.com, pay attention to these best practices to keep scenarios stable and efficient.

Avoid unnecessary nesting

Do not create multiple nested Iterators unless you genuinely need to iterate over arrays inside arrays. Deep nesting makes scenarios harder to debug and can increase execution time.

Watch execution counts

Every item in the array becomes a new execution path. Large arrays can trigger many operations in the rest of the scenario. Consider:

• Adding filters to limit how many items you process.
• Using search conditions in the source module to reduce output size.
• Scheduling runs when large batches will not impact account limits.

Validate array content

Ensure the array you map to the Iterator actually contains the structure you expect:

• Test with sample data that represents a real-world case.
• Check for null or missing fields inside individual items.
• Confirm that indexes and field names are stable.

Troubleshooting the Iterator in Make.com

If your Iterator is not behaving as expected in Make.com scenarios, use these checks.

No bundles after the Iterator

If the Iterator shows zero output bundles:

• Verify that the previous module returned at least one item in the array.
• Confirm that you mapped the correct array path in the Iterator configuration.
• Run the previous module alone to inspect its raw output.

Incorrect data in bundles

If the Iterator bundles show unexpected fields or values:

• Check the structure of the array returned from the source module.
• Open the mapping and confirm that you selected the top-level array, not a nested field.
• Inspect one sample bundle in detail to understand the exact field names.

Too many operations triggered

If your scenario unexpectedly consumes many operations:

• Count how many items are in the array feeding the Iterator.
• Add filters to skip items that do not need processing.
• Consider splitting a very large run into several smaller batches.

Additional resources for Make.com users

To go deeper into Iterator behavior and related modules, review the official documentation and training materials.

• Official Iterator reference: Iterator module documentation
• Automation consulting and implementation services: Consultevo

By combining Iterators with other modules in Make.com, you can build flexible flows that cleanly handle lists, arrays, and complex data structures without writing custom code.

Need Help With Make.com?

If you want expert help building, automating, or scaling your Make scenarios, work with ConsultEvo — certified workflow and automation specialists.

Get Help