How to Use the Aggregator in Make.com

The Aggregator in make.com is a powerful tool that lets you collect multiple items into a single bundle so your scenarios can process data in flexible batches. This how-to guide walks you through what the Aggregator does, how it behaves during scenario execution, and how to configure it for reliable automations.

What the Make.com Aggregator Does

The Aggregator module in make.com takes multiple incoming bundles and joins them into one output bundle that contains an array of items. This is especially useful when you need to:

Wait for several records before sending a single email or report.
Group data into fixed-size batches.
Collect items over a period of time and process them together.
Simplify complex mapping when multiple similar items must be handled at once.

Instead of processing each incoming bundle individually, the Aggregator combines them and then passes the grouped result to the next module.

Key Concepts of the Aggregator in Make.com

Before you configure an Aggregator in make.com, it is important to understand a few core concepts:

Bundle: A data package that moves through your scenario. Each bundle represents one set of data items (for example, one row, one order, or one webhook event).
Array: A list of items stored inside a single output bundle from the Aggregator.
Aggregation cycle: The period during which the Aggregator collects incoming bundles before it sends them onward.
Termination condition: The rule that decides when the Aggregator stops collecting and outputs the grouped data.

With these concepts, you can design consistent data flows and avoid unexpected behavior when working with the Aggregator in your make.com scenarios.

How the Make.com Aggregator Works During Execution

When a scenario runs, the Aggregator in make.com behaves in a predictable sequence:

Start of aggregation: As soon as the Aggregator receives the first incoming bundle in a run, it begins an aggregation cycle.
Collection of bundles: Additional bundles coming from previous modules are stored in memory as part of the current aggregation.
Evaluation of termination conditions: After each new bundle is received, the Aggregator checks whether a termination rule is met (for example, maximum number of bundles or end of scenario execution).
Output of aggregated bundle: When a condition is satisfied, the Aggregator sends a single bundle that contains all collected items as an array.
Start of a new cycle (if needed): If more bundles are available and conditions allow, a new aggregation cycle starts immediately.

Understanding this execution flow helps you design scenarios where the Aggregator in make.com sends data exactly when expected.

Setting Up the Aggregator in Make.com

Follow these steps to add and configure the Aggregator in a make.com scenario:

1. Insert the Aggregator into a Make.com Scenario

Open your scenario in the make.com editor.
Identify the module after which you want to group incoming bundles (for example, a search module or a webhook).
Click the plus icon and add the Array aggregator or a specific Aggregator module available in the service you use.
Place it between the data source and the module that should receive grouped data.

Once inserted, the Aggregator will start collecting bundles from the preceding module when the scenario runs.

2. Choose What the Make.com Aggregator Will Aggregate

In the Aggregator settings of make.com, define the structure of the items it will create:

Open the Aggregator module configuration window.
In the Source module or similar field, select the module from which bundles are being collected.
Map the data fields you want to store inside each aggregated item (for example, ID, name, email, price).
Decide whether you want to keep all fields from the original bundles or only a subset.

The result is an array of items where each element corresponds to one original bundle processed earlier in your make.com scenario.

3. Configure Termination Conditions in Make.com

The heart of any Aggregator in make.com is its termination rule. Common configuration options include:

Maximum number of bundles: Aggregation ends when the defined number of items is collected.
Time-based termination: Aggregation ends after a specified interval of scenario execution or scheduling cycle.
End of scenario data: Aggregation ends automatically when no more incoming bundles are available.

To configure these options:

Locate the Aggregation settings or Stop collecting section.
Set the limit for Max number of results, if available.
Optionally combine conditions, such as a maximum number of bundles or the natural end of the input stream.

Carefully selected termination rules ensure that the Aggregator in make.com returns predictable batch sizes and prevents unbounded memory usage.

Mapping Aggregated Data to the Next Make.com Module

After aggregation, the output of the module in make.com contains an array field that holds all collected items. To use this array effectively:

Open the next module in your scenario.
In the mapping panel, find the array output from the Aggregator.
Map the entire array if the target module supports lists (for example, sending a batch of records).
Alternatively, use an iteration module (such as an Iterator) after the Aggregator to process each item in the array individually.

This mapping approach allows you to either process all bundled items together or fan them out again later in the same make.com workflow.

Typical Use Cases for the Aggregator in Make.com

The Aggregator supports many different automation patterns in make.com. Common use cases include:

Daily or hourly summary emails: Aggregate all new records during one run and send them as a single digest email.
Batch API updates: Collect several items and call an external API that accepts a list of records at once.
Reporting and analytics: Group data from multiple sources, then send a combined dataset to a spreadsheet or database.
Optimizing API quotas: Reduce the number of external calls by grouping multiple operations into one request.

By designing scenarios around these patterns, you make your make.com automations more efficient and easier to maintain.

Best Practices for Using the Make.com Aggregator

To keep your Aggregator setups in make.com reliable and predictable, follow these best practices:

Define clear limits: Always set reasonable maximum counts or time windows for aggregation.
Monitor scenario performance: Large arrays can increase processing time and memory use; adjust limits when necessary.
Validate data structure: Use consistent mapping so every aggregated item has the same fields.
Handle empty aggregations: Plan how downstream modules should behave if no data is collected in a cycle.
Test with sample runs: Run your scenario manually and inspect the Aggregator output bundle to confirm it matches your expectations.

Further Learning on Make.com Aggregators

To dive deeper into the Aggregator behavior in make.com, including advanced settings and visual examples, review the official documentation at the Aggregator help page. It explains detailed scenarios, screenshots, and additional configuration notes.

If you need expert help designing complex automations or optimizing Aggregator usage in make.com, you can also consult automation specialists at Consultevo for implementation guidance and scenario reviews.

With a clear understanding of how the Aggregator works and careful configuration inside make.com, you can efficiently group, process, and route data across all your workflows.

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

Aggregator guide for Make.com