Master Arrays in Make.com: Iterator and Array Aggregator Guide

When building advanced automations in make.com, you will often need to split data into items, process each one, and then rebuild that data into a clean array. This article explains, in practical detail, how to work with the Iterator and Array aggregator modules so your scenarios handle arrays reliably from start to finish.

Why Arrays Matter in Make.com Scenarios

Arrays are simply ordered lists of items. In automations, they typically appear as lists of records, such as:

• Rows from a spreadsheet
• Contacts from a CRM search
• Line items from an invoice
• Messages or comments from an API response

Inside make.com, some modules output an array directly, while other modules expect a single bundle (item) at a time. The Iterator and Array aggregator are the bridge between these two worlds, allowing you to break arrays apart, process each element, and then merge everything back into a structured list.

Understanding the Iterator in Make.com

The Iterator module in make.com converts an input array into a sequence of bundles. Each run of the module outputs one item from the original list. This lets you apply any downstream logic on a per-item basis.

Key behavior of the Iterator in Make.com

• Input: One array field (e.g., a list of rows or objects).
• Output: Multiple bundles, one for each item in the array.
• Execution: Every module after the Iterator runs once per item, until all items have been processed.

This pattern is ideal when you need to:

• Transform each record separately
• Call an external API for every item
• Filter or validate items before saving them

How to configure the Iterator in Make.com

1. Add the Iterator module: In your scenario, click the plus icon and search for the Iterator tool.

2. Select the array to iterate: In the module configuration, choose the array field from the previous module’s output. This is usually marked as a list or array in the output structure.

3. Map the fields: The Iterator exposes each array item as a bundle. You can map the item’s properties directly into subsequent modules.

4. Run the scenario: When you execute the scenario, watch the execution log to see one route run per item.

Understanding the Array Aggregator in Make.com

The Array aggregator module in make.com takes multiple bundles and combines them into a single array. This is often used after an Iterator or any route that generates multiple bundles you want to collect back into one list.

Key behavior of the Array aggregator in Make.com

• Input: Multiple bundles arriving one by one.
• Output: One bundle containing an array field with all aggregated items.
• Execution: It waits for all bundles in a group and then emits a single result.

Use the Array aggregator when you want to:

• Send a single batched request to an API instead of many small ones
• Build a final report or summary from processed items
• Create a structured list to write into a file, email, or document

How to configure the Array aggregator in Make.com

1. Add the Array aggregator: Place the module after the part of your scenario that outputs multiple bundles.

2. Set the source module: Choose which module’s output you want to aggregate. This is often the Iterator or a module after it.

3. Define the aggregation: In the Target structure or similar configuration, specify which fields from incoming bundles should be compiled into the resulting array items.

4. Configure grouping (optional): If you need separate arrays per group (for example, per customer or per file), set a Group by value using an appropriate field.

5. Run and inspect: Execute the scenario and check the output array to confirm all items are present and correctly formatted.

Combining Iterator and Array Aggregator in Make.com

The most common pattern with arrays in make.com is:

1. Receive an array from a trigger or search module.
2. Use an Iterator to process each item individually.
3. Apply any logic needed for each item (filters, lookups, transformations, API calls).
4. Aggregate the processed items with the Array aggregator.

Step-by-step example pattern

1. Trigger or search: A module retrieves a list of records, outputting an array.

2. Iterator: You add the Iterator and select that list as input. Each execution of the following modules works on a single record.

3. Processing modules: For each record, you might:

   • Clean up text fields
   • Enrich data from another system
   • Filter out items you do not need

4. Array aggregator: Once processing is complete, the Array aggregator gathers all resulting bundles into a new array containing only the refined items.

5. Output: You send that final array to another service, save it to a file, or store it in a database.

Common configuration tips in Make.com

Choosing the right array field

When setting up the Iterator, make sure you select the real array, not a single object. In the output of your previous module, look for fields marked as lists. Selecting a non-array field will cause the module to behave unexpectedly or fail.

Designing a clear target structure

In the Array aggregator, define a target structure that mirrors what your next module expects. For example, if you plan to send a JSON body to an external API, configure an array of objects with exactly the keys that API requires.

Using grouping effectively

Grouping lets you produce several arrays instead of just one. A common strategy is to group by:

• Customer ID
• Document ID
• Date or period

This helps you build batch data per entity while still processing everything in a single scenario run in make.com.

Troubleshooting Iterator and Array Aggregator in Make.com

Iterator outputs only one bundle

If you see a single item where you expected many:

• Verify that the input really is an array, not a single object.
• Check sample data in the run history to confirm there are multiple elements.
• Ensure no filter placed after the Iterator is discarding most items.

Array aggregator returns an empty array

If the aggregated array is empty in make.com:

• Confirm that some bundles are actually reaching the Array aggregator.
• Review filters or routers that might be skipping all items.
• Check the Source module setting so it points to the correct upstream module.

Unexpected structure in the final array

When the output does not match what you expect:

• Open a sample execution and inspect the aggregator output step.
• Adjust the mapped fields in the target structure so they reference the desired data.
• Keep object nesting simple and consistent for easy downstream use.

Further learning and resources for Make.com users

To deepen your understanding of iterators and array aggregators, explore the official how-to guide straight from the source: Iterator and Array Aggregator tutorial on make.com. It provides visual examples that complement the concepts outlined here.

If you need expert help designing robust scenarios, optimizing arrays, or improving error handling, you can also work with automation specialists at Consultevo, where consultants focus on building maintainable, scalable workflows.

Conclusion: Confident array handling in Make.com

By mastering the Iterator and Array aggregator in make.com, you gain precise control over how lists of data move through your automations. Use the Iterator to break arrays into manageable items, process each one with clear logic, and then rely on the Array aggregator to rebuild structured arrays ready for export, reporting, or further integration. With these two modules configured correctly, your scenarios remain flexible, readable, and easy to scale as your data grows.

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