Make.com Iterator and Aggregator Patterns How to Process Arrays Without Frustration

You run your scenario. You have an array of ten items. The Aggregator returns a result — but it only processed the first one. The rest simply disappeared.

This is one of the most common issues Make.com users run into. There’s nothing mysterious about it, but finding the right solution without prior experience can take hours. Iterator and Aggregator in Make work as a pair — build them wrong and data just falls through.

What Make.com Iterator and Aggregator Do and Why You Need Both

Iterator takes an array and splits it into individual items — processing each one separately. Aggregator collects those items back together into an array, string, or table.

Without an Iterator, you’re always working with the whole array at once. That means you can’t apply transformations to individual items, filter a subset, or call an API for each record.

The Iterator + Aggregator combo is Make.com’s equivalent of a forEach or map loop in programming.

14 Patterns Organized Into Groups A, B and C

The Iterator & Aggregator Patterns Toolkit includes 14 ready-to-use patterns. Each solves a specific situation — from basic array iteration to deduplication and data transformation.

Group A — basic iteration and collection

• A1: Iterate array — basic pass through an array, output as a new array
• A2: Iterate with index — adds a sequence number to each item
• A3: Collect results — gathers API call outputs into a single array
• A4: Flatten nested array — collapses a nested array into a single level
• A5: Batch processing — processes an array in batches of N items

Group B — transformation and filtering

• B1: Filter array — returns only items matching a condition
• B2: Map values — remaps keys or values for each item
• B3: Transform and reshape — fully restructures each object
• B4: Conditional transform — different transformation based on a field value

Group C — aggregation and deduplication

• C1: Join to string — combines an array into a text string (with separator)
• C2: Deduplicate array — removes duplicate records by key
• C3: Sum and count — sums values or counts items
• C4: Group by key — splits an array into groups by a field value
• C5: Build lookup table — creates a dictionary for fast lookups

Three Most Popular Patterns With Formula Examples

A1 — Iterate array

The most basic pattern. Iterator splits the array, your modules process each item, and Array Aggregator collects results back.

Output variable: {{item}} holds the current item, {{position}} holds its index.

B3 — Transform and reshape

Need to convert {first_name, last_name, email} objects into {name, contact}? B3 remaps each item using a Set Variable or Tools module.

Key formula for joining a name:

{{item.first_name & " " & item.last_name}}

C2 — Deduplicate array

You have an array with duplicate records. Pattern C2 uses an Array Aggregator with a deduplication key — it removes records with the same value for the chosen field.

Example: deduplicating emails from a form submission array:

{{item.email}}

Set the aggregator key to email and duplicates are gone.

How to Use the Toolkit — Four Steps

1. Download the blueprint from Gumroad after purchase
2. Import it into Make.com using the Import Blueprint button
3. Copy the relevant section (Iterator + modules + Aggregator) into your scenario
4. Remap variables to match your data — all inputs are clearly marked

From import to working scenario typically takes 5–10 minutes. No building from scratch, no searching for the right module combination.

💡 If you need to fetch all data from an API before iterating it, check out Make.com Pagination — How to Fetch All Data From an API. The two approaches complement each other well.

FAQ

Does it work with nested arrays? Yes. Pattern A4 Flatten nested array is designed exactly for this — it collapses a multi-level array into a single flat structure that you then work with normally.

How many operations does iterating consume? Each module inside an iteration costs one operation per pass. Iterating 50 items through 3 modules = 150 operations. The toolkit has no effect on this — credit optimization depends on your scenario design.

Do I need to understand IML formulas? Basic familiarity helps when remapping variables, but it’s not required. Every place that needs adjustment is clearly marked in the blueprint. If you want to go deeper into IML, check out how to work with dates and times in Make.com — the principles of IML formulas are explained there with concrete examples.

The Right Pattern Makes All the Difference

Make.com iterator aggregator patterns are among the most powerful tools in Make.com — and the ones where it’s easiest to get stuck without a solid starting point. Each pattern in this toolkit came from a real project, not from documentation, but from hours of finding what works and what doesn’t.

If you’re working with arrays in Make.com and don’t want to build from scratch, Iterator & Aggregator Patterns Toolkit gives you 14 ready-to-deploy solutions.