Mastering the Make.com Array Aggregator

The Array Aggregator in make.com is a powerful tool for restructuring, summarizing, and grouping data inside your automations. Understanding how to configure this module correctly lets you transform multiple bundles into a single, well-structured array you can reuse later in your scenario.

This how-to guide explains what the Array Aggregator does, how it differs from other tools in make.com, and how to configure it step by step using a practical scenario.

What the Make.com Array Aggregator Does

The Array Aggregator module collects multiple incoming bundles and outputs them as a single array. Each bundle that reaches the module becomes one item inside that array. This is useful whenever you need to:

• Group several related records together
• Prepare data for one final API call or action
• Summarize or restructure fields from multiple bundles
• Create nested data structures such as arrays of line items

Unlike ordinary iterator or mapping modules, this make.com module is designed specifically to merge several executions into one array output at the end of a cycle.

When to Use the Array Aggregator in Make.com

The Array Aggregator module in make.com is ideal in scenarios where you must collect information from many records before sending it forward. You will typically use it when:

• Fetching multiple rows from a database and sending them as one payload
• Building a list of products from separate steps into one order
• Combining multiple API responses for a single summary email
• Creating a consolidated data structure for another service

Any time you need a single, combined array at the end of several operations, the Array Aggregator is usually the right choice.

Key Concepts Behind the Make.com Array Aggregator

To configure the Array Aggregator module properly, you need to understand three core ideas in make.com scenarios:

Bundles and arrays in make.com

A bundle is one set of data that passes through a module: for example, one row, one task, or one record. The Array Aggregator collects many of these bundles and produces a single array, where each element corresponds to a bundle.

Cycles and aggregation in make.com

Aggregation happens at the end of a cycle. A cycle is the group of bundles processed as part of one main trigger execution. The Array Aggregator waits until all relevant bundles in a cycle have arrived, then outputs one aggregated array for that cycle.

Fields and mapping behavior

Inside the Array Aggregator configuration, you decide which fields from each bundle should go into the resulting array. You can:

• Map fields directly from incoming bundles
• Apply functions to transform values
• Create new fields that combine existing values

This mapped structure is applied to every bundle, producing a uniform array of objects as output.

Step-by-Step: Configuring the Make.com Array Aggregator

The example below follows the structure outlined in the official how-to for the Array Aggregator module on make.com. The goal is to turn several incoming bundles into one list of neatly formatted records.

1. Add the Array Aggregator module in make.com

1. Open your scenario in the make.com editor.
2. Click the plus icon where you want to aggregate data.
3. Search for Array Aggregator and add the module.
4. Connect it after the modules that produce multiple bundles.

The Array Aggregator should sit at the point where all relevant bundles have already been generated by previous modules.

2. Choose what to aggregate

In the module configuration, choose the Source module (the one that outputs the bundles you want to collect). The Array Aggregator will then take each bundle from that source module and treat it as an item to be included in the final array.

Depending on the scenario, you may also need to select:

• Target structure or Mode (depending on the module version and connectors)
• Whether to use All bundles from the source or a filtered subset based on preceding modules

3. Define the aggregated data structure

Next, configure which fields will appear in the resulting array. For each field you plan to include:

1. Create or select a field in the Array Aggregator mapping panel.
2. Map a value from the source module bundle, such as an ID, name, date, or amount.
3. Optionally apply text or numeric functions to reformat values.

This structure is then duplicated for each bundle collected by the Array Aggregator in make.com, creating a unified array of objects.

4. Group data correctly in make.com

In many scenarios, you must group bundles by some key (for example, an order ID) so that one aggregated array is created per group instead of one big array for everything.

To group bundles:

• Use the Group by settings if available in your module version, or
• Arrange your scenario so that each cycle processes only one logical group (e.g., one customer or one order).

This ensures that the Array Aggregator builds a separate array for each logical set of data in make.com.

5. Use the aggregated array in the next module

Once configured, the Array Aggregator outputs a single bundle that contains an array of items. In downstream modules, you can:

• Map the entire array as a field in an API request
• Iterate over the array using an Iterator module
• Send a single message, invoice, or record containing all aggregated items

This is especially useful when another service expects a list or collection formatted as an array.

Practical Example with the Make.com Array Aggregator

The official tutorial shows a scenario where multiple records are processed and then turned into one list using the Array Aggregator in make.com. The pattern can be summarized as:

1. A trigger retrieves or receives multiple items.
2. One or more modules enrich or transform those items.
3. The Array Aggregator collects the resulting bundles.
4. A final module sends or stores the aggregated array.

By following this pattern, you can replicate the same approach for invoices, task summaries, contact lists, or any other grouped dataset.

You can review the step-by-step screenshots and specific configuration examples in the original how-to guide on the make.com website here: Array Aggregator – How to use this tool effectively in a scenario.

Best Practices for Using the Make.com Array Aggregator

• Keep structures simple: Define only the fields you really need in the resulting array.
• Test with a few records first: Run the scenario with a small data set to validate the aggregated output.
• Use clear field names: Name fields in a way that makes sense to anyone reading the scenario later.
• Document your logic: Add notes in the scenario to explain why you are aggregating and how the grouped data is used.
• Validate downstream requirements: Ensure the service receiving the array expects the exact structure you created in make.com.

Next Steps: Scaling Your Make.com Scenarios

Once you are comfortable with the Array Aggregator, you can combine it with routers, iterators, and filters in make.com to build far more advanced workflows. Aggregation is the foundation for many complex automations, such as batch invoicing, scheduled digests, and multi-item API operations.

If you need professional help planning, optimizing, or documenting complex automations, you can find consulting and training resources at Consultevo, a site focused on workflow and automation excellence.

By mastering the Array Aggregator, you unlock one of the most flexible data‑handling features available in make.com, enabling cleaner, more efficient scenarios and more powerful integrations.

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