Demystifying Make.com's Iterator Module: Effectively Handling Arrays

Introduction

Have you ever spent days wrestling with Make.com's Iterator module, only to have it stubbornly treat your entire array as a single bundle?

I recently faced this exact challenge. After exhausting Make's docs—I gave AI a chance—I pivoted to try multiple Large Language Models (LLMs) like

• Claude.AI,
• Perplexity,
• ChatGPT
  • 01-mini
  • and 01-preview.

It wasn't until I stumbled upon the ChatGPT 01-preview version that I began to understand the nuances of bundles, collections, and arrays in Make.com.

Understanding these concepts and how the "map" option affects data processing in Make.com is crucial. In this tutorial, we'll walk through the steps to correctly handle arrays in the Iterator module, helping you avoid the pitfalls I encountered.

Prerequisites

Before we begin, make sure you have:

• A Make.com account with access to the Iterator module.
• Basic understanding of Make.com's interface and modules.
• Familiarity with arrays and data types.

Steps

1. Understanding the Problem

Initially, I was trying to feed an array like ["Introduction", "Prerequisites", "Steps", "Troubleshooting", "Conclusion"] into the Iterator module. No matter what I did, the module treated the entire array as a single element. This issue persisted even when I tried to map the array from a previous step using the "map" option.

The Importance of Data Types

One key realization was that enclosing items in square brackets [] doesn't necessarily make them an array in Make.com. The platform is sensitive to data types, and an array must be explicitly defined as such. Otherwise, it may be treated as a string, leading to the Iterator module processing it incorrectly.

2. Attempting Solutions with Multiple LLMs

I sought help from various LLMs:

• Claude.AI and Perplexity provided general advice but didn't solve the issue.
• ChatGPT (01-mini) gave me some insights, but it was the ChatGPT 01-preview version that truly clarified the concepts of bundles, collections, and arrays in Make.com.
• These insights inspired me to start simple and verify that I was indeed working with an actual array, rather than assuming so just because of the square brackets.

3. Starting Simple to Verify the Data Type

To ensure that I was working with an actual array, I decided to start from scratch:

Add Items to the Array: Use another "Set Variable" module to add items to the array using the add() function.

{{add(PreviousStep.myArray; "Introduction"; "Prerequisites"; "Steps"; "Troubleshooting"; "Conclusion")}}

Replace PreviousStep with the module number of your initialization step.

Initialize an Empty Array:Use the "Set Variable" module with the value {{emptyarray}}.

{{emptyarray}}

4. Initializing and Populating the Array Step by Step

To ensure that we're working with an actual array, it's important to start simple and verify each step. We'll begin by initializing an empty array and confirming its data type. Then, we'll add elements to it in a separate module. Finally, we'll combine these steps into a single module for efficiency.

Step 1: Initialize an Empty Array

1. Module Name: Set Variable
2. Variable Name: emptyArray

Value:

{{emptyarray}}

This initializes an empty array. When you run this module, the output should display:

[]

This confirms that emptyArray is indeed an array data type.

Step 2: Add Items to the Empty Array

1. Module Name: Set Variable
2. Variable Name: newArray

Value:

{{add(emptyArray; "item1"; "item2")}}

This uses the add() function to append "item1" and "item2" to the emptyArray, resulting in a new array newArray that contains these items.

Verification

Run the scenario up to this point to verify the outputs:

Output of newArray:

["item1", "item2"]

Output of emptyArray:

[]

This step-by-step process confirms that you're working with actual arrays at each stage.

Step 3: Combining Initialization and Population into One Module

To streamline the process, you can combine the initialization and population of the array into a single module.

1. Module Name: Set Variable
2. Variable Name: oneArray
   • Initializes an empty array using emptyarray.
   • Adds "item1" and "item2" to the array using the add() function.

Value:

{{add(emptyarray; "item1"; "item2")}}

This performs both actions:

By combining these steps, you reduce the number of modules and make your scenario more efficient.

5. Configuring the Iterator Module Correctly

When working with the Iterator module, the "map" option plays a crucial role. Here's what I discovered:

