Researched
This analysis is based on documentation, public user reports, and vendor materials — not yet on our own hands-on testing. How we rate
The billing unit changed, and most guides didn't update
Make bills in credits now. It used to bill in operations. The switch happened in August 2025, and it's the reason two pricing articles about the same product can look like they're describing different platforms.
For most people the practical effect is small: one standard module run still costs one credit. Where it matters is AI. Make's built-in AI modules and code execution don't consume at a flat one-to-one rate — token volume and processing feed into it. If you're building AI-heavy scenarios, your credit burn won't track your run count the way it used to.
Operations still show up in your execution history as a usage metric, which is why the vocabulary stays confusing. Credits are the currency. Operations are the odometer.
What the tiers cost
| Plan | Annual (per month) | Monthly | Credits |
|---|
| Free | $0 | $0 | 1,000 |
| Core | ~$12 | ~$16 | 10,000 |
| Pro | ~$21 | ~$28 | 10,000 |
| Teams | ~$38 | ~$51 | 10,000 |
| Enterprise | Custom | Custom | Negotiated |
Published figures move around a little — different sources report slightly different numbers depending on region, promotional pricing and when they checked. The band above reflects what's been consistently reported through mid-2026. Confirm on Make's own page before budgeting.
The structural point matters more than the exact dollar: all three paid tiers include the same 10,000 credits. You are not buying volume as you move up. You are buying features. If you need more credits, you buy credit packs on top of whichever tier you're on.
So what does Pro actually buy?
This is the question people ask, because on paper Pro looks like Core with a higher price and identical credits.
What you get: full-text search across execution logs, custom variables, advanced scheduling, priority execution during peak load, and AI agents.
The execution log search is the one that justifies the upgrade for a lot of people. When a client scenario broke at 3am last Tuesday and you need to find out why, being able to search across historical runs rather than clicking through them individually is the difference between ten minutes and an afternoon. Agencies debugging automations they didn't build recently generally find this pays for itself.
Priority execution matters if your workflows are near-real-time — webhook-triggered customer notifications, for instance. If everything runs on a schedule and nobody notices a two-minute delay, it doesn't.
Teams is narrower still: roles, permissions, shared scenario templates. The price jump from Pro is substantial for what amounts to administrative features. Worth it when three or more people are actively building scenarios. Not worth it for two people who trust each other.
How credits actually disappear
The pricing page tells you how many credits you get. It doesn't tell you how fast a badly designed scenario eats them.
Iterators are the big one. If a scenario loops over line items in an order, every iteration counts. Process an order with twelve line items through a three-module loop and you've spent thirty-six credits on one run. Scale that across a few hundred orders and the arithmetic gets uncomfortable.
Polling triggers drain quietly. A scheduled scenario wakes up at every interval and checks for new data. It consumes credits whether or not there's anything to find. A scenario polling every fifteen minutes runs nearly three thousand times a month before doing any useful work. Where the source app supports webhooks, switching is close to free money.
Trigger design beats plan choice. This is the part most people get backwards. Rescanning an entire source table on every run costs vastly more than a properly configured "watch new records" trigger doing the same job. The difference between a naive and a careful implementation of identical logic can be an order of magnitude. Optimizing a scenario is usually cheaper than upgrading a plan.
How we researched this
We haven't run a Make workspace through a full production year, and we're not going to write as though we have.
This page draws on Make's published plan structure and credit documentation, cross-referenced against independent pricing analyses published between April and August 2026 — including one from Zapier's own comparison content, which we read with appropriate skepticism given the obvious interest but which lines up with the neutral sources on the actual figures.
Where reported prices diverged, we've given the band rather than picking whichever number looked cleanest. On Make that divergence is real: credible sources published within months of each other report Core anywhere from about $9 to about $16 depending on billing period and region. That's not sloppiness on anyone's part, it's a product whose displayed price genuinely varies.
What we can't tell you: how the canvas feels after your fiftieth scenario, how often executions fail silently, or how good Make's support is when something breaks at volume. Those need hands-on time.
Where Make isn't the right call
You want it working today. The visual canvas is powerful and it is not fast to learn. Routers, iterators, aggregators and error handlers all have to be understood before complex scenarios behave predictably. Zapier gets a simple integration live in minutes.
Nobody will own it. Automation platforms decay. Scenarios break when APIs change, and someone has to notice and fix them. Without a designated owner, Make becomes a graveyard of half-working workflows.
Your integration isn't there. Make's catalog runs to several thousand apps, which is large but not the largest. Check for yours specifically before committing — a missing native integration means HTTP modules and manual API work.
You need data residency or self-hosting. Make is hosted only. If your compliance requirements rule that out, n8n is the answer.
Against the alternatives
Against Zapier: Zapier has more integrations and a much gentler on-ramp. Make has more power per dollar and better handling of complex branching logic. The honest split is that Zapier sells simplicity and Make sells capability. Teams that outgrow Zapier's linear model tend to land here.
Against n8n: n8n self-hosts, which makes it dramatically cheaper at volume and keeps your data on your infrastructure. It also expects more of you technically. Make is the better choice when you'd rather pay someone else to keep the lights on.
Against Lindy AI: Lindy is agent-first — you describe what you want and it assembles the workflow. Make is builder-first, where you assemble it explicitly. Different philosophies about how much control you want over the middle.
Against CrewAI: not really competitors. CrewAI orchestrates AI agents in Python for developers. Make orchestrates app integrations visually for everyone else. Teams building agent systems sometimes use Make as the connective tissue around them.
Against Botpress: Botpress is for conversational interfaces specifically. If your automation is a chatbot, that's a different tool.
Pricing 2026
| Plan | Price | What it adds |
|---|
| Free | $0 | 1,000 credits, 2 active scenarios, 15-minute minimum interval |
| Core | ~$12/mo annual · ~$16 monthly | 10,000 credits, unlimited scenarios, all integrations |
| Pro | ~$21/mo annual · ~$28 monthly | Log search, custom variables, priority execution, AI agents |
| Teams | ~$38/mo annual · ~$51 monthly | Roles, permissions, shared scenario templates |
| Enterprise | Custom | Negotiated credits, SSO, SLA, dedicated support |
| Extra credits | Purchasable packs | Available on any paid tier |
Checked August 2026. Make replaced "operations" with "credits" as its billing unit in August 2025; for standard modules the ratio is one to one, but AI modules and code execution consume differently. All paid tiers include the same 10,000 monthly credits — higher tiers add features, not volume. Reported prices vary between sources and billing periods; figures above represent the consistently reported band. Verify on Make's pricing page before budgeting.
Replace polling with webhooks wherever you can. A scenario checking every fifteen minutes burns credits around the clock. This is the highest-return change most people can make.
Count your iterator steps. Loops multiply credit consumption in a way the pricing page never mentions.
Stay on Core unless you're debugging regularly. Pro's execution log search is excellent and unnecessary if your scenarios are simple and stable.
Pay annually once you're committed. The saving over monthly is roughly a third, which is not a rounding error.
Our Verdict
Make occupies a genuinely useful position: more capable than Zapier for anything with branching logic, more approachable than n8n for anyone who doesn't want to run a server. On price per unit of work, it's among the best hosted automation platforms available, and that's been true for a while.
The credit switch is the thing to understand. For standard modules nothing meaningfully changed. For AI-heavy scenarios, consumption no longer tracks run count, and any guide still written in terms of operations is telling you something slightly wrong.
Feature tiers, not volume tiers. All three paid plans carry identical credits. Choose based on whether you need log search and priority execution, not on how much you expect to run.
The reservations are consistent and worth taking seriously. The learning curve is real — this is not a tool you configure over a lunch break. Credit consumption depends heavily on how you build, which means two teams doing similar work can have very different bills. And the free tier, while genuinely useful for evaluation, will not carry anything you'd call production.
For a small business or agency that wants real automation without a developer on staff, Make is close to the best value on the market — as long as someone is willing to learn the canvas properly. For teams who want automations working this afternoon, Zapier is worth the premium.
Note: AIVario earns no commission from Make. This page is based on published documentation and independent pricing research rather than an extended paid deployment.
Best for: Agencies building client automations, small businesses replacing manual processes, ops teams with complex branching workflows, anyone who's outgrown Zapier's linear model
Not ideal for: Users needing something working immediately, teams without a designated owner, organizations requiring self-hosting or data residency
Bottom line: The best price-to-power ratio in hosted automation, provided you invest the time to learn it and design scenarios with credits in mind.
- Zapier — more integrations and a far gentler learning curve, at a higher price
- n8n — self-hostable and cheaper at volume if you can run infrastructure
- Lindy AI — agent-first automation where you describe outcomes rather than build steps
- CrewAI — multi-agent orchestration for developers, complementary rather than competing
- Botpress — the right tool when the automation is a conversation
Frequently Asked Questions about Make
What does Make cost in 2026?
Five tiers. Free is $0 with 1,000 credits a month and a cap of two active scenarios. On annual billing, Core is around $12 a month, Pro around $21, and Teams around $38 — all three including 10,000 credits. Monthly billing costs meaningfully more, in the region of $16, $28 and $51. Enterprise is custom with negotiated credit allocation. Published figures vary a little between regions and promotional periods, so treat these as the band rather than the exact number on your invoice.
What's the difference between credits and operations?
Credits are what Make bills you; operations are what your modules do. Make made the switch in August 2025. For ordinary modules the relationship is one to one — each module run costs one credit — so the practical math didn't change for most workflows. Where it does change is AI: Make's built-in AI modules and code execution can consume credits at a different rate than standard runs, depending on tokens and processing. Operations still appear in your run history as a usage metric, which is why the two terms get muddled.
Why do Core, Pro and Teams all include 10,000 credits?
Because on Make you're buying features, not volume. All three tiers include the same credit allocation. Core gets you the full scenario builder, unlimited scenarios, and every integration. Pro adds full-text search across execution logs, custom variables, priority execution and AI agents. Teams adds roles, permissions and shared scenario templates. If you need more credits rather than more features, you buy additional credit packs on whatever tier you're on.
Is the free plan actually usable?
For testing, yes. For production, no. A thousand credits sounds generous until you count properly: a straightforward three-step scenario spends three credits per run, which gives you roughly 330 runs a month. Add a router and a filter and you're at 200. The two-active-scenario cap bites just as hard, and the fifteen-minute minimum interval between scheduled runs rules out anything time-sensitive. It's a genuinely good evaluation tier and a genuinely bad production one.
How does Make compare to Zapier on price?
Make is substantially cheaper at equivalent volume — commonly three to five times so — but the units aren't directly comparable. A Zapier task is one successful action; a Make credit covers any module run including triggers, filters and iterator steps. So a workflow that Zapier counts as two tasks might cost you three or four credits on Make. Even accounting for that, Make comes out ahead on price at almost every volume. What Zapier buys you is speed of setup and a larger app catalog.
What burns credits fastest?
Iterators and aggregators, by a wide margin. If a scenario loops over line items, each iteration counts separately — a ten-item order costs ten credits at that step, not one. Polling triggers are the other quiet drain: a scheduled scenario wakes up and consumes credits at every interval whether or not there's new data. Switching from polling to webhooks where the source supports it is usually the single biggest saving available, and it costs nothing but an afternoon.
Make or n8n?
Depends on whether you want to run infrastructure. n8n can be self-hosted, which means near-zero marginal cost at high volume and full data control, and it's more comfortable if you're happy writing JavaScript inside nodes. Make is hosted, more polished, and considerably more approachable for people who aren't developers. The rough rule: if your team includes someone who'd enjoy maintaining a server, n8n is cheaper at scale. If not, Make's hosting is worth paying for.
