Make.com (formerly Integromat) Pricing: Current Plans, Explained

If you searched for "Integromat pricing" and keep landing on pages that say Make.com – you're in the right place: Integromat was renamed Make.com in February 2022, and it's the same product under a new name. That's why the pricing looks nothing like what you remember – the old Integromat plans are gone, and this page walks you through what Make actually charges today.

Last updated: 27 July 2026. Prices checked on make.com/en/pricing on that date.

Make.com pricing at a glance (as of July 2026)

Make currently sells five plans: Free, Core, Pro, Teams and Enterprise. The prices below are the listed USD prices on Make's international pricing page for the entry tier of 10,000 credits per month – a slider lets you buy more (up to 8 million+), and the price scales with the volume. All prices shown here are the annual-billing rate, i.e. the per-month price you pay when you commit to a year; paying month to month costs noticeably more (Make advertises 15 % or more saved on annual). Make lists prices in USD only; if you're billed in another currency, the exact figure on your checkout page is the one that counts.

Free – $0

Up to 1,000 credits per month, a maximum of 2 active scenarios, runs no more often than every 15 minutes, and each run may last at most 5 minutes. Who it fits: trying Make out and running one or two small personal automations. Not enough for anything a business depends on.

Core – from $9/month (billed annually)

10,000 credits per month at the entry tier, unlimited active scenarios, 1-minute scheduling, up to 40 minutes per run, files up to 100 MB. Who it fits: solo operators and small businesses running their first real automations – this is where most people should start paying.

Pro – from $16/month (billed annually)

Everything in Core, plus priority scenario execution, larger files (up to 250 MB) and full-text execution log search. Who it fits: businesses whose scenarios are process-critical – when a delayed run costs you money, priority execution is what you're paying for.

Teams – from $29/month

Everything in Pro, plus teams and roles (shared workspaces, permissions) and files up to 500 MB. Who it fits: several people building and maintaining scenarios together – the plan is about collaboration, not more horsepower.

Enterprise – custom pricing

Files up to 1,000 MB, 60 days of execution log storage, and the usual enterprise layer (talk-to-sales pricing). Who it fits: large organisations with compliance and scale requirements.

Credits, not operations: how Make's billing actually works

Here's the second rename that trips people up – and most pricing articles out there still get it wrong. If you've read older Make or Integromat guides, you know the billing unit "operations". Operations no longer exist: since 27 August 2025, Make bills in credits. The bridge is simple: one action – what used to be one operation – still costs exactly one credit. For classic scenarios, only the word changed, not your bill.

So why rename at all? Because you can now run AI models directly inside Make – and AI usage is measured in tokens, which don't come in neat whole steps. That's why credit charges can be fractional, uneven numbers, where old operations were always whole ones. Classic actions still consume one credit each; AI actions consume credits by token, at published rates – the next section shows exactly how, because that's where the real money sits.

The practical consequence: your scenario design decides your bill, not the plan you picked. A classic scenario with 4 modules that runs 100 times a day consumes roughly 400 credits a day (one per action) – about 12,000 a month, already past the entry tier of a paid plan. The same business outcome, built leaner, can cost a fraction of that. The three leaks we see most often in client accounts:

• Polling instead of webhooks. A scenario that checks for new data every minute pays for every check – including the thousands of runs that find nothing. An instant trigger (webhook) only runs when something actually happens.
• Filtering too late. If your filter sits at module 4, modules 1–3 have already consumed credits for records you were going to throw away. Filter as early in the scenario as possible.
• Processing records one by one. Handling items individually when they could be aggregated and processed in batches multiplies your runs – and your credits.

This is the part most pricing pages skip, and it matters more than the difference between $9 and $16: a well-designed scenario on Core is routinely cheaper than a wasteful one on Pro.

AI in your scenarios: where credits really go

As soon as a scenario calls an AI model, billing switches from counting actions to counting tokens – the units AI models read and write text in. Make's rule of thumb: in English, 1 token is around 4 characters, and 100 tokens are about a paragraph. After a run, you can see the tokens a module consumed in its output bubble – worth checking before a scenario goes into daily production. Make publishes exact token-per-credit tables in its credits documentation; the figures below are from that page, retrieved 27 July 2026.

