How to Combine Multiple Bundles Into One Input in Make.com
Struggling with variable-length data in your Make.com automations? When processing multi-item orders, trip itineraries, or other scenarios where users can submit an unpredictable number of items, you need bundle aggregation. This technique lets you combine all those separate data bundles into one clean input for downstream modules.
The Bundle Aggregation Problem
When building complex automations in Make.com, you'll eventually hit a wall: how to handle variable-length data where the number of items isn't known in advance. Traditional automation approaches break down when users can submit an unpredictable number of related items - whether it's multi-leg trips, survey responses, or product orders with variable options.
The breakthrough comes when you realize Make.com processes these as separate "bundles" - individual packets of data that normally get processed one at a time. Bundle aggregation lets you combine them back into a single, structured collection that downstream modules can process efficiently.
Key insight: The Array Aggregator module isn't just for combining arrays - it's your secret weapon for transforming multiple bundles into one coherent data structure that AI modules, databases, and other tools can consume.
Real-World Use Case: Multi-Country Trips
Consider the travel booking automation shown in the video (at 0:45). Users can submit trips with any number of countries and legs - from simple weekend getaways to complex multi-month itineraries. Each leg becomes its own bundle with destination details, dates, and other metadata.
Without bundle aggregation, you'd need to create separate automation paths for each possible number of trip legs - an impossible task. The solution? Process each leg through an Iterator, then aggregate all the trip data into one collection using the Array Aggregator. This creates a flexible system that adapts to any itinerary length.
Practical benefit: This same pattern works for any variable-length data - product orders with multiple items, survey responses with conditional questions, or event registrations with guest lists of any size.
Iterator Module Setup
The first critical component is the Iterator module (shown at 2:10 in the video). This breaks down your incoming bundles so you can process each one individually. In our trip example, we configure the Iterator to process the "trip data" array from our webhook.
Configuration is straightforward:
- Connect the Iterator to your data source module (webhook, API call, etc.)
- Select the array field containing your bundles (e.g., "trip_data")
- Set up any filters or transformations needed for individual bundles
The Iterator outputs each bundle one at a time, letting you process them sequentially before aggregation. At 2:35 in the video, you can see how each trip leg becomes its own processed bundle ready for consolidation.
Array Aggregator Configuration
The Array Aggregator (shown at 3:15) is where the magic happens. Placed immediately after your Iterator, it collects all processed bundles and combines them into a single output array.
To configure it properly:
- Set the source module to your Iterator
- Select which fields to include from each bundle (e.g., country, dates, budget)
- Choose whether to maintain original order or sort the aggregated data
At 3:45 in the video, you can see the Aggregator's output - a clean array containing all trip legs in one structured collection. This becomes your single input for downstream modules like ChatGPT, databases, or notification systems.
Pro tip: Use the Aggregator's field selection to filter out unnecessary data - only include what your downstream modules actually need to process.
Passing Aggregated Data to AI Modules
One of the most powerful applications is feeding aggregated data to AI modules like ChatGPT (shown at 4:20). Instead of sending multiple API calls for each bundle, you send one clean, structured input containing all relevant information.
In our trip example (4:35), we:
- Pass the aggregated trip data array to ChatGPT
- Provide clear instructions for processing the complete itinerary
- Receive a consolidated output (like a country list for email personalization)
This pattern works for any AI processing task where context from all bundles matters - summarizing multiple support tickets, analyzing survey trends across responses, or generating recommendations from order histories.
Performance Considerations
While bundle aggregation is powerful, it's important to understand its impact on your automation's performance. Each bundle adds one iteration cycle, so extremely large datasets (100+ bundles) may need optimization.
Best practices include:
- Filter data early - remove unneeded fields before aggregation
- Set reasonable limits on bundle quantities where appropriate
- Consider parallel processing for very large datasets
- Monitor execution times as your automation scales
The video's trip example (at 5:10) shows how Make.com's new "run with existing data" feature helps testing without recreating complex submissions each time.
Alternative Approaches
While the Iterator + Aggregator combo is the most straightforward method, other techniques exist for specific scenarios:
- Webhook Collections: Some apps provide all data in one webhook collection
- Database Modules: Writing bundles to a database table then reading them back as one set
- Custom Scripts: Using JavaScript or Python to transform bundle data
However, for most Make.com users, the native Iterator and Array Aggregator provide the best balance of simplicity and flexibility, especially when combined with AI modules for processing the aggregated data.
Watch the Full Tutorial
See bundle aggregation in action with this complete Make.com walkthrough. The video demonstrates each step from initial webhook setup through final ChatGPT integration, including key configuration details you'll need for your own implementations.
Key Takeaways
Bundle aggregation solves one of the most common challenges in complex Make.com automations - handling variable-length data where the number of items isn't known in advance. By combining an Iterator with an Array Aggregator, you create flexible workflows that adapt to any input size while providing clean, consolidated outputs for downstream processing.
In summary: Use the Iterator to process each bundle individually, then the Array Aggregator to combine them into one structured collection. This pattern works for trip itineraries, multi-item orders, survey responses, and any scenario where users can submit an unpredictable number of related items.
Frequently Asked Questions
Common questions about bundle aggregation in Make.com
Bundle aggregation is the process of combining multiple data bundles from a single operation into one consolidated collection. This is essential when you need to pass variable-length data sets (like trip legs to multiple countries) to downstream modules that expect a single input.
In technical terms, Make.com processes each item in an array as a separate bundle. The aggregator reassembles these individual bundles back into a structured array that other modules can process as a whole.
- Transforms multiple bundles into one coherent data structure
- Essential for handling variable-length data sets
- Uses Make.com's Iterator and Array Aggregator modules
You need bundle aggregation when processing variable-length data where the number of items isn't known in advance. This occurs whenever users can submit an unpredictable number of related items that your automation needs to process together.
Common scenarios include processing multi-leg trips (as shown in the video), orders with variable product options, survey responses with conditional questions, or event registrations with guest lists of any size.
- Multi-item orders with variable product options
- Travel itineraries with any number of destinations
- Survey responses with conditional question paths
You need two key modules: an Iterator to process each bundle individually, followed by an Array Aggregator to combine them. The Iterator breaks down each bundle while the Aggregator reassembles them into a single collection that downstream modules can process.
The Iterator handles the sequential processing of each bundle, while the Aggregator provides the final consolidated output. This combination gives you both individual bundle processing and unified output capabilities.
- Iterator module for processing individual bundles
- Array Aggregator module for combining bundles
- Optional filter modules between them for data transformation
Yes, the Array Aggregator lets you select exactly which fields to include in the final output. You can choose to aggregate all data or only specific fields from each bundle, giving you precise control over what gets passed to downstream modules.
This selective aggregation is particularly useful when different downstream modules need different subsets of your data. You can create multiple aggregation paths from the same source bundles if needed.
- Select specific fields to include in aggregation
- Exclude sensitive or unnecessary data
- Create multiple aggregation paths from same source
AI modules typically need consolidated inputs to provide meaningful outputs. By aggregating bundles first, you can feed all relevant data in one structured format to your AI module. For example, combining all trip legs into one collection lets ChatGPT analyze the complete itinerary rather than processing each leg separately.
This approach is shown in the video at 4:20, where aggregated trip data is passed to ChatGPT to generate a consolidated list of visited countries. The AI can understand relationships across all bundles when they're presented together.
- Provides complete context to AI for better outputs
- Reduces API calls by sending one consolidated input
- Enables cross-bundle analysis by the AI
The performance impact is minimal for most use cases. Make.com processes bundles sequentially in the Iterator, and the Aggregator simply reorganizes the data. The main consideration is operation count - each bundle adds one iteration cycle, but the actual aggregation step is very efficient.
For very large datasets (100+ bundles), you might want to implement parallel processing or batch aggregation to optimize performance. The video example handles 5 trip legs with no noticeable performance impact.
- Minimal processing overhead for aggregation
- Each bundle adds one iteration cycle
- Consider parallel processing for 100+ bundles
While this technique works best with bundles from a single operation, you can aggregate from multiple sources by first mapping them to a common structure. However, this requires careful data mapping to ensure all bundles contain compatible fields before aggregation.
The challenge comes in maintaining consistent data structures across different sources. You'll typically need transformation modules between each source and the aggregator to ensure field compatibility.
- Possible with additional data mapping
- Requires consistent field structures
- Adds complexity to the automation
GrowwStacks specializes in building complex Make.com automations that handle variable data sets. Our team can design and implement bundle aggregation workflows tailored to your specific use case, whether you're processing multi-item orders, complex itineraries, or other variable-length data.
We offer free consultations to discuss your automation needs and how bundle aggregation can solve your specific challenges. Our experts will analyze your workflow, recommend the optimal implementation, and build a solution that scales with your business.
- Custom bundle aggregation workflows for your data
- Integration with your existing systems and processes
- Free 30-minute consultation to discuss your needs
Ready to Implement Bundle Aggregation in Your Make.com Automations?
Manual processing of variable-length data wastes time and creates fragile automations. Let GrowwStacks build you a robust bundle aggregation solution that handles any input size automatically.