Make.com Iterator Credits: Why Loops Burn Them and How to Cut the Cost (2026)
Make.com iterator credits add up because every bundle an Iterator outputs makes each module after it run again, and Make bills one credit per module run. A 50-item array followed by three action modules costs 152 credits in a single scenario run. There are four ways to cut that, and the right one depends on your destination app and your volume.
Want to test your own loop?
Both platforms have a free plan, so you can measure your real credit use before changing anything.
First, check whether you need the Iterator at all, because array functions can often reshape data inside one module. If you do, put an Array Aggregator before your final write and send one batch call. For heavy per-item logic, the Make Code app bills by execution time, and Latenode bills by runtime in CPU seconds instead of per item. Keep Make.com for everything that is not loop-heavy.
How Make.com charges credits for iterators
Make bills most apps at one credit per operation. The part that surprises people is how bundles work. An Iterator splits an array into separate bundles, and every module after it runs once per bundle. Make’s own documentation states that the Iterator uses 1 credit to split the array, and the next modules use 1 credit for each iterated bundle.
| Module type | Credit rule | What it means in a loop |
|---|---|---|
| Trigger | 1 credit per run | Charged once, even if it finds no new data |
| Search | 1 credit per run | Charged once, however many bundles it returns |
| Iterator | 1 credit to split the array | Every module after it now runs per bundle |
| Action (Add, Update, Delete) | 1 credit per bundle processed | 50 items means 50 credits for each action module |
| Array Aggregator | 1 credit per aggregation | Collapses many bundles back into one |
| Router and filters | No credits | Free, but they do not stop upstream bundles |
| Make Code app | 2 credits per second of execution | Billed by time, not by item |
Source: Make’s “How features use credits” page, which showed an update date of November 6, 2026 when we checked.
The formula
Credits per run = 1 (trigger) + 1 (Iterator) + items x number of modules after the Iterator. For 50 items and 3 modules that is 1 + 1 + 150 = 152. At 1,000 runs a month, that is 152,000 credits.
Make.com iterator credit calculator
Enter your numbers to compare the standard Iterator, the Array Aggregator fix and a runtime-billed loop in Latenode. Make prices use the Core credit ladder on yearly billing, and Latenode uses its published CPU-second rates.
Make.com standard Iterator
Per month, the standard Iterator costs $182.16 more than Latenode and the Aggregator fix costs $99 more.
Estimates only. The Aggregator card assumes your last module becomes one batch call (1 aggregator credit plus 1 call credit); any other per-item modules still bill per item. Make prices are Core on yearly billing (10,000 credits $9, 20,000 $16, 40,000 $29, 80,000 $55, 150,000 $99, 300,000 $182.16), then Pro rates above 300,000. Monthly billing costs more. Latenode seconds depend on how long your loop really runs, including time spent waiting on external APIs. Confirm current prices on each vendor pricing page.
Module-by-module math for a 50-item run
This example has a trigger, an Iterator, one transform module and one write module after the Iterator.
| Workflow step | Make.com standard Iterator | Make.com with Array Aggregator | Latenode code node loop |
|---|---|---|---|
| 1. Trigger | 1 credit | 1 credit | Part of run time |
| 2. Iterator (50 items) | 1 credit | 1 credit | Not needed, the loop runs in code |
| 3. Transform each item | 50 credits | 50 credits | Part of run time |
| 4. Write to destination | 50 credits | 2 credits (1 aggregator, 1 batch call) | Part of run time |
| Total per run | 102 credits | 54 credits | Billed in CPU seconds |
If nothing needs to happen to each item between the Iterator and the Aggregator, the same run can drop to 4 credits. Often you can go further and skip the Iterator, as the next section explains.
Four fixes when loops burn your credits
Fix 1: Skip the Iterator with array functions
Make’s built-in array functions, such as map and join, can reshape or flatten an array inside a single module’s field mapping. If you only need to pull one field from each item, or build a joined string, you may not need to split the array at all, and the per-bundle charges never start.
Fix 2: Aggregate, then send one batch call
If the destination supports bulk records, such as a batch lead endpoint or a bulk row append, place an Array Aggregator right before the write. Fifty write operations become one aggregator credit plus one batch call. It only fixes the final write, so any per-item module before it still bills per item. Stay on Make.com for this one.
Fix 3: Move the loop into the Make Code app
The Make Code app bills 2 credits per second of execution instead of per bundle, according to Make’s credit documentation. A loop that finishes in one second costs 2 credits whatever the array size. Check that the app is available on your plan and that your logic fits its limits before you rely on it.
Fix 4: Offload heavy loops to Latenode
Latenode bills workflow runtime in CPU seconds and does not multiply the bill by nodes or items. A loop inside one JavaScript node costs the seconds it runs. This helps most when each item needs enrichment, regex or JSON reshaping, and the whole batch finishes in seconds. It helps least when the loop spends most of its time waiting on a slow external API.
Our recommended order
Try array functions first, then the Aggregator, because both keep you in one tool. Reach for the Code app or Latenode when per-item logic is heavy enough that Make’s per-bundle billing is still the main cost.
Want to see your own loop cost? Open Latenode’s free plan and run one real batch, then compare its CPU seconds with your Make credit usage.
Pricing snapshot (November 2026)
Prices change, so confirm on each pricing page. Make figures below are Core on yearly billing, and monthly billing is higher.
| Platform | Volume | Price |
|---|---|---|
| Make.com | 1,000 credits | Free |
| Make.com | 10,000 credits | $9 per month |
| Make.com | 40,000 credits | $29 per month |
| Make.com | 150,000 credits | $99 per month |
| Make.com | 300,000 credits | $182.16 per month |
| Latenode | First 10,000 CPU seconds | Free every month |
| Latenode | 10,001 to 100,000 CPU seconds | $0.00012 per CPU second |
| Latenode | 100,001 to 200,000 CPU seconds | $0.00011 per CPU second |
| Latenode | Example: 100,000 one-second runs | About $10.80 per month |
Latenode’s free plan limits runs to 3 minutes and 5 active workflows. Pay as you go raises that to 10 minutes per run and unlimited active workflows. Start with Latenode’s free plan or Make’s free plan.
When Latenode is not the right fix
Small arrays
A loop of five or ten items costs few Make credits. Rebuilding it elsewhere adds work without a meaningful saving.
Slow external APIs
Runtime billing counts the seconds your loop runs. If most of that time is waiting on a rate-limited API, the savings shrink.
A large existing Make setup
If dozens of scenarios depend on Make connectors and team habits, fixing the loop in place is usually cheaper than a migration.
Run limits
Free runs stop after 3 minutes and pay as you go runs after 10. Very long batches may need splitting.
Measure before you move
Run one real batch on each platform and compare the credits or CPU seconds in the execution logs. That number beats any estimate, including ours.
Test your loop for free
Run the same array through both approaches and compare the usage. Most people can tell within an hour whether the Aggregator is enough or the loop belongs somewhere else.
Affiliate links. We may earn a commission at no extra cost to you.
Frequently asked questions
Does the Make.com Iterator use credits?
Yes. The Iterator uses 1 credit to split an array into bundles, and each module after it uses 1 credit for every bundle it processes. Routers and filters do not use credits.
How many credits does a 50-item loop cost in Make.com?
With a trigger, an Iterator and three action modules, one run costs 152 credits: 1 for the trigger, 1 for the Iterator and 150 for three modules running once per item.
Do Make.com routers and filters use credits?
No. Make lists routers and filters, along with the Rollback, Break, Resume, Commit and Ignore error handlers, among the modules that do not use credits.
How can I reduce Make.com iterator credits?
Avoid the Iterator when array functions can reshape the data inside one module, batch the final write with an Array Aggregator and a bulk endpoint, move heavy loops into the Make Code app, which Make documents at 2 credits per second of execution, or run the loop on a platform that bills by runtime.
How does Latenode bill loops?
Latenode bills workflow runtime in CPU seconds, not per item or per node. The free plan includes 10,000 CPU seconds a month, and pay as you go pricing starts at $0.00012 per CPU second, falling in volume brackets. A loop inside one code node costs the seconds it runs.
Is Latenode always cheaper than Make.com for loops?
No. Small arrays, or loops that spend a long time waiting on slow external APIs, can cost more in runtime than they save. Measure a real run, and compare it with the Aggregator and array-function fixes before you move anything.
Official pages to verify
Rules for triggers, iterators, aggregators and the Code app.
Current plans and the credit volume slider.
Free allowance, CPU-second rates and plan limits.
How code nodes work inside a scenario.
Continue the automation build
Affiliate disclosure
CreatorOpsMatrix is an independent technical research and education publication. Some links to Latenode and Make.com are affiliate links, which means CreatorOpsMatrix may earn a commission if you sign up or purchase through them, at no additional cost to you. Commercial relationships do not change the technical criteria used in this guide. Pricing and credit rules change, so verify current details before you commit.