Make Iterators and Aggregators Explained: Arrays and Bundles

A practical field guide from Automation Ace.

The short answer

In Make, data moves between modules as bundles, and each later module runs once per bundle. An array is a list inside a single bundle, such as the line items on one order. An iterator splits an array into separate bundles so later modules can handle each item. An aggregator does the reverse: it collects bundles back into one, such as a single list, text block, table, or file. Choose the aggregator's source module carefully, and use array functions when you only need to reshape a list.

Bundles: how data moves in Make

Every module outputs zero, one, or many bundles. A webhook usually outputs one bundle per request. A search module can output many bundles, one per record found. Each module after it then runs once for each bundle, which is why a search that returns 50 records makes the next module run 50 times.

This is different from Zapier, where each run normally handles one trigger item. See Zapier vs Make vs n8n.

Arrays: lists inside one bundle

An array is a list of items inside a single bundle, such as the line items in an order, the attendees of a meeting, or the files on a form. Make shows arrays with square brackets in the mapping panel. You can map the whole array, a specific item such as the first one, or use functions to reshape it without looping. See the Make functions cheat sheet.

Iterators: one bundle per item

Use an iterator when each item needs its own action, such as creating one invoice line per order item or sending one message per attendee. Map the iterator to the array, and every module after it runs once per item.

• Map the array itself, not a single item or a joined text version of it.
• Many app modules return arrays that need an iterator before you can act on each item.
• Every module after the iterator runs once per item, so a 100-item array multiplies usage by 100.

Aggregators: back to one bundle

Every aggregator has a source module: the module whose bundles it collects, usually the iterator or search. Setting it wrong is the most common reason an aggregator returns only one item. See why an aggregator collects only one item.

When to skip the loop and use functions

If you only need to reshape a list, functions are usually cheaper and simpler than an iterator plus an aggregator:

• map(array; key) pulls one field out of every item.
• join(array; ", ") turns a list into text.
• length(array) counts items, and first() or last() picks one.
• sum(map(items; price)) totals a field without a numeric aggregator.

Use an iterator only when each item needs its own module action.

Common mistakes

• Wrong source module: the aggregator collects the wrong bundles.
• Mapping a single item to the iterator: it outputs one bundle instead of many.
• Filters between iterator and aggregator: they can drop items you expected to see.
• Mismatched lists: pairing separate arrays by position breaks when one is longer. See why line items don't map correctly.
• Large arrays: looping over thousands of items in one run is slow and costly. See processing large lists in Make.

Example: order line items to an invoice

A webhook receives an order with five line items. An iterator splits them into five bundles, a module looks up each product's accounting code, and an Array aggregator with the iterator as its source module combines them back into one array. A single HTTP module then creates the invoice with all five lines. Using one invoice call instead of five also keeps usage and API calls down. For the Zapier version of this pattern, see looping and aggregating line items in Zapier.

Frequently asked questions

What is a bundle in Make?

A bundle is one package of data passed from a module to the next. Each later module runs once per bundle, so a module that outputs ten bundles makes the next module run ten times.

What is the difference between an iterator and an aggregator?

An iterator splits an array into separate bundles so each item can be handled on its own. An aggregator collects bundles back into one, such as an array, text block, sum, or table.

Why does my aggregator only return one item?

Usually its source module is set to a module that outputs a single bundle, or the iterator is mapped to one value instead of the array. Set the source module to the iterator and map the array itself.

Do iterators increase Make usage?

Yes. Every module after an iterator runs once per item, and each run counts toward your plan. Use functions such as map, join, and sum when you only need to reshape a list.