• The "Map" Option Only Works with Previous Module Outputs:The "map" option is designed to ingest data from a previous module's output, such as a variable or an array produced earlier in your scenario. If you're executing only the Iterator module for troubleshooting, having "map" turned on can be misleading. The module expects input from an earlier step, and without it, it may not function as intended.
• Understanding Why This Happens:Turning off the "map" option forces the Iterator module to interpret the input as a static array. However, since the input was actually a string formatted to look like an array, the module misinterpreted the data. It split the string at each comma but included the opening [ in the first item and the closing ] in the last item, which indicated that it wasn't processing a true array data type.This behavior helped me realize that my input wasn't being recognized as an array by Make.com. It prompted me to look deeper into how arrays are defined and processed within the platform.
• Key Takeaway:The "map" option should be turned on when you are ingesting data from a previous module's output. If you're entering data directly into the Iterator module for testing or troubleshooting, turning "map" off can help you understand how the module is interpreting your input. However, be aware that this might not accurately reflect how your data will be processed in the full scenario.

Misleading Results During Troubleshooting:While troubleshooting, I noticed that when I turned "map" off and input my sample string (which I thought was an array but wasn't), the output changed in a revealing way.Before (with "map" on):The Iterator treated the entire input as a single string:

["Introduction", "Prerequisites", "Steps", "Troubleshooting", "Conclusion"]

After (with "map" off): The output transformed into an array-like structure:

Array
Item 1: ["Introduction"
Item 2:  "Prerequisites"
Item 3:  "Steps"
Item 4:  "Troubleshooting"
Item 5:  "Conclusion"]

6. Verifying the Output

With the correct configuration and a properly defined array, run the scenario to see the Iterator module processing each item individually. The output should display multiple bundles:

Bundle 1: Introduction
Bundle 2: Prerequisites
Bundle 3: Steps
Bundle 4: Troubleshooting
Bundle 5: Conclusion

7. Analyzing the Output and Code Bundles

It's essential to study both the output and the code behind these bundles. You'll notice that the way data is packaged in the output differs from the underlying code structure. Understanding this helps in troubleshooting and ensures that your data is being processed as intended.

By examining the discrepancies between expected and actual outputs, I gained a better understanding of how Make.com handles data types. The realization that my input wasn't a true array prompted me to adjust my approach, leading to the successful processing of each array element.

Troubleshooting

Common Issues and Solutions

• Entire Array Treated as One Item:Ensure you're passing an actual array data type, not a string that looks like an array. Use functions like emptyarray and add() to define your array explicitly.
• "Map" Option Misconfigured:The "map" option should be turned on when you're mapping data from a previous module. If you're inputting the array directly for testing purposes, turning it off can help you see how the module interprets your input, but remember to turn it back on in your actual scenario.
• Data Type Confusion:Be cautious about assuming that data enclosed in square brackets is recognized as an array. Make.com may interpret it as a string unless it's explicitly defined as an array data type.

Tips

• Double-Check Your Functions:Ensure that you're using the correct syntax and that all functions are properly closed with parentheses.
• Use Debug Mode:Make.com provides debugging tools to inspect your data at each step. Use this to verify that your array is correctly formatted.
• Include Reference Screenshots:Visual aids can help you understand how your data is being processed. I'll include relevant screenshots to illustrate these points.

Conclusion

Navigating Make.com's Iterator module can be challenging, especially when dealing with arrays. By understanding the importance of data types and correctly configuring your modules, you can efficiently process each element in your array.

I hope this tutorial saves you the time and frustration I experienced. Remember, sometimes starting simple and verifying each step can lead you to the solution more quickly than trying to implement complex fixes.

Final Thoughts

If you've been pulling your hair out over Make.com's Iterator module, know that understanding data types and module configurations can make all the difference. By paying attention to how the "map" option affects data processing and verifying your data types, you can save yourself a lot of time and frustration.

What challenges have you faced while automating tasks in Make.com or similar platforms? Share your experiences in the comments below!

FAQs