Make.com Data Aggregation

What Aggregation Is

In Make.com, data flows through scenarios as "bundles." When an Iterator processes an array of 50 items, it outputs 50 bundles — each module after the Iterator runs 50 times.

Aggregation is the reverse: Take many bundles and combine them into one. The Array Aggregator collects all bundles into a single array. The Text Aggregator concatenates text from all bundles. The Numeric Aggregator calculates sum, average, min, or max across all bundles.

This is the foundation of:

• Building email digests (50 individual alerts → one summary email)
• Generating reports (50 individual metrics → one report document)
• Creating batch API calls (50 individual records → one array sent to an API)
• Computing statistics (50 order amounts → total, average, highest value)

The Array Aggregator

The Array Aggregator collects bundles into a single array. Each bundle's data becomes an element in the output array.

Setup: Place an Array Aggregator after the modules you want to aggregate. In the "Source Module" field, select the Iterator (or triggering module) that started the series of bundles. In the "Map" field, configure what data to include from each bundle.

Output: A single bundle containing an array field with all collected data.

Use case: Collect all enriched leads then send one batch to a CRM

1. Airtable: Fetch all leads to process
2. Iterator: Process each lead
3. Apollo HTTP: Enrich each lead
4. Array Aggregator: Collect all enriched leads
5. HubSpot Bulk Create: Send the entire array at once (if the API supports batch operations)

One API call to create all contacts rather than one API call per contact.

The Text Aggregator

The Text Aggregator concatenates text from multiple bundles into a single text block, with a configurable separator.

Setup: Configure the "text" field (the content from each bundle) and "row separator" (what goes between each item — newline, comma, pipe, etc.)

Use case: Build a digest email from individual records

1. Airtable: Fetch today's pending tasks
2. Iterator: Process each task
3. Text Aggregator: Row separator = "\n", Text = "• {{1.taskName}} — due {{1.dueDate}} (assigned to {{1.assignee}})"
4. Output: A single text block listing all tasks as bullet points
5. Gmail Send: Insert the aggregated text into the email body

Use case: Build a structured report

1. HTTP Request: Fetch multiple metrics (multiple modules, multiple bundles)
2. Text Aggregator: Build a formatted text report
3. Claude HTTP: "Polish and summarise this data into a professional executive brief"
4. Email or Slack: Send the polished report

The Numeric Aggregator

Calculates sum, average, count, max, or min across all bundles.

Use case: Weekly revenue calculation

1. Stripe: Fetch all successful payments this week
2. Iterator: Process each payment
3. Numeric Aggregator (Sum): Sum all payment amounts
4. Numeric Aggregator (Count): Count all payments
5. Calculated: Average order value (Sum / Count — via simple math in a field)
6. Slack: "This week: [count] orders, [total] revenue, [avg] average order value"

Combining Aggregators

For complex summaries, chain multiple aggregators:

1. Iterator over categories: For each product category
2. Numeric Aggregator: Total revenue for that category
3. Array Aggregator (outer): Collect all categories with their totals
4. Claude HTTP: "Analyse this category performance data and highlight the top performer, the biggest concern, and one actionable recommendation"
5. Email: Send the report

Aggregator Best Practices

Always match the Source Module: The Source Module in the aggregator must be the exact module that started the bundle iteration (the Iterator or trigger). Selecting the wrong source module causes the aggregator to collect bundles from the wrong scope.

Use Text Aggregator for readable output: If the aggregated data needs to be human-readable (in an email, a Slack message), use Text Aggregator to format it as you go. Post-processing raw arrays is harder.

Aggregator is a "synchronisation point": After an aggregator, the scenario has one bundle again. Subsequent modules run once with the aggregated data. Use this to move from parallel processing back to a single sequential flow.

Large aggregations are slow: If you're aggregating 10,000 bundles, the scenario will run for a long time. For very large data sets, consider whether Make.com is the right tool or whether a database query would be faster.

Recommended Tools

• Make.com — Aggregator modules built in
• Airtable — Data source for aggregation scenarios
• Claude API — Analysing aggregated data and generating summaries
• Slack — Receiving aggregated report notifications
• Gmail — Sending aggregated report emails

“Aggregation unlocks Make.com's reporting and batch processing capability. Master the Text and Array Aggregator and you can build any kind of automated report or summary.”