Make.com Iterator and Aggregator: Process Arrays and Collections

Contains affiliate links. Disclosure.

When you pull data from an API in Make.com, you usually get an array — a list of 50 products, 200 contacts, or 100 scraped web pages. The scenario receives that list as one bundle, and most modules can only handle one item at a time.

The Iterator splits that one bundle into N individual bundles. The Aggregator collects them back into one. Master these two modules and you can process any collection in Make.com — loop through rows, transform each item, and ship the results wherever you need.

Why Arrays Break Naive Make Scenarios

Make.com processes data as bundles. A bundle is a single unit of data flowing through a scenario. When a Google Sheets "Search Rows" module finds 80 rows, it outputs 80 bundles — and every downstream module runs once per bundle automatically.

But when an HTTP module returns a JSON response like this:

{
  "products": [
    { "id": 1, "name": "Widget A", "price": 9.99 },
    { "id": 2, "name": "Widget B", "price": 14.99 }
  ]
}

That entire response is one bundle. The products field is just a property inside it — an array nested inside a single bundle. Connecting a "Create Google Sheets Row" module downstream will try to write the entire array into one cell. That is not what you want.

This is exactly where the Iterator solves the problem.

What Is an Iterator in Make.com?

An Iterator is a built-in Make.com module (found under Tools) that takes an array and outputs each element as a separate bundle. If you feed it an array of 100 items, it outputs 100 sequential bundles — one per execution cycle.

Every bundle coming out of the Iterator carries:

• The item data (the individual array element)
• A bundle number (1, 2, 3 ... N) so you know where in the sequence you are
• A bundle position flag (is this the first bundle? the last?)

Think of the Iterator as a for loop in code: it walks through every element and hands it to the next module in your scenario.

Configuring the Iterator Module

1. Add a module → search "Iterator" under Tools.
2. In the Array field, map the array you want to loop through. In the example above, you would map {{1.products}} (referencing the array from the HTTP module at step 1).
3. That's it. The Iterator has no other required configuration.

Every module you place after the Iterator now receives one product at a time. You can filter, transform, enrich, or store each item independently before they're collected.

Understanding Bundle Numbering

Make processes bundles sequentially by default. When the Iterator emits 100 bundles, your downstream modules run 100 times — once per bundle, in order.

The Iterator exposes bundle position metadata you can use in downstream modules:

• Bundle order: the current index in the sequence (1, 2, 3 ... N). Use this to add a row number to each output or skip certain positions with a Filter.
• First/last bundle flags: Make marks the first and last bundle in a series. This lets you trigger a follow-up action only when all items have been processed, or apply different logic to the first item (e.g., writing a header row).

The exact field names in the Make.com formula editor are visible when you click into a field downstream of the Iterator — look for the Iterator module's output mappings under "Bundle order information".

The Four Aggregator Types

After the Iterator processes each bundle, you often need to reassemble them — send all results in one email, write them to a spreadsheet in bulk, or pass the transformed collection to another system. That is what Aggregators do.

An Aggregator is the inverse of an Iterator: it waits for all bundles to pass through, then emits a single output bundle.

All aggregators share one critical configuration field: "Source Module" — you must point this at the Iterator (or trigger module) that produced the bundles, so Make knows how many items to wait for before emitting.

1. Array Aggregator

The most versatile aggregator. Collects each bundle into an array and outputs a single bundle containing that array.

Use when: You want to pass the transformed items to another module as a list — send to an API endpoint, write to a database, or feed into another Iterator.

Configuration:

• Source Module: select your Iterator
• Aggregated fields: map the fields from each item you want to include in the output array

Example output:

[
  { "id": 1, "name": "Widget A", "discounted_price": 8.49 },
  { "id": 2, "name": "Widget B", "discounted_price": 12.74 }
]

2. Text Aggregator

Joins all bundles into a single text string with a separator.

Use when: Building a summary report, formatting an email body with a list of items, or creating a CSV row by row.

Configuration:

• Source Module: your Iterator
• Row separator: newline (\n), comma, pipe, or any custom character
• Text: the template to render for each bundle (e.g., {{item.name}}: ${{item.price}})

Example output (with newline separator):

Widget A: $9.99
Widget B: $14.99
Widget C: $24.99

3. Numeric Aggregator

Applies a math function across a numeric field in all bundles.

Supported functions: Sum, Count, Average, Max, Min.

Use when: Summing an order total, counting how many items passed a filter, or finding the highest-priced product in a list.

Configuration:

• Function: choose Sum, Count, etc.
• Value: map the numeric field from each bundle (e.g., {{item.price}})

4. Table Aggregator

Creates a CSV-formatted table from all bundles. Each bundle becomes a row; each mapped field becomes a column.

Use when: Generating a downloadable CSV report, pasting structured data into Google Sheets via a single "Append Row" call, or building an email attachment.

Configuration:

• Source Module: your Iterator
• Columns: define column names and map the corresponding fields

End-to-End Example: Process 100 Scraped Items into a Report

Here is a complete real-world scenario: you scrape 100 product listings from an e-commerce site using Apify and want to apply a 15% discount to each price, then produce a consolidated Google Sheet.

Scenario flow:

1. Apify → Run Actor (scrape 100 product listings)
2. HTTP → Get Dataset Items  (returns one bundle: array of 100 products)
3. Iterator             (splits array into 100 bundles)
4. Tools → Set Variable    (calculate discounted_price = price * 0.85)
5. Array Aggregator        (reassembles 100 discounted products into one array)
6. Google Sheets → Add Rows (writes all 100 rows in one call)

Step-by-step configuration