Make's own AI Provider (the built-in connection, no API key needed) comes in three tiers:

Other models are billed per token too, with separate rates for input (your prompt) and output (the answer). The Anthropic rows show the spread best:

(OpenAI models have their own rows in the same table on Make's page.)

Read that table again: the model you pick is a cost decision, not just a quality decision. A worked example – our assumptions, not Make's, but using Make's published rates: say your scenario sends a ~2,000-character prompt (≈ 500 tokens in) and gets a ~1,000-character answer (≈ 250 tokens out). With Haiku 4.5 that's 500 ÷ 904 + 250 ÷ 181 ≈ 2 credits. The identical call with Fable 5 is 500 ÷ 90 + 250 ÷ 18 ≈ 20 credits – ten times the cost. On a 10,000-credit plan, that's the difference between thousands of such calls a month and hundreds. Redo the arithmetic with your own prompt sizes; the ratios are what matter, and they come straight from Make's table.

And the lever almost nobody writes about: connect your own AI provider account instead of Make's automatic connection. Make's documentation is explicit – with the automatic connection you pay credits based on tokens, operations and other usage factors; with your own (custom) provider connection, available on paid plans, Make charges credits for operations only, and you pay your AI provider directly for the tokens. To be clear, that doesn't make tokens free – you've moved the cost to your OpenAI or Anthropic bill, at their prices. But it turns a token-hungry AI call into a one-credit action on the Make side, and for heavy AI use it changes the maths completely: your Make plan stops being the bottleneck for how much AI you can run.

What changed since Integromat

Short and factual:

• February 2022: Integromat became Make.com – new name, new interface, same underlying platform.
• The old Integromat plans (Basic, Standard, Business, Platinum) were retired. Today's structure is Free, Core, Pro, Teams and Enterprise – the Teams layer (shared workspaces and roles) had no direct equivalent in the old lineup.
• August 2025: the billing unit changed from operations to credits. One action still equals one credit; the new unit exists because AI usage inside Make is billed in variable (fractional) amounts that the old whole-number operations couldn't express.

If you're following an old Integromat tutorial: the building blocks (scenarios, modules, triggers) work the same way. Only the prices and plan names on that tutorial's screenshots are history.

Which plan should you pick?

We're an automation agency – we'd earn nothing by talking you into a smaller plan. Here's our honest advice anyway, and it happens to favour the cheaper one:

• Default to Core. For most businesses, Core is enough: unlimited scenarios, 1-minute scheduling, 10,000 credits to start. Don't buy Pro "to be safe" – upgrade when something actually bites.
• Move to Pro when a limit bites – or for one specific feature. The honest upgrade reasons: a delayed run costs you money (priority execution), you hit the 100 MB file ceiling – or you need full-text execution log search, which Make lists as a Pro-and-up feature. It lets you search your scenario execution history to find and troubleshoot individual items. No pricing page explains why that matters, so we will: once business-critical scenarios run daily and one record goes missing, that search is how you find it – in our client work, it's the feature that most often ends up pushing a team from Core to Pro.
• Teams when several people build together. Shared workspaces, roles, permissions. It's about collaboration, not horsepower – below that team size, it buys you nothing over Pro.
• Free is for trying out. 1,000 credits is enough to test-build, not enough to run a business on.

Want to find out without committing to anything? Through our partner link you start on the Pro plan with 10,000 credits, free for one month. That's genuinely enough time and credits to build a real scenario or two and see whether Make fits your business – and you don't have to decide anything up front: if you do nothing, you're automatically moved to the Free plan when the month ends. No cancellation needed, no card trap.

Transparency: This is a referral (affiliate) link. If you use it, we may earn a commission – the price you pay stays the same.

When the plan isn't the real question

Once you're automating processes your business actually depends on, the tier price stops being the interesting number – a badly designed process burns more money in credits and missed automation than any plan difference ever will. Designing lean, reliable automations is what we do; the plan comparison above you can now handle yourself.