Make.com Array Iterator Tutorial: How to Iterate Arrays

The Engine of Scale: Mastering the Make.com Array Iterator

Imagine you have a single box. Inside, there are 50 distinct requests from high-value clients. You hand this box to an employee and say, “Process this.”

In the manual world, a smart employee opens the box. They take out item number one and handle it. Then, they move to item number two. They intuitively know how to iterate.

But in the world of automation, software is literal. Specifically within Make.com (formerly Integromat), if you hand a module a “box” of 50 items, it tries to process the box itself as a single unit. This often results in errors, data blobs, or a complete workflow failure.

This is where the Array Iterator becomes the most critical tool in your automation stack. It is the transmission system that shifts your automation from a static data mover to a dynamic processing engine.

At Thinkpeak.ai, we specialize in transforming manual business operations into self-driving ecosystems. Whether we are deploying our SEO Öncelikli Blog Mimarı or using our Google Sheets Bulk Uploader, the humble Iterator is the silent workhorse behind the scenes.

In this guide, we will move beyond basic tutorials. We will dissect the logic of the Array Iterator. We will explore its relationship with JSON structures and reveal how to avoid the deadly “Operations Trap.” Finally, we will show you how to build the complex, AI-driven workflows that power modern enterprises.

The Core Concept: Arrays vs. Bundles

To master the Iterator, you must first understand the fundamental language of Make.com. You need to know the difference between an Array and a Bundle.

The “Box of Donuts” Analogy

Think of data moving through Make.com like a delivery of donuts.

A Bundle is the shipment. It is a container.
An Array is the box of donuts inside the shipment.
The Items are the individual donuts (Glazed, Chocolate, Jelly).

When you receive a webhook from Shopify with an order containing 5 different products, Make.com usually sees one Bundle (the Order). Inside that Bundle is an Array called Line Items, containing 5 products.

If you try to map Line Items: SKU to a Google Sheet row without an Iterator, Make.com doesn’t know which SKU you mean. It might grab the first one. Or, it might try to jam all five SKUs into a single cell.

Bu Array Iterator takes that box of donuts (the Array) and separates them. It outputs 5 distinct Bundles, one for each donut. Now, the subsequent modules in your scenario run 5 times—once for each product.

Why This Distinction Matters

Understanding this structure is the difference between a broken scenario and a scalable one. Most beginners fail because they treat Arrays like Text. They aren’t. They are structured lists that require “unpacking.”

Definition: Bu Array Iterator is a flow control module that splits a single bundle containing an array of items into multiple bundles. This allows subsequent modules to process each item individually.

Step-by-Step Tutorial: Setting Up the Array Iterator

Let’s walk through a foundational setup. We will use a common scenario: Processing a list of leads from a CSV file.

Step 1: The Source Data

Assume you have a module (like Parse CSV veya Google Sheets: Search Rows) that outputs a list of leads.

Çıktı: 1 Bundle.
Data: An Array named Rows[] containing 20 lead objects (Name, Email, LinkedIn URL).

Step 2: Adding the Iterator

Click the Flow Control icon (the purple specialized module icon) at the bottom of your scenario builder.
Select Yineleyici.
Connect it immediately after your source module.

Step 3: Mapping the Array

When you open the Iterator settings, you will see a single field: Dizi.

Click into the field.
Locate the Rows[] array from your source module in the mapping panel.
Crucial Tip: You must select the top-level array (usually indicated by brackets []), not a specific value inside it (like İsim).

Step 4: Configuring Subsequent Modules

Now, add a module after the Iterator. For example, use Gmail: Send an Email.

Open the Gmail module.
In the “To” field, map the email address from the Iterator module, not the original CSV module.
Visual Check: When you hover over the connection line between the Iterator and Gmail, you should see a multiple bundles icon after running. This indicates the data has been split.

The Result

If your CSV had 20 rows:

The CSV module runs 1 time.
The Iterator runs 1 time (to perform the split).
The Gmail module runs 20 times.

