What does a Make.com automation agency do?
A Make.com automation agency designs, builds and repairs Make scenarios: the visual workflows that move data between your apps. We plan the scenario, build it on your own Make account, add error handling and alerts, and keep it running.
Make (once called Integromat) runs automations as scenarios. A scenario starts with a trigger module, such as a new form entry or a webhook from your CRM, and then runs action modules in order. Routers split the flow into branches, iterators break a list into single items, and aggregators join them back together. The canvas shows every module and how many times it ran, which makes Make easy to read and easy to break without noticing.
Our Make work falls into four jobs:
- New scenarios. Lead routing, order and invoice syncs, reporting, file handling and handoffs between a CRM and the tools around it.
- Fixing broken scenarios. Scenarios that switch themselves off, stop halfway, use up credits early or quietly drop records.
- Cost work. Rebuilding scenarios so the same job uses fewer credits, usually by changing the trigger or filtering earlier.
- AI steps. Adding a Make AI Agent or an AI module where a step needs judgement, such as sorting an email or summarising a document.
Make is one of three tools we build on, next to n8n automation services and Zapier automation services. All three sit inside our wider business process automation work, and we tell you plainly when one of the other two fits your job better.
How does Make bill you: operations or credits?
Make bills in credits. Since August 2025, credits replaced operations as the billing unit, and for non-AI apps one operation still equals one credit. Each module run is an operation, while routers and error handlers use no credits.
Make's credits guide sets the rules. Existing operations were converted to credits at 1:1, and plans and prices stayed the same at the switch. What changed is AI: Make's built-in AI features can use more than one credit per run, because they also charge for tokens.
What counts as one operation
Make's operations page defines an operation as "a single module run to process data or check for new data." Three details decide most bills:
- Every bundle counts. A Gmail module that sends 5 emails in one run uses 5 operations, one per email.
- A polling trigger counts once per check. A Watch New Rows trigger uses 1 operation every time it checks, even when nothing new is there.
- Some features cost nothing. Make's pricing page says error handler modules and router modules consume no credits.
What a plan includes
| Item | What Make publishes |
|---|---|
| Free plan | 1,000 credits a month |
| Usage allowance per 10,000 credits a month | 5 GB data transfer, 10 MB data storage, 10 MB incomplete executions storage (2 GB maximum), webhook queue of 667 (10,000 maximum) |
| Core plan ceiling | Up to 300,000 credits a month; larger tiers moved to Pro (November 6, 2025) |
| Pro plan ceiling | Up to 8 million credits a month |
| Extra credits | Bought in units of 1,000 by hand or 10,000 automatically, at 25% more than the credits in your plan |
| Annual billing | Pro and Teams get the year's credits up front; Core still resets monthly |
| Longest scenario run | 45 minutes on paid plans, 10 minutes on Free |
| Make Code app | 2 credits per second of code run time; 30-second limit on Core, Pro and Teams |
Sources: Make pricing page, the plans and pricing adjustments note, the extra credits guide the errors and warnings guide and the Make Code release note, all checked October 30, 2026. The minimum gap between scheduled runs depends on your plan, according to Make's scheduling guide. The default schedule is every 15 minutes.
What does Make cost for 5,000 and 50,000 runs a month?
For a six-module scenario triggered by a webhook, 5,000 runs a month uses 30,000 Make credits, about $23 to $27 at the per-credit prices in Make's own help pages. At 50,000 runs it uses 300,000 credits, about $203 to $228.
Monthly cost of 5,000 runs of a six-module scenario
We priced one workload on all three tools with the figures each vendor published, checked October 30, 2026. The arithmetic is shown so you can redo it with your own numbers.
Units used per run
- Make: 6 modules x 1 credit = 6 credits a run. Make counts the trigger.
- Zapier: 5 actions x 1 task = 5 tasks a run. Zapier's pricing page says triggers do not count.
- n8n Cloud: 1 execution a run. n8n's pricing page bills each complete workflow run once, whatever the number of steps.
| Tool | 5,000 runs a month | 50,000 runs a month |
|---|---|---|
| Make | 30,000 credits. 30,000 x $0.000759 = $22.77; 30,000 x $0.0009 = $27.00. Staying on the 10,000-credit plan and buying 20,000 extra credits instead: $9 + (20,000 x $0.0009 x 1.25) = $31.50 | 300,000 credits, the most Core allows. 300,000 x $0.00067626 = $202.88; 300,000 x $0.000759 = $227.70 |
| Zapier | 25,000 tasks. Smallest tier that holds it is 50,000 tasks: Pro $289 a month billed annually, or $433.50 billed monthly | 250,000 tasks. Above the largest tier on the page (100,000 tasks, Pro $489 a month billed annually), so you would need Zapier's overage or a quote |
| n8n Cloud | 5,000 executions. Pro: €50 a month billed annually for 10,000 executions | 50,000 executions. Above Business (40,000 executions, €667 a month billed annually, self-hosted only), so a custom quote from n8n, or the self-hosted Community Edition on your own server |
Three things move these numbers more than the plan does:
- Polling triggers. If the scenario checks for new data on a schedule, each check costs a credit. Every 15 minutes is 4 x 24 x 30 = 2,880 credits a month; every minute is 60 x 24 x 30 = 43,200 credits a month, even when nothing arrives. A webhook trigger avoids that.
- Lists. A module after an iterator runs once per item. A run that loops over 20 order lines can use 20 times the credits you planned.
- AI tokens. With Make's AI Provider, credits also cover tokens. On GPT-5 mini, Make's table gives 3,616 input tokens and 452 output tokens per credit. An illustrative agent step that reads 2,000 tokens and writes 300 uses about 2,000 / 3,616 + 300 / 452 = 0.55 + 0.66 = 1.2 credits in tokens, plus 1 credit for the operation, before any rounding Make applies.
For the Zapier and n8n side of this comparison in more depth, see our n8n and Zapier pricing research, or run your own run and step counts through the Zapier vs n8n cost calculator.
How much does it cost to hire us to build on Make?
At the time of writing, the strategy call and audit are free, a small build of two or three scenarios is about $1,000, and larger systems get a fixed price after the audit. Fixes to what we build are free for 6 months.
After the first 6 months, monthly support from $200 is optional. Your Make subscription is separate: you pay Make directly on your own account, so you see the real credit cost every month. If you need more detail on running costs, our page on software costs on top of a build lists what tends to sit alongside an automation project.
| What you need | Price at the time of writing |
|---|---|
| Strategy call and audit of your current scenarios | Free |
| Small build: two or three scenarios | About $1,000 |
| Larger system (many scenarios, AI agents, CRM backend) | Fixed price quoted after the free audit |
| Fixes to anything we built | Free for 6 months |
| Monthly support after that | Optional, from $200 a month |
Freelance Make developers often charge by the hour. Hourly work suits a single small fix. For a build, a fixed price after an audit tells you the full cost before work starts.
How do we build a Make scenario?
We map the process first, then build on your Make account, test with real records, add error handlers and alerts, and hand over notes. A small build of two or three scenarios usually takes days.
- Free call and audit. We look at the job, your apps and any scenarios you already have, then send a written plan and a fixed price.
- Design on paper. Trigger, modules, routes and the expected credits per run, so you know the monthly Make cost before anything is built.
- Build. On your Make organization, with connections to your own app accounts.
- Test. Real sample records through every route, including the failure routes.
- Error handling. Handlers on the modules that can fail, incomplete executions turned on where data must not be lost, and an alert to a person.
- Handover. A short note per scenario covering what it does, what it costs and what to check if it stops.
Timelines for larger systems are in how long an automation build takes.
When is Make the right tool, and when is n8n or Zapier better?
Make suits visual, branching scenarios at moderate volume where a team wants to see the whole flow on one canvas. n8n fits very high volume, long runs or heavy code. Zapier fits simple app-to-app links that a non-technical person will own.
| Your situation | Our usual pick | Why |
|---|---|---|
| Many branches and conditions, moderate volume | Make | Routers cost no credits, and the canvas shows every branch |
| Database writes that must all succeed or all fail | Make | Modules tagged ACID can roll back as a group (execution phases) |
| You need data processed in an EU data center | Make or n8n | Make lets you pick a US or EU data center when you create the organization |
| Runs that last longer than 45 minutes | n8n | Make stops a paid-plan run after 45 minutes |
| Heavy custom code | n8n | Make Code is limited to 30 seconds on Core, Pro and Teams and costs 2 credits a second |
| Tens of thousands of long runs a month | n8n | n8n bills the run, not each step |
| A two-app link a non-technical person will maintain | Zapier | Short setup and a gentle learning curve |
| Texts, emails and pipeline stages inside your CRM | The CRM itself | Keep messaging logic where the contact record lives |
Our n8n vs Zapier guide covers the other two tools head to head. When a job outgrows Make, it usually moves to n8n; our medical job board feed import is an example of a scheduled, batch-heavy workflow we built on n8n.
How do Make error handlers work?
An error handler sits on a module and takes over when that module fails, so the scenario does not simply stop. Make has five: Skip, Retry, Resume, Commit and Rollback. Handlers use no credits when they run.
What each Make error handler does
Make's error handling overview describes each one. If you learned Make from an older tutorial that mentions Ignore or Break, Skip and Retry are the current handlers that do those jobs.
| Handler | What it does | When we use it |
|---|---|---|
| Skip | Drops the failed bundle and carries on with the next one; the run is marked successful | Losing that one record does no harm, such as a duplicate the CRM already rejected |
| Retry | Stores the failed bundle as an incomplete execution and retries it, by default 3 times, 15 minutes apart | Temporary failures, such as a database that is briefly unreachable |
| Resume | Puts a substitute value in place of the failed module's output and continues | A missing field has a safe default |
| Commit | Stops the run and keeps the changes made so far | Earlier steps are valid on their own |
| Rollback | Stops the run and reverts changes in modules that support rollback | All steps must succeed together |
Incomplete executions
Incomplete executions are Make's safety net: a failed run is saved so it can be fixed and continued. They are off by default; you turn them on in the scenario settings. Once they are on, Make retries connection, rate limit and timeout errors on its own, 1 minute after the failure, then after 10, 10 and 30 minutes and on from there, according to its automatic retry guide.
Two gaps catch people out. An error on the first module does not create an incomplete execution unless a Retry handler is attached to it. And a run that hits the 45-minute limit is not saved either.
Why do Make scenarios break, and how do we fix them?
Most broken scenarios fail in a handful of ways: they switch themselves off, stop halfway, burn credits on empty checks, or drop records without saving them. Each has a clear cause in Make's own settings and a fix.
Make limits that cause most failures
| Symptom | Cause | Fix |
|---|---|---|
| The scenario turned itself off after one error | A scenario that starts with an instant trigger is deactivated at the first error | Add handlers to the modules that can fail and turn on incomplete executions |
| Runs stop partway with ExecutionInterruptedError | The run passed 45 minutes (10 on Free) | Split the scenario and lower search module limits |
| Credits run out though volume has not changed | A polling trigger checking often, or a module after an iterator running per item | Switch to a webhook trigger, widen the interval, filter before the expensive modules |
| Failed runs vanish with nothing to retry | Incomplete executions are off, or the error was on the first module | Turn them on; put a Retry handler on the first module |
| Callers of your webhook get HTTP 429 | The scenario hit its runs-per-minute limit (default 100) while returning a webhook response | Raise the limit, or let requests queue without an instant response |
| Failed data discarded | Incomplete executions storage is full and data loss is allowed | Size storage for your volume and alert someone before it fills |
| Half-written records after an error | Modules without the ACID tag cannot roll back | Check for a record before creating one, and use Commit or Rollback on purpose |
| Bills jumped after adding an AI step | Make's AI Provider charges credits for tokens | Use your own AI provider connection on a paid plan and pay the provider directly |
Sources for these behaviours: Make's scenario settings guide, scheduling guide, errors and warnings guide and credits guide, checked October 30, 2026. When we take over someone else's scenarios, we first list every scenario, its trigger and its credits per run, then fix the ones that fail or cost the most.
What are Make AI Agents and Make Grid, and do you need them?
Make AI Agents let a scenario hand a judgement call to an AI model with tools and knowledge files. Make Grid is an auto-generated map of how your scenarios, apps and agents connect. Agents suit messy inputs; Grid suits large accounts.
The current app, Make AI Agent (New), was released on February 2, 2026 and is in open beta, so features and pricing may change, according to Make's AI agent introduction. It runs on all plans with Make's AI Provider, and paid plans can connect their own provider. Make's own guidance is to use an agent for judgement calls, an AI module for fixed tasks like translating, and a standard scenario for predictable syncs. We follow the same rule and keep agents away from high-stakes decisions. In October 2026 Make added a fallback provider and prompt caching; our note on the October 2026 Make AI Agent update has the details. For agent work across tools, see AI steps inside a workflow.
Make Grid draws a near real-time map of scenarios, apps, data stores and AI components, with error indicators. On a messy account it shows which scenarios depend on each other before anything is changed.
How do you check that a Make expert or Make partner is real?
Ask for the firm's profile link in Make's partner directory at make.com/en/partners-directory and open it yourself. Make lists partners there with their tier: Platinum is highest, then Gold, then Silver. A badge on a website alone proves nothing.
Make says on its partner program page that partners take its training course to earn certification. Its partner directory can be filtered by country, language and app specialization. To check any provider:
- Ask whether they are a Make partner. If yes, ask for the directory link and check the name matches.
- Ask who will build your scenarios, and ask to see a scenario they built, with client data hidden.
- Ask how they handle errors. A good answer names handlers and alerts. "It just works" is a weak answer.
- Ask whose Make account the work runs on. It should be yours.
Autoesta is not listed as a Make partner, and we do not use Make's partner badge. What we offer instead is the work itself: a free audit, a written plan with the expected credit cost, and 6 months of free fixes on what we build.
Who owns the Make account, scenarios and data?
You do. We build on a Make organization in your name, paid by you, and connect it to your own app accounts. You can remove our access at any time, and your scenarios and data stay where they are.
- Account. Each Make organization has its own plan and billing, per Make's organizations guide. Yours stays in your name, and we join it as a team member.
- Data location. You pick a US or EU data center when the organization is created, and it cannot be changed afterwards. Decide this before the build.
- Connections and keys. Connections use your own app logins and API keys. Make's credential request links are for official Make partners and Enterprise customers, so we set connections up with you on a short call instead.
- Sensitive data. The "keep data confidential" setting stops Make storing run payloads in its logs, at the cost of harder troubleshooting.
The general rules are in our page on who owns automations and data.
Read next:
- Make.com webhook not working?
- Make vs n8n in 2026
- what the Make Free plan includes
- Does Autoesta build Make.com automations?
More questions about Make.com automation
What does a Make.com expert do?
A Make.com expert plans, builds and repairs Make scenarios. That covers choosing triggers that do not waste credits, mapping data between apps, branching with routers, adding error handlers, and connecting tools that have no ready-made module through the HTTP module or webhooks. A good one also tells you what each scenario will cost per run before building it, and when Make is the wrong tool.
Is Make.com free to use?
Make has a Free plan with 1,000 credits a month, which is enough to learn and to run a few light scenarios. Free runs stop after 10 minutes, against 45 minutes on paid plans, and the shortest schedule interval depends on the plan. Most businesses move to a paid plan once a scenario runs on real volume.
Is Make cheaper than Zapier?
For multi-step scenarios, usually yes. In our worked example, 5,000 runs of a six-module scenario came to about $23 to $27 a month on Make, against $289 a month on Zapier's annual Pro tier that holds 25,000 tasks. Polling triggers and loops can close that gap, so count credits per run before you compare.
Should I use Make or n8n?
Use Make when you want a visual, hosted tool and your scenarios run under 45 minutes at moderate volume. Use n8n when runs are long, volume is very high, you need a lot of custom code, or you want to host it yourself. We build on both, and we can move a scenario from one to the other when the job changes.
Can you fix a Make scenario someone else built?
Yes. We start with a free audit: every scenario, its trigger, its credits per run and its recent errors. Then we fix the ones that fail or cost the most, add error handlers and alerts, and write a short note on what each scenario does. Fixes to anything we rebuild are free for 6 months.
What happens when Make runs out of credits?
Make's pricing page says scenarios will not continue until credits are added, and its error docs treat running out as a fatal error that switches off a scenario's schedule, so each scenario may need turning back on (see what happens when Make runs out of credits). Webhook data queues up to your storage limit. You can upgrade, buy extra credits, or turn on auto-purchasing, which buys 10,000 credits at a time at 25% more than your plan rate. Watching credits per scenario avoids the surprise.
Can Make connect to GoHighLevel?
Yes, through webhooks and the API. A GoHighLevel workflow can send a webhook to a Make custom webhook, and Make's HTTP module can call HighLevel's API. Our guide to connecting GoHighLevel by webhook or API explains which route fits which job.
Is Make.com secure enough for customer data?
Make lets you choose a US or EU data center for each organization and offers a setting that stops run data being kept in logs. Security also depends on the build: least-privilege connections, no secrets pasted into modules, and access removed when people leave. For regulated data, check Make's current terms against your own obligations before you build.
How long does a Make build take?
A small build of two or three scenarios usually takes days, including testing and error handling. Larger systems with many scenarios, AI agents or a CRM backend take weeks, and we give a timeline with the fixed quote after the free audit. Most of the time goes into testing the failure routes, not the happy path.
Can you move my Zaps to Make?
Yes. We list each Zap, rebuild it as a Make scenario, run both side by side on real records, then switch off the Zap. Moving can lower cost when Zaps have many steps, though Make counts the trigger as a credit while Zapier does not. We work out both costs first and tell you if moving is not worth it.
Make is one tool among several we connect; for custom connections between your CRM and other systems, see API integrations. To talk through a scenario, use the contact page or book a free strategy call.
Sources and further reading
- Make: Pricing and usage allowance, checked October 30, 2026
- Make Help Center: Credits
- Make Help Center: Operations
- Make Help Center: Extra credits
- Make Help Center: Change your subscription (Core example price)
- Make Help Center: Adjustments to plans and pricing
- Make Help Center: Overview of error handling
- Make Help Center: Automatic retry of incomplete executions
- Make Help Center: Fix errors and warnings
- Make Help Center: Scenario settings
- Make Help Center: Introduction to Make AI Agent (New)
- Make Help Center: Introduction to Make Grid
- Make Help Center: Schedule a scenario
- Make Help Center: Scenario execution, cycles, and phases
- Make Help Center: The Make Code app is available
- Make Help Center: Organizations
- Make: Partner directory
- Make: Partner programs
- Zapier: Pricing, checked October 30, 2026
- n8n: Pricing, checked October 30, 2026
