Contents
- Verdict
- What is Make?
- Best for, and not for
- Strengths and limits
- Pricing
- What people actually build with Make
- What Make actually costs at small-business volume
- The pricing gotcha: polling, and the tier that adds no capacity
- What breaks in production, and how you find out
- What it connects to that you already run
- Make alternatives: what to pick instead, and when
- Migration and lock-in: can you get your work out?
- FAQ
Make is the best canvas in the category and the meter is the catch. As of August 2026 it prices Core at $9 a month for 10,000 credits, Pro at $16 and Teams at $29, all with the same 10,000-credit allowance - so what you buy at the higher tiers is features and seats, not capacity. Make counts most individual module actions as one credit, which means a six-step automation running 2,000 times a month consumes roughly 12,000 credits and has already outgrown every published tier's included allowance. That is the whole story: brilliant to build in, cheap to start, and the bill tracks how many steps you drew rather than how much work got done.
What is Make?
Make (formerly Integromat) is a no-code automation platform built around a visual canvas where you lay out scenarios of connected modules. It is known for handling more complex, branching logic than the simplest automation tools, including loops, filters, and data transformation. It connects to a wide range of apps and has been adding AI modules for LLM steps.
Best for
People who want more logic and data handling than basic automation tools, with a visual canvas.
Not for
High-frequency or step-heavy workloads. If your automation polls often, loops over rows, or has fifteen modules in the happy path, per-credit billing turns every design decision into a pricing decision and you will spend more time optimising the meter than the outcome.
Strengths
- The clearest visual canvas in the category: branching, error routes and data flow are genuinely legible at a glance
- Handles loops, filters, aggregators and array mapping properly, which most simple trigger-action tools cannot do at all
- Cheapest credible entry point of the mainstream tools at $9 a month for 10,000 credits as of August 2026
- Routers and error handlers do not consume credits, so defensive design is free
- Large connector catalogue covering the small-business stack: Google Workspace, Microsoft 365, Shopify, WooCommerce, Stripe, QuickBooks, Xero, HubSpot, Pipedrive, Slack and Twilio
- Native modules for OpenAI, Anthropic and other model providers, plus an agents feature, so AI steps sit inside the same canvas
- Scenario blueprints export as JSON, which gives you a real backup and a portable record of your logic
Limitations
- Credit billing punishes complexity: every module you add multiplies by every run, so the cost of a workflow is a function of its diagram
- Core, Pro and Teams all ship the same 10,000 credits, which surprises people who upgrade expecting headroom and get features instead
- Large scenarios become visually unmanageable - the canvas that sells the product stops helping past roughly thirty modules
- Tracing a failure means stepping through execution history bundle by bundle, and re-running a partial scenario is fiddly
- Polling triggers burn credits on every check even when there is nothing to process, which is a quiet, permanent drain
- The 15-minute minimum interval on the free tier makes it unusable for anything time-sensitive, so the real entry price is $9
Make pricing
Make meters credits, where most individual module actions consume one credit; routers and error handlers are free. Published pricing as of August 2026: Free at $0 with 1,000 credits a month, two active scenarios and a 15-minute minimum interval; Core at $9 a month or $108 a year with 10,000 credits and unlimited scenarios at a 1-minute interval; Pro at $16 a month or $192 a year; Teams at $29 a month or $348 a year; Enterprise custom. Annual billing saves about 15 percent. Note that Core, Pro and Teams all include the same 10,000 credits - the higher tiers buy priority execution, custom variables, team roles and shared templates, not more capacity. Extra credits are purchased separately.
| Plan | Price | What you get |
|---|---|---|
| Free | $0 | 1,000 credits/mo, 2 active scenarios, 15-minute minimum interval (as of Aug 2026) |
| Core | $9/mo | 10,000 credits/mo, unlimited scenarios, 1-minute interval ($108/yr) |
| Pro | $16/mo | Same 10,000 credits, plus priority execution and custom variables ($192/yr) |
| Teams | $29/mo | Same 10,000 credits, plus team roles and shared templates ($348/yr) |
| Enterprise | Custom | Custom credit volume, 24/7 support, custom functions |
Pricing reflects public plans as of August 6, 2026 and can change. Check Make for the latest.
What people actually build with Make
Make is the tool people reach for when the automation has shape to it - branches, loops, a bundle of line items that needs splitting apart. Here is what that looks like in practice.
Inbox triage with a router. A Gmail watch module picks up new mail, an OpenAI module classifies it, and a router sends each class down its own path: quotes to a HubSpot deal, invoices to a Google Sheet, everything else to an archive label. Routers cost no credits, so the branching itself is free and only the modules on the taken path bill.
Order-to-fulfilment for an ecommerce business. A Shopify webhook fires on a new order, an iterator splits the line items, each item is checked against inventory in Airtable, and a single aggregated pick list goes to the warehouse by email. This is the case Make handles that simple trigger-action tools cannot handle at all, and it is also the case that eats credits fastest, because the iterator multiplies everything downstream of it.
Quote follow-up for a cleaning company. A new quote in the job system triggers a scenario that waits three days, checks whether the quote has been accepted, and if not sends a templated follow-up, then repeats once more at day seven before marking it dead. Two thirds of the modules in that scenario are checks that usually do nothing, which is exactly the pattern to model before you build.
Review requests for a salon. A completed appointment triggers an SMS via Twilio asking for a Google review, with a filter that excludes anyone who has been asked in the last ninety days. The filter is the cheap part and the reason the scenario is not annoying.
Invoice chasing for an accounting firm. A nightly job reads overdue invoices from QuickBooks or Xero, groups them by client with an aggregator, and sends one summary email per client rather than one per invoice. The aggregator is what turns a spammy automation into a professional one.
What Make is genuinely bad at: high-frequency polling and anything step-heavy at volume. A trigger checking an inbox every minute burns credits roughly 43,000 times a month whether or not anything happened, and a fifteen-module scenario running a few thousand times is a five-figure credit bill. Make is also cloud-only, with no self-hosting and no data-residency control, so any commitment you have made about where customer records physically sit rules it out regardless of price.
Bottom line: Make is the right tool when an automation has branches, iterators or aggregators in it, and the wrong one when the same automation has to run at high frequency, because the meter counts modules rather than runs.
What Make actually costs at small-business volume
Take the same workload we price everywhere on this site: a lead-handling automation that fires 2,000 times a month and takes about six module actions per run. In Make's own unit that is roughly 12,000 credits. Core, Pro and Teams all include 10,000. So the honest answer is that this single automation does not fit any published Make tier, and you are buying a credit top-up in month one. That is not a criticism of the product - it is the arithmetic of a per-step meter, and it is exactly why credits vs tasks vs operations is the first thing to settle before you choose a platform.
Turn the same numbers around and Make looks excellent. Three light automations at two or three modules each, running a few hundred times a month, sit inside Core's $9 comfortably and would cost more on most competitors. Make's entry price is genuinely the cheapest credible one in the mainstream category as of August 2026. The rule of thumb that survives contact with reality: Make is cheap while your scenarios are small, and gets expensive in direct proportion to how many boxes you drew.
Two allowance details that decide real bills and are not on the price line. Credits expire - monthly plans lose the unused balance each month, while annual subscribers keep credits for 12 months, which makes annual materially better value for a business with seasonal spikes. And there are hard data ceilings per plan: a 5 MB maximum file size and 512 MB of data transfer on Free, rising to 100 MB files and 5 GB transfer on Core, 250 MB on Pro and 1,000 MB on Enterprise as of August 2026. If your automation moves PDFs, recordings or images rather than rows, that file-size cap will bite you before the credit allowance does.
| Tier | Monthly price | Credits included | Active scenarios | Min interval | Max file size |
|---|---|---|---|---|---|
| Free | $0 | 1,000 | 2 | 15 minutes | 5 MB |
| Core | $9 | 10,000 | Unlimited | 1 minute | 100 MB |
| Pro | $16 | 10,000 | Unlimited | 1 minute | 250 MB |
| Teams | $29 | 10,000 | Unlimited | 1 minute | 500 MB |
| Enterprise | Custom | Custom | Unlimited | 1 minute | 1,000 MB |
The unit is called credits now, and the plan names have moved before
Make renamed its billing unit from operations to credits, and its own pricing page states plainly that credits are the billing unit as of the changeover date. The mechanics did not change: most module actions consume one credit, routers and error handlers consume none, and some AI-provider features consume more than one. If you are reading a comparison written before the rename that talks about operations, the arithmetic still holds - only the noun moved.
The plan names and prices have also moved under people's feet more than once, which is why every figure here carries a date. As read on make.com/en/pricing on 2026-08-06, in US dollars with no currency selector on the page: Free at $0 for up to 1,000 credits, two active scenarios and a 15-minute minimum interval; Core at $9 a month for 10,000 credits; Pro at $16; Teams at $29; Enterprise custom quoted. Annual billing is advertised as saving 15 percent or more, though the page does not render the resulting annual totals. Teams at $29 is worth calling out specifically, because it has been widely and wrongly reported at $99.
The data ceiling that scales with your credits
One detail that is easy to misread on the comparison table: data transfer is not a flat per-plan number. Make's page states that allowed usage scales proportionally at 5 GB of data transfer per 10,000 monthly credits. So buying more credits buys more transfer in the same ratio. Maximum file size does not scale that way and is fixed per tier - 5 MB on Free, 100 MB on Core, 250 MB on Pro, 500 MB on Teams, 1,000 MB on Enterprise as of 2026-08-06. If your scenario handles a single large PDF or an audio file, that fixed ceiling is the one that will stop you, and no amount of extra credits moves it.
Bottom line: Core, Pro and Teams all include the same 10,000 credits at $9, $16 and $29 a month, so moving up a tier buys features and seats and never buys capacity.
The pricing gotcha: polling, and the tier that adds no capacity
The first gotcha is that upgrading does not buy you room. Core, Pro and Teams all ship the same 10,000 credits as of August 2026; the extra money buys priority execution, custom variables, full-text log search, team roles and template sharing. People hit a volume ceiling, click the obvious button, pay 78 percent more and hit the identical ceiling. If your constraint is volume, the answer is a credit top-up, not a tier.
The second is polling. A trigger set to check an inbox or a spreadsheet every minute consumes credits every minute of every day whether or not anything happened, which is roughly 43,000 checks a month from one idle trigger. Use webhooks wherever the source app supports them, and lengthen the interval everywhere it does not. This is the single most common reason a Make bill is four times what someone modelled.
The third is more subtle: loops multiply. A scenario that fetches 200 rows and then runs four modules against each row is 800 credits per execution, not five. Iterators and array aggregators are what make Make powerful compared with simple trigger-action tools, and they are also where a scenario silently becomes the most expensive thing in your account. Before you build anything with an iterator in it, multiply the expected batch size by the modules downstream of it and look at that number honestly.
A fourth that catches people at renewal: the free tier's 15-minute minimum interval makes it useless for anything a customer is waiting on, so the real entry price to this platform is $9 rather than $0. Model your budget from Core, not from Free.
Bottom line: One polling trigger checking every minute consumes around 43,000 credits a month doing nothing, which is more than four times the entire Core allowance before a single useful action runs.
What breaks in production, and how you find out
Make's most important production concept is one most users meet by accident: incomplete executions. When a scenario errors, Make can store the run's blueprint and log so you can fix and resume it rather than lose the data. Every organisation has a maximum storage size for those, set by plan, and there is a setting that decides what happens when it fills. Choose one way and Make keeps running the scenario while dropping new incomplete executions - the option is named, with admirable bluntness, for enabling data loss. Choose the other and Make disables the scenario entirely until you clear the backlog. Neither is a good surprise. Decide which you want deliberately, and put a human on the incomplete-executions queue weekly, because both settings fail silently from the outside.
Resolved incomplete executions are deleted automatically after 30 days, or 60 on Enterprise, and general execution history follows the same retention: 7 days on Free, 30 days on Core, Pro and Teams, 60 days on Enterprise as of August 2026. If you need an audit trail longer than a month, Make is not your system of record and you should be writing your own log to a database or a sheet as a step in the scenario.
Rate limits show up in two different places and it is worth keeping them apart. Downstream APIs rate-limit you - a scenario hammering a CRM will start collecting 429s, and Make's guidance is to slow the scenario down or queue the work. Separately, Make's own API is capped by plan: 60 requests a minute on Core, 120 on Pro, 240 on Teams and 1,000 on Enterprise as of August 2026, returning a 429 with an organisation-limit message when you exceed it. You can read your own organisation's exact limit from the API's organisation endpoint rather than trusting the table.
One limit we could not verify: Make's help centre was not publicly readable when we checked in August 2026 - it returns a 403 to automated requests - and community threads discuss a maximum scenario runtime measured in tens of minutes for long-running or rate-limited scenarios. Treat that as a community-reported figure and confirm the current number in Make's live documentation before you design anything that runs for a long time in one pass. The safer pattern regardless is to break long jobs into batches triggered by a queue rather than one heroic execution.
The failure mode nobody designs for: the half-finished run
A scenario that writes to three systems and fails at the second leaves your data in a state no single system knows is wrong. The invoice exists, the CRM says the deal is open, and the customer got no email. Make will not clean that up for you and the incomplete-execution queue only helps if somebody looks at it.
The fix is design rather than configuration. Put the write that is hardest to undo last. Give every scenario an explicit error route rather than the default stop-and-email. Where an action can be safely repeated, make it repeatable and let it retry; where it cannot, add duplicate protection by checking for the record before creating it. None of this is Make-specific, but Make's ability to build long scenarios makes it easier to build long scenarios that fail halfway.
The scenario that becomes unreadable
The canvas is the reason to buy Make and it stops helping at roughly thirty modules. Past that, the person who inherits the scenario cannot safely change anything, which in practice means it never gets changed and slowly stops matching the business. The habit that prevents this is to split by responsibility: one scenario per outcome, calling each other over webhooks, rather than one scenario that does everything. It costs a couple of extra credits per run and it is the difference between a system and an artefact.
Bottom line: The setting that decides whether a full incomplete-executions store silently drops runs or disables the scenario outright is one most Make users have never opened, and both outcomes are invisible from outside.
What it connects to that you already run
Connector breadth is Make's second-best argument after the canvas. The small-business stack is covered thoroughly: Google Workspace and Microsoft 365 across mail, sheets, drive and calendar, Slack, HubSpot, Pipedrive, Salesforce, Shopify, WooCommerce, Stripe, QuickBooks, Xero, Airtable, Notion, Mailchimp, Twilio, WhatsApp Business and the common SQL databases. AI is native rather than bolted on, with modules for OpenAI, Anthropic and other providers plus Make's own agents feature, so a model call sits in the same scenario as the CRM write.
Where Make is genuinely stronger than the simpler trigger-action tools is data shape. Iterators, aggregators, array mapping and text parsing are first-class, which means Make can handle the messy middle - a webhook that arrives as one blob containing twelve line items, for instance - without dropping to code. When nothing native exists, the HTTP and webhook modules call any REST API, and Make's custom-app framework lets a developer package a private integration properly rather than gluing HTTP modules together.
The gap worth checking before you commit is the long tail. If your business runs on a trade-specific job system, a regional accounting package or a practice-management product, verify by name that a module exists and that it exposes the specific action you need. Zapier's catalogue is meaningfully deeper in that tail, and that single fact decides the platform choice more often than price does.
Bottom line: Make handles data shape - iterators, aggregators, array mapping - better than any simple trigger-action tool, which is why it survives the messy webhook that arrives as one blob of twelve line items.
Make alternatives: what to pick instead, and when
Make's weakness is one number: credits are consumed per module action, so cost is a function of the diagram rather than the work. Every alternative below is really a different answer to that one design decision, so run the shared reference workload through each and pick on the arithmetic.
Pick n8n instead the moment your scenarios get long or your volume gets high. It bills one execution per whole run, which means the reference workload is 1,000 billable units on n8n against roughly 5,000 on Make, and the gap widens with every module you add. You need someone technical, and you get the option to self-host on your own infrastructure, which Make cannot offer at any price.
Pick Zapier instead only for catalogue reasons. It is more expensive than Make at every volume we can compare - $89 a month billed annually for the reference workload against $9 - and its logic handling is weaker. The one thing it does better is support the obscure app your trade depends on, and if that is your binding constraint then it is worth the premium and nothing else on this page matters.
Pick Activepieces instead if you want Make's approachability without the per-step meter. A flow run costs one credit regardless of step count, the community edition is MIT-licensed and free to run yourself, and the builder is close enough to Make's model that the transition is short. The catalogue is much thinner, which is the reason most people do not.
Pick Pipedream instead if you have a developer. Compute-time billing makes fast multi-step workflows extremely cheap, and code steps handle transformations that would be twelve modules on a canvas. You give up the visual builder that is the entire reason to like Make, so this is a change of philosophy rather than a swap.
And if what you actually want is the outcome rather than the diagram, that is what Autonoly is aimed at - you describe the job in plain English instead of assembling every module. Workato and Power Automate are the two other names that come up in this conversation; both are worth a look if you are already inside a Microsoft estate or buying at enterprise scale, and neither is priced for a small business.
| Platform | Billing unit | Reference workload | Realistic monthly cost | Suits | Does better than Make |
|---|---|---|---|---|---|
| Make | 1 credit per module action | ~5,000 credits | $9 on Core (10,000 credits included) | Non-technical builder, visual logic | - |
| n8n | 1 execution per whole run | 1,000 executions | 20 EUR (~$23) on Starter, or ~$15 hosting self-hosted | One technical owner, data control | Step count does not affect price; self-hosting |
| Zapier | 1 task per successful action | ~5,000 tasks | $89 annually, $133.50 monthly on Professional | Obscure app, no technical staff | Connector catalogue breadth |
| Activepieces | 1 credit per run, 2-20 per AI call | 1,000 run credits plus AI credits | $20 on Plus, or ~$15 hosting self-hosted | Open source with a simple builder | MIT licence, per-run billing, MCP |
| Pipedream | 1 credit per 30s compute at 256MB | ~1,000 credits if runs finish inside 30s | Plan prices not published | Developers wanting managed OAuth | Code steps, cost of fast multi-step work |
Bottom line: The same 1,000-item inbox triage is roughly 5,000 credits on Make and 1,000 executions on n8n, so Make wins on price while scenarios are short and loses steadily as they lengthen.
Migration and lock-in: can you get your work out?
You can export any scenario as a blueprint in JSON, and you should, on a schedule. It is a real backup: the modules, their settings, the mapping and the routes are all in there, and re-importing it into another Make account reconstructs the scenario. Make also exposes a documented API - available from Core upward as of August 2026, authenticated with an API token or OAuth 2.0 - covering scenarios, hooks, connections, data stores and audit logs, so scripted export of your whole account is possible rather than theoretical.
The limit is that a blueprint is portable to Make and nowhere else. No other platform imports it. What you actually own is a human-readable description of your logic, which is worth a great deal when someone rebuilds it elsewhere and worth nothing to a machine. Connections are not included in the export either, so credentials get re-authorised by hand, and anything held in Make data stores needs exporting separately.
If leaving is a live concern, the two things that cut the cost of it are boring and effective: keep the business rule written in plain English next to the scenario, and avoid pushing state into Make data stores that has no home in your own systems. A scenario you can describe in a paragraph is a scenario somebody can rebuild in a day.
The structural exposure to be clear-eyed about is that Make is cloud-only. There is no community edition, no self-hosted build and no data-residency control, so if the company changes its pricing you have no version to keep running. That is the single thing an open-source alternative gives you that no amount of blueprint exporting replaces.
Bottom line: Blueprints export as JSON and import into Make and nowhere else, and because Make is cloud-only with no self-hosted build, a pricing change is something that happens to you rather than something you can sit out.
Make FAQ
What does Make cost for a real small-business automation?
Cheaper than most to start and harder to predict as you grow. As of August 2026, Core is $9 a month for 10,000 credits. The number that decides your bill is steps multiplied by runs: a six-step automation running 2,000 times a month is about 12,000 credits, which is already past every published tier's included allowance and means buying extra credits. Two or three light automations fit comfortably inside $9. One busy automation with a dozen modules does not.
What exactly is a credit in Make?
One action performed by one module - reading a record, searching, creating, updating, transforming or aggregating data. Make's documentation notes that most actions consume one credit, and that routers and error handlers consume none. The unit was previously called an operation and the mechanics are the same. The practical consequence is that a scenario's cost is visible in its diagram: count the modules on the path a typical run takes, multiply by expected runs, and you have your monthly credit consumption before you build anything.
Why do Core, Pro and Teams all include 10,000 credits?
Because on Make's published pricing as of August 2026, the higher tiers sell capability rather than capacity. Pro at $16 adds priority execution and custom variables; Teams at $29 adds team roles and shared templates. If what you actually need is more runs, upgrading tiers does not help - you buy additional credits instead. This trips people up regularly, so decide separately whether your constraint is volume or features, and do not assume the next tier up solves a volume problem.
What goes wrong with Make in production?
Polling triggers quietly eating credits when nothing is happening is the most common one, and it is invisible until the bill arrives - use webhooks wherever the source app supports them. Second is scenario sprawl: a canvas past about thirty modules stops being readable, and the next person to touch it cannot safely change anything. Third is partial failures midway through a run leaving records half-updated, which is why any scenario touching a CRM or an invoice needs explicit error routes rather than the default stop-and-email.
Who is Make genuinely wrong for?
Anyone whose workload is high-frequency or step-heavy. If you are processing every row of a spreadsheet nightly, polling an inbox every minute, or running a fifteen-module pipeline thousands of times, per-credit billing will cost multiples of what a per-execution or per-compute-second tool charges for identical work. It is also wrong for teams that need self-hosting or on-premises data handling, since Make is cloud-only with no self-hosted edition.
How hard is it to migrate off Make later?
Moderately hard, and the difficulty is in the details rather than the shape. You can export a scenario blueprint as JSON, which preserves your logic in a readable form, but no other platform imports it - so a migration means a human reading the blueprint and rebuilding it elsewhere. Data mappings and Make's expression functions are the fiddly part. The mitigation is unglamorous: document what each scenario is supposed to achieve in plain language alongside the build, so a rebuild starts from intent rather than reverse-engineering.
Can Make build AI agents?
Yes. Make ships native modules for OpenAI, Anthropic and other providers plus an agents capability, so a scenario can call a model, act on its output and branch on the result. The cost note matters here: every model call is a module action and therefore a credit, on top of whatever the model provider charges you for tokens. An agent that loops through several tool calls per run can consume a surprising number of credits per outcome, so cap the loop and measure a real week before scaling it up.
Make or Zapier for a small business?
Make is cheaper and far more capable at handling logic; Zapier has the larger connector catalogue and the simpler first-run experience. As of August 2026 Make Core is $9 a month for 10,000 credits against Zapier Professional from $29.99 a month for 750 tasks, so the arithmetic favours Make heavily. Choose Zapier when your deciding factor is that it already supports an obscure app you depend on. Choose Make when your automation has branches, loops or data transformation in it.
Can you build our Make scenarios for us?
Yes. Make is the platform we most often build in for owners who want to keep editing things themselves afterwards, because the canvas is legible enough to hand over. We scope it on a free automation audit, build the scenarios in your own Make account so the subscription and the data stay yours, and hand over blueprints, documentation and a recurring report of what ran and what it saved. If you would rather see the likely cost first, our AI automation cost breakdown sets out what this kind of work typically runs.
Looking at alternatives? Make is the tool we recommend most often to a non-technical owner who wants to build it themselves, because the canvas teaches you how automation thinks. The honest warning is the meter: model your credit consumption before you commit, because the number that matters is steps multiplied by runs, not runs. On lock-in, you can export scenario blueprints as JSON, which is a genuine backup, but they only import into Make - the logic is portable in the sense that a human can read it, not in the sense that another tool can run it. Autonoly aims one level up: you state the goal instead of drawing every module, which suits people who care about the outcome more than the diagram. See the Autonoly review.