The “Operations Trap”: Cost Optimization Strategy

İşte burası Thinkpeak.ai consultants usually intervene to save clients money. The Array Iterator is powerful, but it poses a risk to your Make.com operations budget.

How the Math Works

Make.com charges you per “Operation.” This happens every time a module creates a bundle or performs an action.

Scenario A (No Iterator):

Trigger: 1 Op
Action: 1 Op
Total: 2 Operations.

Scenario B (Iterator with 100 items):

Trigger: 1 Op
Iterator: 1 Op (Splitting costs 1 Op).
Action: 100 Ops (Runs once per item).
Total: 102 Operations.

If you process a list of 1,000 items daily, a single Iterator can burn 30,000 operations a month.

Optimization Strategies

1. Filtering Before Execution

Always place a filter immediately after the Iterator. For example, if iterating through Shopify Orders, filter for Status = Paid önce the subsequent modules run. If you filter inside the module, you pay for the operation to start it. By placing the filter on the connecting line, you stop the operation before it costs you money.

2. Batch Processing (The Aggregator Trick)

If you are writing data to a database like Supabase or Google BigQuery, do not iterate and write one row at a time.

Kullanım Yineleyici to clean or format data.
Immediately use an Array Aggregator to rebundle the data into groups of 50.
Send 1 “Batch Create” API call instead of 50 individual “Create Row” calls.

3. The Thinkpeak “Efficiency Audit”

When we build Ismarlama Dahili Araçlar, we architect backend logic to minimize loop cycles. For example, our Inbound Lead Qualifier doesn’t just loop through every form submission. It uses array functions like map() ve flatten() inside a generic variable setter. This filters data in memory before ever engaging an Iterator, saving thousands of credits.

Advanced Logic: Nested Arrays & Complex JSON

As you move into AI automation, data structures get messy. AI agents often return Nested Arrays—lists inside of lists.

Örnek: An AI analyzes a company and returns a JSON object with:

Competitors[] (Array)
- Competitor Name
- Top_Articles[] (Nested Array inside Competitor)

How do you iterate through the Makaleler of the Competitors?

The Double-Iterator Method

Iterator 1: Maps the Competitors[] array.
- Output: One bundle per Competitor.
Iterator 2: Maps the Top_Articles[] array from Iterator 1.
- Output: One bundle per Article.

Warning on Data Context

When you are inside Iterator 2 (Articles), you still have access to the data from Iterator 1 (Competitor Name). This allows you to create records linking the competitor to their specific articles. This technique is fundamental to our LinkedIn Yapay Zeka Parazit Sistemi, which identifies high-performing content and iterates through comments to generate engagement insights.

The Reassembly: Mastering the Array Aggregator

You cannot talk about the Iterator without its twin: the Aggregator. If the Iterator is a grenade that blows your data into pieces, the Aggregator is the magnet that pulls it back together.

When to Use It

Summarizing: You iterated through 50 sales to calculate commissions. Now you need to send bir email with the total. You aggregate the bundles back into a text string or HTML table.
JSON Construction: You are preparing a payload for an API that requires a list of items.
Error Recovery: Grouping successful operations while filtering out failed ones.

The Setup

Place the Array Aggregator after your processing modules.
Source Module: Select the Iterator you started with. This tells the Aggregator to wait until that specific loop finishes.
Target Structure: If mapping to a specific app, Make.com will ask for the structure. For a custom array, choose “Custom.”

Thinkpeak Pro Tip: In our AI Proposal Generator, we iterate through client discovery notes to generate bullet points. We then use a Text Aggregator to merge those points into a single formatted HTML string to inject directly into a PDF proposal.

Strategic Use Case: The “Cold Outreach Hyper-Personalizer”

To truly understand the power of the Iterator, let’s look at a real-world workflow from the Thinkpeak.ai Otomasyon Pazaryeri.

The Goal: Scrape 100 prospects, research their company news, and generate a personalized “Icebreaker” for a cold email.

The Workflow