Module 1 — Apify Run Actor: Configure your Apify Actor (e.g., a product scraper). Set the webhook to wait for the run to complete and return the dataset URL. Connect Make.com to Apify via the official Apify module or an HTTP module.

Module 2 — HTTP Get: Call Apify's dataset API endpoint to retrieve the results array. Output is one bundle: {{body.items}} contains the array.

Module 3 — Iterator: Set Array to {{2.body.items}}. Now each product flows as an individual bundle.

Module 4 — Tools Set Variable: Add a variable discounted_price = {{3.price * 0.85}}. This runs once per product.

Module 5 — Array Aggregator: Set Source Module to the Iterator (module 3). Map id, name, price, and discounted_price as aggregated fields.

Module 6 — Google Sheets Add Rows: Map the aggregated array. Google Sheets will write all 100 rows in one operation rather than 100 separate API calls — dramatically reducing your Make.com operation count and scenario run time.

Batch Processing Patterns

Pattern 1: Filter inside the loop

Place a Filter module between the Iterator and Aggregator to process only items matching specific criteria. Items that don't match the filter are simply dropped — the Aggregator collects only the passing items.

Iterator → Filter (price > 10) → Array Aggregator

The Aggregator's Source Module should still point to the Iterator, not the Filter. Make handles the missing bundles automatically.

Pattern 2: Nested loops

You can Iterator → process → Array Aggregator, then immediately Iterator the resulting array again for a second pass. Use this when each item contains a sub-array you also need to loop through.

Iterator (orders) → Iterator (line items per order) → Text Aggregator (line summary) → Array Aggregator (all orders)

Pattern 3: Error handling per item

Wrap the processing modules between the Iterator and Aggregator in a Break error handler. If one item fails (e.g., an API rate limit on item 47), Make logs the error for that bundle, continues with the remaining 99, and the Aggregator still collects all successful results. Set the scenario to "Resume" on the break to continue automatically.

Pattern 4: Paginated API responses

If your API returns results across multiple pages (e.g., pages 1–10, each with 20 items), use the Repeater module to fetch each page, then pipe results through an Array Aggregator to combine pages, and then an Iterator to split the merged collection for per-item processing.

Common Mistakes to Avoid

Mistake 1 — Wrong Source Module on the Aggregator
The Aggregator needs to know where its bundles start. Pointing it at the wrong module causes it to aggregate incomplete sets. Always set the Source Module to the same Iterator that started the loop.

Mistake 2 — Routing modules after a Filter instead of before
If you add modules downstream of a Filter but before the Aggregator, they only run on items that passed the filter. Place any unconditional transformations before the Filter.

Mistake 3 — Processing each item individually when bulk API calls are cheaper
If your destination API supports batch inserts (Google Sheets Append Rows, Airtable bulk create, etc.), collect with an Array Aggregator first, then send in one call. Making 100 separate API calls burns 100 operations and hits rate limits.

Mistake 4 — Forgetting the Iterator produces sequential bundles
The Iterator processes bundles one by one. If you need parallel execution across items, Make does not natively support parallel bundle processing — everything is sequential within a scenario run.

Iterator vs. Aggregator Quick Reference

Need	Module
Loop through each item in an array	Iterator
Collect results back into an array	Array Aggregator
Join results into a text string	Text Aggregator
Sum / average a numeric field	Numeric Aggregator
Build a CSV table from items	Table Aggregator
Process only matching items	Filter (between Iterator and Aggregator)

Getting Started with Make.com

Iterator and aggregator workflows are available on all Make.com plans, including the free tier (1,000 operations/month). If you are building data pipelines that process large collections regularly, the Make.com Core plan starts at $9/month for 10,000 operations.

Pricing verified June 2026. Plans change frequently — check the vendor’s official pricing page for current rates.

You can create a free Make.com account and try these patterns immediately using the template library — several pre-built scenarios demonstrate Iterator + Aggregator patterns.

For web scraping pipelines that feed Make.com, Apify is the recommended source: it handles JavaScript-heavy sites, proxy rotation, and returns clean JSON arrays ready for your Iterator. The Apify + Make.com integration guide walks through the full connection.

---

FAQ

Frequently Asked Questions

Use the Iterator module under Tools. Map the array you want to loop through into its Array field. Every module placed after the Iterator will run once per item in the array. When you're done processing, use an Aggregator module to collect the results back into a single bundle.

The Iterator is a Tools module that takes an array (a list of items inside a single bundle) and outputs each element as a separate bundle. If you have an array of 50 items, the Iterator produces 50 individual bundles that flow through your scenario sequentially.

The Iterator splits an existing array into individual bundles. The Repeater generates a fixed number of bundles from scratch — you specify how many times it should repeat (e.g., to paginate through API pages). Use Iterator when you already have an array to loop through; use Repeater when you need to run a module N times independently.

The Source Module tells the Aggregator where the bundles it should collect start from. Set it to the Iterator (or other module) that produced the bundles. Without the correct Source Module, Make doesn't know how many bundles to wait for before emitting the aggregated result.

Add an Array Aggregator module after your processing modules. Set its Source Module to your Iterator, then map the fields from each bundle you want to include. The Array Aggregator waits for all bundles to pass through, then emits one bundle containing the assembled array.

Yes. Place a Filter module after the Iterator and before the Aggregator. Items that don't pass the filter are dropped; the Aggregator collects only the bundles that made it through. The Source Module on the Aggregator should still point to the Iterator, not the Filter.

Each module execution counts as one operation. If you iterate over 100 items and have 3 modules between the Iterator and Aggregator, that scenario run uses 100 × 3 = 300 operations for the loop body, plus one operation each for the Iterator and Aggregator themselves. Minimizing the number of modules inside the loop keeps your operation count low.