Make's Free 1,000 Credits a Month: How Far They Really Go, and the One Aggregator That Cuts Usage 73%

Make (formerly Integromat) advertises a generous free tier: 1,000 credits per month. Yet plenty of people build their first scenario and watch the balance drain inside a week.

The problem is not that you are running too much. It is that what you think of as “one run” is not one run under Make’s billing rules.

Everything below comes from Make’s own help center. The two core documents, Operations and Credits, both carry an official update date of 2026-09-10, so this is the current version (verified 2026-09-10).

1. The conversion you have to memorize: one module run equals one credit

Make’s definition of an operation is a single sentence: an operation is one module run, either to process data or to check for new data.

Credits are the billing unit, and the documentation is explicit:

• Non-AI apps: 1 operation = 1 credit.
• Third-party AI apps (Make names OpenAI, Anthropic Claude, and Gemini): 1 operation = 1 credit as well, though modules using automatic AI provider connections also fold token usage into the credit count.

Make explains why there are two words at all: credits track how much you are spending, operations show the outcome of what you did on the platform.

So the answer to “what does one scenario run cost” is never “1.” It is how many times every module in that run executed.

2. Triggers cost 1, no matter how much they pull back

This is the one exception that works in your favor, and the one most people get backwards:

Trigger modules run only once to check for or retrieve data, regardless of the number of bundles returned.

Make’s example: a Google Sheets watch new rows module checking a spreadsheet is 1 operation per check — even when that check returns 10 rows.

In other words, your credits are not consumed by fetching data. They are consumed by everything you then do to each item.

3. The bundle multiplier: one run becomes 31 credits

Make calls a unit of data a bundle — one email, one contact, one file. The rule that matters:

Modules process each bundle separately, meaning each bundle triggers its own module run.

Make supplies the arithmetic directly. A scenario watches for new Google Forms responses, creates a document for each one, downloads it, and emails it to the respondent. The trigger returned 10 new responses:

Make’s own conclusion: bundles in earlier modules have a multiplying effect on the operations in the rest of the scenario.

Put that against the free tier: 1,000 credits ÷ 31 ≈ 32 runs. A “do three things with each response” scenario is good for roughly 32 rounds a month.

4. The fix Make itself demonstrates: an aggregator takes 11 down to 3

In the same document, Make walks through its own optimization. The original scenario: Google Sheets watches for new contacts (1 operation, returning 10 bundles), then Gmail sends one email per contact to the sales manager (10 operations) — 11 operations total.

Make’s fix: add a text aggregator that combines all new contacts into the body of a single email. The documented result:

This adjustment reduces total operations for this run from 11 to 3.

That is 73% off. The inbox also gets better — one digest beats ten notifications on its own merits.

This is the single most actionable rule here. Whenever your scenario does something once per item, ask whether those actions can be merged: digest notifications, batched writes, one combined file. Same idea every time.

5. Do the schedule math against your 1,000 credits

Our tool record (read directly from Make’s official pricing page on 2026-08-28) lists the free tier limits as: 1,000 credits per month, at most 2 active scenarios, a 15-minute minimum scheduling interval, a 5-minute cap per run, and a 5 MB file limit.

Apply the official rule that each trigger check is one operation: a 15-minute interval is 96 checks a day, roughly 2,880 a month — more than double the free tier’s 1,000 credits before a single downstream module has run. (That figure is our arithmetic on Make’s stated definition, not a published Make number.)

So on the free tier:

1. Stretch the interval. Not every workflow needs to fire every 15 minutes; hourly or daily changes credit consumption by an order of magnitude.
2. Use webhooks instead of polling where you can. Being woken when something happens beats asking every 15 minutes.
3. Two active scenarios is a hard cap. Turn off the experiments you are not using.

⚠️ Unverified: an earlier note in our tool record says filters and routers are billed too. Reading Make’s Operations and Filtering documents on 2026-09-10, Make defines an operation as a module run, and a filter is a condition placed on the connection between two modules — the documentation does not list it as producing an operation. The two accounts disagree, so we are not ruling on whether filters bill until Make states it explicitly.

6. Where the credits really go: AI modules

If you plan to run AI steps on the free tier, read this part. Make splits credit consumption in two:

• Fixed usage: the default rate of 1 operation = 1 credit, constant regardless of input size. Make’s example is a Google Drive file upload — 1 credit whatever the file weighs. With exceptions: Make states that some Make AI Content Extractor modules consume more than the default because of processing complexity (its illustration shows modules at 2 and 10 credits), and those modules carry a distinct tag in the interface.
• Dynamic usage: billed on actual consumption, most often tokens. Make lists other factors as well: file size, page count, and processing time.

More important, the connection type decides how you are billed — and there is a plan gate hidden in it:

Read that carefully: the cheapest arrangement — bring your own key, pay credits only per operation — is documented as paid-plans-only. On the free tier your AI runs through Make’s provider, where credits track tokens directly.

Make’s published conversion rates (excerpt; Make notes they change as new models ship):

The spread is severe: for the same text, Sonnet 5 burns roughly 60 times the credits of GPT-5 nano. Make also notes that in English about 4 characters make a token, and 100 tokens is about a paragraph.

Practical free-tier advice: prove the workflow with a small model first, and do not point the largest model at long documents while you are still on free credits.

7. When the credits run out, the free tier has no top-up

Make’s Extra credits page is direct. Three things matter:

1. Extra credits are for paid plans only. On free, you wait for the monthly reset (our record: credits reset monthly and do not roll over).
2. Top-ups cost 25% more. Make’s worked example: a US$9 plan with 10,000 credits puts one credit at US$0.0009, so 1,000 extra credits cost US$1.125 and 10,000 cost US$11.25.
3. Extra credits expire. On monthly billing they die at the end of the current cycle (Make’s example: a cycle running the 1st to the 31st, credits bought on the 20th expire on the 31st). On annual billing they expire at each monthly reset.

Make’s own advice is honest enough: if you routinely exceed your plan, move up a plan rather than keep topping up, because higher tiers have a lower per-credit cost.

8. Free-tier credit checklist

1. Cost one round first: 1 for the trigger, plus each downstream module times the bundle count.
2. Merge anything that runs once per item — Make’s own aggregator example saves 73%.
3. Lengthen the schedule or switch to webhooks; 15-minute polling alone outruns the monthly allowance.
4. Start AI steps on a small model; the bring-your-own-key discount is not available on free.
5. Watch for tagged high-consumption modules that bill 2 or 10 credits per run.
6. You cannot buy your way out on free, so track usage mid-month rather than discovering it when scenarios stop.

Sources

• Make help center, Operations: https://help.make.com/operations (official update date 2026-09-10)
• Make help center, Credits: https://help.make.com/credits (official update date 2026-09-10)
• Make help center, Extra credits: https://help.make.com/extra-credits
• Make help center, Filtering: https://help.make.com/filtering
• Free tier limits come from our tool record (read directly from make.com’s pricing page on 2026-08-28). On 2026-09-10 make.com/en/pricing returned 403 to our request, so the plan and free-tier figures are carried over from that earlier first-hand check rather than re-verified today.

For a comparison of free allowances on a similar workflow tool, see n8n community edition versus the cloud trial. Make’s current plans and free limits are on the Make tool profile.