Make.com

What Make Does

Make is a visual automation platform. You build a scenario on a canvas, connect modules that each represent an action in some external service, and data flows from one module to the next. The vendor lists "3,000+ Integration Apps", covering AI providers, CRM and ERP systems, communication tools, commerce and payments, marketing platforms, project management, file storage and databases. For anything without a pre-built connector there is a generic HTTP app, so any service with an API is reachable.

The canvas is the differentiator. Where a linear automation tool shows you a list of steps, Make shows you a diagram, which is why it tends to be the choice for people whose workflows branch, loop and merge rather than run straight through. If your automations are mostly one trigger and one action, a simpler linear tool will feel faster to set up. If you are routing based on conditions, iterating over collections and re-aggregating results, the visual model stops being decoration and starts being how you understand the thing you built.

How a Scenario Actually Runs

Understanding the execution model is what separates people who are happy with Make from people who are confused by it. The documentation explains that a scenario "begins with the first module responding to an event", and that if this first module returns no bundles then "the scenario does not continue and ends after the first module". A bundle is a unit of data.

Bundles then move through the scenario one at a time rather than in parallel. The docs give a concrete example: "If Facebook returns multiple bundles, for example two bundles, the processing of the latter bundle will not start until the first bundle is converted and uploaded to Dropbox." Each bundle passes through a four-step transaction of "initialization, operation, commit/rollback, and finalization", which is the mechanism that lets Make roll back cleanly when a module fails partway through a batch.

Operations and Credits

Make meters usage rather than seats, and the unit is worth understanding precisely because it determines your bill. The documentation defines it plainly: "an operation is a single module run to process data or check for new data." Each bundle a module handles is its own run. The examples given are unambiguous, that "the gmail > send an email module sends 5 emails = 5 operations (one per email)" and "the google drive > upload file module uploads 3 files = 3 operations (one per file)".

There is a useful exception. Trigger modules "only run once to check for or retrieve data, regardless of the number of bundles returned", so polling for new records is cheap no matter how many arrive. Billing then converts operations to credits, and for standard apps the conversion is fixed: "by default, 1 operation equals 1 credit", and "that rate is constant regardless of input or data transfer size". Sending a large file costs the same as sending a small one.

AI features work differently and the docs are clear about it. Credit consumption there is dynamic, where "The most common factor affecting credit usage is token consumption". When you call an external provider such as OpenAI or Anthropic Claude through Make, "you pay for credits based on operations and your ai provider for tokens", so budget both lines rather than one.

Because the meter is volume-based, Make fits workloads you can estimate. If your throughput is steady and predictable, this pricing shape is efficient, since you pay for automation that actually runs rather than for a seat that might. If your volume spikes unpredictably, the documented options are to upgrade the subscription, buy extra credits, or enable automatic extra credit purchasing so a busy day does not stall a scenario mid-run.

Pricing, checked August 2026

Free is $0 with up to 1,000 credits per month and a minimum scheduling interval of 15 minutes. Core is $9 per month with 10,000 credits and a one-minute minimum interval. Pro is $16 per month, Teams is $29 per month, and both start from the same 10,000 credit base with the one-minute interval. Enterprise is custom. Annual billing is advertised as saving 15 percent or more.

That structure means the paid tiers separate on capability rather than on volume, with credit capacity purchased alongside. Core buys you the one-minute schedule and the automation itself. Pro adds custom variables, full-text execution log search and high-priority scenario execution, which is the tier at which debugging a large estate stops being painful. Teams adds team roles, Make Grid and priority execution. Enterprise adds custom functions, enterprise app integrations, an on-premises agent, 24/7 support and value engineering.

Read that ladder as a description of team size rather than a set of gates. A solo operator running a handful of scenarios genuinely does not need full-text log search. An agency maintaining a hundred scenarios across client accounts genuinely does, and that is precisely who Pro and Teams are drawn for.

Who It Suits

Make suits operators whose workflows have shape: conditions, loops, branches, and several systems that must agree with each other. It suits agencies and technical marketers who want to see the whole diagram at once. The 15-minute minimum interval on the free plan makes that tier an evaluation environment rather than a production one, and anything near real time starts at Core.

If your integrations are simple one-to-one connections, a linear automation tool will be quicker to configure. If the data you are moving already lives inside one platform, an in-app automation layer such as the one in Airtable may be enough without adding a vendor. Make earns its place when the logic is genuinely multi-step and you would rather maintain a diagram than a pile of scripts.

Is Make the Right Automation Layer?

Automation tools sort themselves by the shape of the work, not by the length of their integration lists. Make is the visual option. You build a scenario as a diagram, with branches, loops and merges laid out in front of you, and that model is either what you want or more than you require.

If your automations are one trigger and one action, a linear tool will be quicker to configure and easier to hand over. If the data never leaves one platform, the automation features already built into something like Airtable may cover it without adding a vendor. Make earns its place when the logic branches, when several systems have to agree, and when you would rather look at a diagram than read a list of steps. Coverage is not the constraint either way: the vendor lists more than 3,000 integration apps, and anything else is reachable through the HTTP module.

How the Pricing Works, and Who It Fits

Make bills by how much automation runs rather than by how many people hold a login. The unit is an operation, a single module run, and each item of data a module handles counts as one, so sending five emails is five operations. For standard apps the rate is fixed at one credit per operation regardless of payload size, so a large file costs the same as a small one. Trigger modules consume only one operation no matter how many records they return, which keeps polling cheap.

That shape suits workloads you can estimate: you pay for work performed rather than for headcount. If your volume spikes unpredictably, the documented answer is to upgrade, buy extra credits, or switch on automatic extra credit purchasing so a busy day does not stall a scenario.

Checked August 2026, Free is $0 with up to 1,000 credits per month and a 15-minute minimum scheduling interval, which makes it an evaluation environment. Core is $9 per month with 10,000 credits and a one-minute interval. Pro is $16 and Teams is $29 from the same 10,000 credit base, with annual billing advertised at 15 percent or more off. The paid tiers separate on capability: Pro adds custom variables and full-text execution log search, Teams adds team roles.

The Verdict

Make is the strongest choice for multi-step, branching automation where you want to see the whole picture. Start on Free to build the diagram, move to Core when you need the schedule to run every minute, and climb to Pro when debugging becomes the bottleneck.