Tetikleyici: Watch Leads in Apollo (Outputs 100 leads).
Module: Iterator: Split the 100 leads into individual bundles.
Module: HTTP Request (Scraper): Kullanın Company URL from the Iterator to scrape the homepage text.
Module: OpenAI (GPT-4): Prompt the AI to write a compliment based on the scraped text.
Module: Update Record (HubSpot): Write the generated Icebreaker back to the lead’s CRM profile.
Module: Sleep: Optional delay to avoid hitting API rate limits.

Why the Iterator is Vital Here

You cannot send 100 homepage URLs to ChatGPT in a single prompt and ask for 100 distinct sentences reliably. The AI will hallucinate or merge them. The Iterator ensures that Lead A gets Icebreaker A, maintaining 100% data integrity.

Need this built for you? Bu seviye Hiper-Kişiselleştirme is standard in our systems. Stop guessing and start converting. Thinkpeak'in Otomasyon Pazarını Keşfedin.

Troubleshooting & Common Pitfalls

Even experts encounter errors. Here are the most common issues and how to solve them.

1. The “Missing Variables” Bug

Symptom: You add an Iterator, but subsequent modules only show Total number of bundles. You cannot see the actual data fields to map them.

Çözüm: Make.com hasn’t “learned” the structure yet. Right-click the Iterator and choose “Run this module only” with sample data. The fields will appear after the first run.

2. The “Infinite Loop” (API Rate Limits)

Symptom: Your scenario fails with 429: Too Many Requests.

Çözüm: The Iterator is firing API calls faster than the destination allows. Add a Sleep module inside the loop to throttle execution.

3. Processing “Collections” instead of “Arrays”

Symptom: The Iterator only outputs 1 bundle, even though you see multiple items.

Çözüm: Your data is inside a Collection (Object), not an Array (List). Use the toArray() function or the JSON > Transform to JSON module to restructure the data before iterating.

Beyond the Basics: Building a Proprietary Software Stack

The Array Iterator is just one brick in the wall. At Thinkpeak.ai, we believe that mastering these tools allows businesses to stop renting software and start building o.

When you combine Iterators, APIs, and AI Agents, you enter the realm of Özel Düşük Kodlu Uygulama Geliştirme. We use tools like FlutterFlow for the front end, while complex Make.com iterators handle the backend logic. This delivers SaaS-level performance for a fraction of the cost.

If you are tired of patching together “Zaps” and want a robust ecosystem, you are ready for the Thinkpeak.ai approach. Discover Our Bespoke Engineering Services.

Sonuç

Bu Make.com Array Iterator is the gateway to advanced automation. It allows you to handle lists, scale operations, and personalize data at volume. However, it requires a disciplined approach to data structures and costs.

By mastering the Iterator/Aggregator loop, you build a digital workforce capable of handling thousands of tasks without fatigue.

Take the next step:

Hız için: Bizim göz atın Otomasyon Pazaryeri for pre-configured workflows.
Ölçek için: Contact our Ismarlama Mühendislik team to architect a custom internal tool.

Sıkça Sorulan Sorular (SSS)

What is the difference between an Iterator and an Aggregator in Make.com?

An Iterator splits a single array into multiple bundles (1 input becomes Many outputs). An Aggregator does the opposite: it combines multiple bundles into a single array (Many inputs become 1 output). They are often used together to process data and then summarize the results.

Does the Array Iterator consume operations?

Yes. The Iterator module itself consumes 1 operation to perform the split. However, the subsequent modules will consume 1 operation per bundle. If you iterate an array of 50 items, the next module will run 50 times, consuming 50 operations.

How do I filter data inside an Iterator?

To save operations, place a filter on the connecting line arasında the Iterator and the next module. This prevents the next module from running for bundles that don’t meet your criteria.

Can I nest Iterators?

Yes. You can place a second Iterator after the first one to handle nested arrays. Be careful with operation costs, as this creates a multiplicative effect (10 groups x 10 items = 100 operations).

Make.com Array Iterator Tutorial: How to Iterate Arrays