Skip to main content
RapidDev - Software Development Agency
Platform review30 min read

Make (ex Integromat)

Make, formerly Integromat, is the best-value hosted automation platform for complex multi-step workflows in 2026. With a visual scenario canvas and credits starting at ~$10.59/mo for 10,000 credits — versus ~$300/mo on Zapier for equivalent operations — it delivers serious power at a fraction of the cost. The credit model requires active monitoring, and the hard 40-minute execution timeout is a real architectural ceiling. Score: 7.3/10.

4.9Clutch rating
600+Happy partners
17+Countries served
190+Team members
7.3/10

Platform review

The best-value hosted automation platform for multi-step complex workflows — powerful visual canvas at a fraction of Zapier's price, with the strongest credit-per-dollar ratio in the hosted category.

Ease of use7.0
Pricing & value8.5
Scalability7.0
Performance7.5
Ecosystem & integrations8.0
Support & community6.5
Vendor lock-in6.0
AI features8.0
Pricing from
~$10.59/mo (Core, annual)
Free tier
Yes — 1,000 credits/mo, 2 active scenarios
Founded
2012 (as Integromat; rebranded to Make Feb 2022)
Best for
Multi-step data-transformation workflows at low cost

Reviewed July 2026

The verdict

The best-value hosted automation platform for multi-step complex workflows — powerful visual canvas at a fraction of Zapier's price, with the strongest credit-per-dollar ratio in the hosted category.

Our recommendation

Make hits a compelling sweet spot: the visual canvas is powerful enough for serious branching and data-transformation workflows, yet it costs 10–30× less than Zapier for equivalent operation counts. The Aug 27, 2025 switch from 'operations' to 'credits' introduced some pricing complexity, and the 40-minute execution timeout per scenario run is a hard limit teams must architect around. But for technical-ish users and agencies that build discipline around credit monitoring, Make consistently delivers the best dollar-per-operation of any hosted tool in 2026.

Choose it if

You want Zapier-level power at 10–30× lower cost and are comfortable learning a visual canvas and monitoring credit usage.

Avoid it if

You need self-hosting or data-residency control, run high-frequency polling at scale, or require more than 40 minutes of continuous execution per scenario run.

How we review: This review is based on real automation projects built and managed by RapidDev engineers since 2016, cross-referenced with Make's official documentation, community forums (r/Integromat, Make community), published third-party analyses (automationatlas.io, trackstack.tech, mcstarters.com), and help.make.com changelog entries. No affiliate relationship with Make or Celonis — pricing figures should be verified at make.com/en/pricing before purchase, particularly given the Aug 2025 billing model change and ongoing platform evolution.

Scored, dimension by dimension

Strong (8+)Fair (6–7.9)Weak (<6)

Every score is earned — each note explains exactly why.

Ease of use

7.0/10

Make's visual scenario canvas is more intuitive than n8n's node graph for non-coders, but it is distinctly steeper than Zapier's linear builder. The first 2–3 simple scenarios feel approachable; complexity hides under the surface once you layer routers, iterators, and aggregators into a single flow. Credit-awareness adds a layer of cognitive load that Zapier's simpler task-counting does not impose — you need to think not just about workflow logic but about how many credits each module path will consume.

Pricing & value

8.5/10

Make is the cheapest hosted option for complex multi-step workflows — Core at ~$10.59/mo covers 10,000 credits, which maps to the same effective operation count that costs ~$300/mo on Zapier. One agency documented dropping from $129/mo on Zapier to $9/mo on Make Core for more volume (mcstarters.com, anecdotal but representative). The free tier at 1,000 credits/mo and 2 active scenarios is a genuine sandbox, not just a marketing checkbox.

Scalability

7.0/10

Make has no self-host option and hard ceilings that matter at scale: the ~40-minute execution timeout per single scenario run (documented in-product error; one staff post cites 45 min — verify current limit in Make docs) is the architectural wall teams hit on data-migration or long-running export scenarios. Data transfer is capped at 5 GB per 10,000 credits/mo; the webhook queue handles 667–10,000 events depending on plan. At very high credit volumes the per-credit cost approaches what self-hosted n8n on a Hetzner VPS would cost.

Performance

7.5/10

On a managed Celonis-backed infrastructure Make is reliable for standard workloads; teams rarely report outages in the way they do SQLite corruption on self-hosted n8n. The documented constraints are structural rather than stability-related: the 5 MB file-size default on free-tier modules, per-plan concurrency limits (not officially published but community-confirmed via rate-limit behavior), and priority execution queue reserved for Pro+ plans. For time-sensitive workflows, the lack of a published per-plan concurrency guarantee is worth confirming with Make's sales team before committing.

Ecosystem & integrations

8.0/10

Make offers 3,000+ apps as of 2026, including ~1,000+ Make-built standard apps, 350–400+ AI-specific app integrations, and enterprise connectors for Workday, ServiceNow, and Coupa on higher tiers. Partner and community apps continue to grow. This is roughly 37% of Zapier's 8,000+ catalog, so niche or legacy connectors may require the HTTP module as a workaround — but the HTTP module itself is fully capable for any REST API and does not count extra credits beyond the module call itself.

Support & community

6.5/10

Priority execution queue is reserved for Pro+ plans, meaning Core-tier users can experience slower scenario starts during peak demand. The Aug 27, 2025 switch from 'operations' to 'credits' caused genuine community confusion and invalidated many how-to guides — the community is still working through updated documentation as of mid-2026. Support response is slower on Core/Pro tiers per community feedback; no SLA is available below Enterprise. The community forum and help center are solid, but complex issues on lower tiers can take days to resolve via tickets.

Vendor lock-in

6.0/10

Make scores meaningfully better than Zapier on portability: scenarios are JSON-exportable, giving you a migration path if you need to rebuild on another platform. That said, Make is entirely cloud-resident with no self-host option, and the Celonis parent company is reportedly planning a 2026 IPO (verify via current Celonis announcements) — a public-company context historically introduces pricing and roadmap pressure. The lock-in risk is medium-high: better than Zapier's full proprietary trap, worse than n8n's open-source freedom.

AI features

8.0/10

Make's AI capabilities in 2026 are genuinely strong: Maia (the conversational scenario builder), Make AI Agents (all paid plans; open beta launched Feb 2, 2026 with MCP tools support), an MCP server that makes scenarios callable as tools from Claude, GPT, and Cursor, plus an MCP client, Make Grid, and module-as-tool patterns. The standout transparency feature is that agent reasoning is visible directly on the scenario canvas — unique in the category. The limitation is that AI-native modules consume variable credits per tokens/file/page, making cost estimation harder than standard module usage.

Pros & cons

What we like

  • 10–30× cheaper than Zapier for complex multi-step workflows — Core ~$10.59/mo versus ~$300/mo on Zapier for equivalent 10,000 effective operations
  • Powerful visual canvas with routers, iterators, and aggregators handles complex branching and batch data transformation without any code
  • Per-module credit visibility directly in the canvas — you can see exactly which modules ran and what they cost before and after execution
  • 3,000+ app integrations including enterprise connectors (Workday, ServiceNow, Coupa) on higher tiers and 350–400+ dedicated AI app integrations
  • Make AI Agents (open beta Feb 2, 2026) with MCP tools support — scenarios callable as tools from Claude, GPT, and Cursor via MCP server
  • Scenarios are JSON-exportable, providing genuine portability that Zapier does not offer
  • Generous free tier: 1,000 credits/mo and 2 active scenarios — a real testing sandbox, not a 2-click demo
  • Dedicated error handlers (Rollback, Break, Resume, Commit, Ignore) do not count as credits — production error-handling is cost-neutral

What we don't

  • Hard ~40-minute execution timeout per single scenario run — long-running data exports, migrations, or batch jobs that exceed this limit will fail silently until you architect chunking logic
  • Every module counts toward credits including filters, routers, iterators, and aggregators — a 'simple 3-step' scenario can burn 8–15 credits per run; a 10-item iterator × 100 runs = 1,000 credits per scenario run (trackstack.tech; r/Integromat)
  • A single polling scenario at 1-minute intervals = ~43,200 credits/mo — Core's 10,000-credit baseline consumed by one polling scenario in under 6 hours (automation.md §8)
  • No self-hosting option: all data flows through Make's cloud infrastructure; teams requiring HIPAA certification or data-residency control must look elsewhere (verify compliance posture in Make's trust center before assuming any standard)
  • The Aug 27, 2025 switch from 'operations' to 'credits' invalidated many existing how-to guides and community answers; search results for Make help still surface pre-Aug 2025 content using the old terminology
  • Extra credit packs cost approximately 25% more than in-plan credits (as of Nov 6, 2025, per help.make.com) — sustained overage makes a tier upgrade cheaper than buying packs repeatedly
  • No officially published per-plan concurrency limit — community-confirmed via rate-limit behavior, but you cannot plan capacity from official documentation

Make (ex Integromat) vs the competition

Head-to-head on the aspects that actually decide the choice. The highlighted cell wins each row.

AspectMake (ex Integromat)Zapiern8n
Price @ 10,000 effective ops/mo~$10.59–16/mo Core/Pro~$300/mo (10,000 tasks)€50/mo Cloud Pro or ~$10/mo self-hosted
Free tier1,000 credits/mo, 2 active scenarios100 tasks/mo, 2-step Zaps onlyUnlimited executions (self-hosted Community)
Integrations count3,000+ apps8,000+~400+ nodes + any REST API via HTTP
AI and agent depthHigh — Maia, AI Agents open beta Feb 2026, MCP server/clientHigh — Copilot, Agents GA May 2025, MCPVery high — LangChain, MCP Client built-in, code nodes, human-in-loop Jan 2026
Self-hosting optionNoNoYes — Community Edition free forever
Vendor lock-inMedium-High (JSON export; no self-host; Celonis-managed)High — no export format, US-primary hostingLow — open-source, JSON + Git export
Learning curveModerate-steep (canvas clicks fast but credit model adds complexity)Gentlest in category — linear builder, CopilotSteep — expression syntax, self-hosting
HIPAA/PHI complianceUnverified — verify Make trust center for current compliance postureNo — no BAA; PHI explicitly prohibited (zapier.com/legal/data-privacy)Yes (self-hosted; your certification responsibility)
Execution timeout~40-minute hard limit per scenario runNo published timeout per ZapConfigurable via EXECUTIONS_TIMEOUT env var on self-hosted
Scenario portabilityJSON export availableNo export formatJSON export + Git version control

Swipe the table sideways to see every competitor.

Pricing, for real

Free

$0/mo

1,000 credits/mo, 2 active scenarios, 15-minute minimum polling interval, access to 3,000+ apps. A genuine sandbox for testing — not just a marketing tier — but 2 active scenarios limits real production utility.

Core

~$10.59/mo (annual)

10,000 credits/mo, unlimited active scenarios, 1-minute minimum polling interval, Make API access. The primary tier for individuals and small teams. GATEKEEPER: 10,000 credits sounds generous until a single 1-minute polling scenario consumes them in under 6 hours of runtime.

Pro

~$16/mo (annual)

10,000 credits base, priority execution queue, full-text log search, custom variables. The priority queue is a meaningful upgrade for time-sensitive workflows — Core users queue behind Pro+ on shared infrastructure.

Teams

~$29–34/mo (annual)

Team roles and permissions, AI Agents access, shared templates. AI Agents (open beta Feb 2026) are Teams-tier only — if you want to experiment with Make's autonomous agent capabilities, this is the minimum tier required.

Enterprise

Custom

SSO/SCIM, audit logs, advanced security controls, 24/7 support. The compliance and governance tier — confirm current SOC 2 and HIPAA posture with Make's sales team and trust center documentation.

Hidden costs to budget for

Every module counts credits including filters, routers, iterators, and aggregators — place filters as the FIRST module after the trigger to avoid paying credits on records that will be discarded. A '3-step' scenario that iterates over 10 items can easily cost 15–20 credits per run.

Polling at 1-minute intervals: a single polling scenario = ~43,200 credits/mo. Convert polling triggers to webhooks wherever the source application supports it — this is the single most impactful credit optimization.

Extra credit packs cost approximately 25% more than in-plan credits (Nov 6, 2025, per help.make.com). If you are regularly buying overage packs, upgrading to the next tier is almost certainly cheaper.

AI-native modules consume variable credits based on tokens, file size, or page count — calling external AI APIs via the HTTP module instead keeps your AI spending in your own LLM provider account (usually cheaper) and prevents unpredictable credit consumption.

Value verdict

At ~$10.59/mo for 10,000 credits versus ~$300/mo on Zapier for the same effective operation count, Make's value proposition for complex multi-step workflows is the strongest in the hosted category. The credit model requires active management — filters, polling frequency, and iterator design all affect your burn rate — but teams that build that discipline consistently land at 3–20× lower costs than equivalent Zapier spend. For agencies, the Teams tier at ~$29–34/mo covering team permissions and AI Agents is a strong price anchor for client work.

What it'll cost you

Real monthly cost for three typical profiles — not the headline sticker price.

Solo founder, validation/hobby

$0–10.59/mo

per month

Assumptions

~2,000 credits/mo, simple scenarios, webhook-triggered (no polling), 2–3 active scenarios

Free tier (1,000 credits, 2 scenarios) covers basic use if structured carefully with webhook triggers. Core at ~$10.59/mo handles 10,000 credits comfortably at this volume, with headroom for iteration and testing. Total annual: $0–127/yr versus ~$240/yr minimum on Zapier Professional.

Growing startup, multi-step data processing

$25–35/mo

per month

Assumptions

~25,000 credits/mo, 5–10 active scenarios, mix of webhook and scheduled triggers, some iterator modules

Core base (10,000 credits) plus ~1.5 extra packs at ~$11/10,000 credits = approximately $25–35/mo. Alternatively, step up to Pro (~$16/mo) plus one pack. Compare: equivalent operation count on Zapier would run $100–300+/mo depending on step configuration. The savings compound as step count per run increases.

Agency or high-volume team

$200–500+/mo (estimate)

per month

Assumptions

~500,000 credits/mo, 20+ active scenarios across client accounts, AI-native modules, Teams tier

At this volume, the credit costs start approaching the economics of self-hosted n8n. Teams tier (~$29–34/mo base) plus credit packs for 490,000 additional credits at in-plan rates gets expensive. This is typically the inflection point where architects evaluate Make-to-n8n migration: one documented case moved from $348/mo Make Teams to ~$12/mo n8n on Hetzner VPS (automationatlas.io), accepting ~40% of project time spent on credential and webhook recreation.

From the RapidDev workshop

What we see from teams migrating to and scaling on Make

Teams migrating from Zapier to Make consistently report the same shock in reverse: they expected complexity, found a visual canvas that 'clicks' after 2–3 hours, and immediately saw cost relief. The $129→$9/mo pattern documented in the wild (mcstarters.com) is representative of what agencies and technical founders tell us when they make the switch — the savings are real and front-loaded. The challenge that surfaces later is credit budgeting discipline once scenarios start layering routers, iterators, and AI-native modules.

The Aug 2025 operations→credits rebranding is still causing friction in mid-2026. Teams whose internal documentation said 'this workflow costs 300 operations/mo' had no immediate way to know how credits mapped to the old unit — largely 1:1 for standard modules, but not for AI-native ones. The pattern we see: teams building AI-heavy scenarios in Make hit this billing gap first, typically when an AI module processes a batch of files and the credit charge is 5–10× what they modeled.

The '40-minute timeout' is the other recurring pattern: teams try to migrate a 50,000-row database or run a long data export via a single Make scenario and hit the wall. The architectural fix — chunk the operation using Make's error-handler and scheduling patterns — is not obvious from the canvas UI. Agencies managing Make for multiple clients appreciate the Teams tier's shared-template and role system but hit the absence of per-client project isolation (unlike n8n's project feature); the operational workaround is maintaining separate Make accounts per client.

Our field verdict

Make is the right tool when the priority is Zapier-comparable power at a fraction of the cost — the value proposition is real and well-documented. The credit model and 40-minute timeout require explicit architectural planning; teams that skip that planning hit billing surprises or scenario failures at the exact moment production traffic scales up.

What the community says

Make's community is split between two camps: users who migrated from Zapier and are enthusiastic about the cost savings, and users who were burned by the Aug 2025 operations-to-credits billing change or by credit surprises from polling and iterator-heavy scenarios. The platform has a strong net-positive reputation for value and canvas power, with the credit model being the persistent friction point.

Most common complaints

Operations/credit counting surprises — every module including filters, routers, and iterators counts; a '3-step' scenario can burn 8–15 credits per run

trackstack.tech; r/Integromat; community forumsVery frequent — the top complaint across all Make community channels and comparison sites

The Aug 27, 2025 switch from 'operations' to 'credits' caused confusion about AI module costs; pre-Aug 2025 guides and forum answers are now misleading

alltomate.com; Make community forumsMedium frequency but high recency — still actively causing confusion as of mid-2026 because older search results surface pre-change content

Credit burn from polling scenarios — 1-minute polling exhausts Core's 10,000-credit baseline in under 6 hours of runtime

automation.md §8; community forum polling discussionsFrequent — consistently surfaces in 'Make vs Zapier' and 'Make pricing' threads as a gotcha for new users

Learning curve 'hiding under the surface' — the canvas looks simple until routers and iterators create compounding complexity

eesel.ai; Reddit; community forum onboarding threadsConsistent — described as a baseline expectation rather than a bug; affects users who arrive expecting Zapier-level simplicity

Support response is slower on Core and Pro tiers; priority execution queue reserved for Pro+ creates speed disparity on shared infrastructure

Anecdotal community reports; forum support-wait threadsLower frequency but notable — particularly frustrating when production scenarios queue during peak demand

Most praised

  • Dramatically cheaper than Zapier for complex multi-step workflows — 'dropped from $129/mo Zapier to $9/mo Make Core for more volume' (mcstarters.com) captures the common migration experience
  • Powerful visual canvas with routers, iterators, and aggregators — handles branching and data transformation that Zapier's linear model cannot match without code
  • Per-module execution visibility in the canvas — see exactly which modules ran, how many credits each cost, and what data passed through
  • Generous and genuinely usable free tier (1,000 credits/mo, 2 scenarios) for testing and validation before committing to a paid plan

Deep dive

Visual canvas and editor

The scenario canvas is Make's defining advantage over both Zapier (linear builder) and n8n (developer-leaning node graph). Routers create branching logic visually, iterators handle batch data natively, and aggregators collapse array output back into single bundles — all without writing code. Every module's execution result is visible in the canvas after a run, including exactly how many credits each module consumed. The weakness is that this visual richness creates a false sense of simplicity: a scenario that looks like four boxes on the canvas can be routing through 12 credit-consuming module calls by the time iterators and error handlers are layered in. The documented community experience is that 'complexity hides under the surface' (eesel.ai; Reddit) — this is accurate and worth internalizing before building anything production-critical.

Credit model mechanics (post-Aug 27, 2025)

Make switched from 'operations' to 'credits' on Aug 27, 2025. For standard modules, the mapping is largely 1:1, but AI-native modules consume variable credits based on tokens processed, file pages, or data volume — this is where budget predictability breaks down. The core discipline required: model credit cost before enabling high-frequency triggers or AI-native processing. Filters placed early in the scenario (before any processing modules) eliminate credits wasted on records that would be discarded anyway — this is the single highest-leverage optimization. Extra credit packs cost approximately 25% more than in-plan credits as of Nov 6, 2025 (help.make.com), meaning sustained overage should always trigger a tier upgrade rather than repeated pack purchases.

AI capabilities in 2026

Make's AI buildout is serious: Maia handles conversational scenario building, Make AI Agents (open beta launched Feb 2, 2026) enable autonomous multi-step automation with MCP tools, and the MCP server makes Make scenarios callable as tools from external LLMs including Claude, GPT, and Cursor. The MCP client goes the other direction — Make scenarios can call external MCP tools. The agent reasoning visibility on the scenario canvas is a unique transparency feature: you can see what the agent decided and why, step by step, without leaving the Make UI. The limitation is that AI Agents are Teams-tier only (~$29–34/mo), and AI-native module costs can be hard to predict for budgeting purposes without running a sample batch first.

Integration ecosystem

Make's 3,000+ apps in 2026 cover the core business stack well, including ~1,000+ Make-built standard apps and 350–400+ AI-specific integrations. Enterprise connectors for Workday, ServiceNow, and Coupa are available on higher tiers, which matters for teams in enterprise IT environments. The gap versus Zapier's 8,000+ catalog is real: approximately 37% of Zapier's breadth, meaning niche or legacy SaaS connectors may not have a native Make app. The HTTP module fills most of this gap for any REST API — it is fully capable and costs only the module call credit. Where Make's integration catalog genuinely excels is depth within the apps it does support: native support for Make-specific features like iterators and aggregators on complex API responses sets it apart from thin wrapper integrations.

Error handling and data transformation

Make's error handling is among the most sophisticated in the no-code automation category: dedicated error handler modules (Rollback, Break, Resume, Commit, and Ignore) do not count as credits — production error handling is cost-neutral. Exponential backoff for retries is built in. Scenario-level rate limit controls prevent thundering-herd API failures. The routers, iterators, and aggregators handle complex data transformation natively that would require custom code in simpler tools. The hard constraint is the ~40-minute execution timeout per scenario run — any workflow that needs to process a large dataset, run a migration, or execute a long-running API call in a single pass will hit this ceiling. The architectural response is to chunk operations into batches with a scheduler-triggered loop, but this adds design complexity that teams often don't anticipate until they hit the timeout in production.

Security, compliance, and portability

Make's security posture benefits from Celonis-backed infrastructure with published data security documentation. Enterprise SSO/SCIM and audit logs are available. However, Make's SOC 2 and HIPAA compliance posture was not fully verifiable from primary sources in this research — verify current certifications directly in Make's trust center before making procurement decisions that depend on them. Do not assume SOC 2 Type II or HIPAA BAA availability without primary confirmation. On portability, Make is better than Zapier: scenarios are JSON-exportable, giving teams a migration path. The absence of self-hosting is the deeper constraint for data-residency-sensitive workloads — all scenario execution and data transit runs through Make's cloud infrastructure.

Pricing mechanics compared to Zapier and n8n

The comparison arithmetic is Make's most powerful marketing argument — and it's accurate. At 10,000 effective operations per month, Make Core costs ~$10.59/mo versus ~$300/mo on Zapier. The key is understanding what 'effective operations' means in each system: one Make credit = one module execution; Zapier counts each action as one task; n8n (self-hosted) counts the entire workflow run as one execution regardless of step count. For a 10-module Make scenario processing 1,000 items, that's 10,000 credits — still within Core. The same workload on Zapier = 10,000 tasks at ~$300/mo. On n8n self-hosted = 1,000 executions at ~$10/mo infra. Make sits between Zapier and n8n self-host on cost for complex multi-step work, and above n8n on ease of management since no server administration is required.

Agency and team workflows

Agencies using Make for multiple clients run into the absence of per-client project isolation — unlike n8n's project feature (available from Pro tier), Make's Teams tier is organized around shared organizational space rather than isolated client workspaces. The documented workaround is maintaining separate Make accounts per client, which adds account management overhead but provides clean credential and scenario separation. The Teams tier's shared-template system and role-based permissions are genuinely useful for internal team collaboration and for onboarding junior team members to existing automation patterns. Make's per-module execution visibility also makes it easier to audit and explain credit usage to clients compared to the more opaque metering in Zapier.

Where the platform ceiling is

The question no affiliate blog answers: how far this scales before you outgrow it.

1

The ceiling

Make has no self-hosting option — all execution runs in Make's cloud. The hard architectural ceiling is the ~40-minute execution timeout per single scenario run (documented in-product; verify current limit in Make's official documentation). Data transfer is capped at 5 GB per 10,000 credits/mo; webhook queue capacity is 667–10,000 events depending on plan; data storage is 10 MB per 10,000 credits; per-plan concurrency limits are not officially published but are community-confirmed via rate-limit behavior. At high credit volumes — roughly 500,000+ credits/mo — the cost per operation approaches the economics of running self-hosted n8n on a VPS, which becomes the natural migration destination.

2

When to leave

Three clear exit signals: (1) A production scenario genuinely needs more than 40 minutes of continuous execution per run — Make's timeout is a hard architectural limit with no override option. (2) Credit costs from high-frequency polling or high-volume AI-native modules reach the territory of a Hetzner VPS running n8n (~$12/mo for modest workloads, as documented in automationatlas.io). (3) A regulatory or contractual requirement for self-hosting, data-residency control, or confirmed HIPAA BAA coverage — Make cannot satisfy these without verification and may not satisfy them at all.

3

Where teams go next

The documented migration path is Make Teams → self-hosted n8n. One tracked case: 23 scenarios migrated from Make Teams ($348/mo) to a Hetzner VPS running n8n (~$12/mo) — meaningful savings at scale, but approximately 40% of the project time went to recreating credentials and webhook registrations (automationatlas.io, anecdotal). Budget this reconstruction time before committing to a migration timeline; it is the primary hidden cost of the Make→n8n transition.

Platform momentum

Stable
  1. Make is owned by Celonis (acquired Oct 14, 2020; rebranded Feb 2022); Celonis was valued at $13B in its 2022 funding round (last public valuation figure per Make's About page)
  2. Make revenue estimated at ~$52.6M in 2025 (GetLatka; not audited — third-party estimate); serves 400,000+ organizations across 200+ countries as of 2026 (official homepage)
  3. Make AI Agents open beta launched Feb 2, 2026 with MCP tools support — active AI roadmap execution, not just announcements
  4. Billing model evolutionswitch from 'operations' to 'credits' Aug 27, 2025; extra credit pack pricing increased approximately 25% Nov 6, 2025 (help.make.com) — pricing is actively evolving
  5. Celonis reportedly planning a 2026 IPO (verify via current Celonis announcements — estimate, not confirmed as of this writing) — a public-company context could accelerate roadmap execution or introduce pricing pressure

Our outlook

Make is well-resourced through Celonis and actively shipping AI features (Maia, AI Agents, MCP) that position it as a genuine AI-automation platform rather than just a Zapier alternative. The most significant variable for 2026–2027 is the Celonis IPO: public-company status typically introduces pricing discipline and can accelerate product velocity, but also creates pressure on margin that sometimes flows through to customers. As of mid-2026, Make remains the best value-per-operation in the hosted automation category — that position is defensible as long as credit pricing stays close to current levels.

Who it's for

Technical-ish users and agencies wanting visual power at low cost

Good fit

Make's canvas with routers, iterators, and aggregators covers complex data-transformation workflows at roughly 1/20th of Zapier's cost for equivalent operation counts. Teams with some technical literacy that don't want to manage servers are in Make's ideal user profile.

Multi-step data-transformation workflows

Good fit

Routers, iterators, aggregators, and error handlers are native canvas elements — no code required for complex branching, batch processing, or conditional routing. The visual execution history after each run makes debugging faster than most code-based solutions.

Teams that actively monitor credit usage

Good fit

The canvas shows per-module credit cost in real time, which is unique in the category. Teams that build a habit of auditing polling frequency and module placement consistently avoid the billing surprises that plague Make newcomers.

Non-technical solo founders who want simplest possible setup

Poor fit

Zapier's linear builder is meaningfully simpler for first-time users. Make's credit-counting model and canvas branching introduce cognitive load that beginners don't want — the 'clicks after 2–3 hours' onboarding is real but longer than Zapier's sub-30-minute first-Zap experience.

Teams requiring real-time or high-frequency polling at scale

Poor fit

1-minute polling at high volume is a credit destruction pattern: a single polling scenario at 1-min intervals = ~43,200 credits/mo, consuming Core's monthly baseline in under 6 hours. Teams with this requirement should either use webhooks (where the source supports them) or evaluate n8n's execution-based model.

Teams requiring self-hosting or confirmed HIPAA certification

Poor fit

Make has no self-host option. Compliance posture for SOC 2 and HIPAA is not fully verifiable from public primary sources — confirm directly in Make's trust center before any procurement decision that depends on it.

Your first 30 days

A practitioner's runbook to get productive fast — the shortcuts we wish we'd known.

1
Day 1 — First scenario

Sign up free; pick a webhook-triggered scenario (not a polling trigger) to build your first 2–3 workflows

Practitioner tip: Place filters as the FIRST module after the trigger — filters do not save credits by themselves, but they prevent downstream modules from running on records you'll discard, which is where the real credit waste happens. A filter before a 10-module processing chain saves up to 10 credits per discard.

2
Week 1 — Credit audit

Run your scenarios and review credit usage per module in the canvas; identify any polling scenarios versus webhook-triggered ones

Practitioner tip: Every polling scenario at 1-minute intervals = ~43,200 credits/mo. Check your trigger sources and convert any that support outbound webhooks — this is the single highest-impact credit optimization. A polling scenario becoming a webhook-triggered one can save 40,000+ credits/mo and drop you from overage territory to within Core baseline.

3
Weeks 2–3 — Advanced canvas

Add routers for branching logic, iterators for batch processing, and aggregators for output consolidation; map step count × runs before adding any iterator

Practitioner tip: A 10-item iterator × 100 runs = 1,000 credits per scenario activation. Use the HTTP module for external API calls instead of AI-native Make modules to keep AI billing in your own LLM provider account — cheaper and more predictable for budgeting.

4
Month 2+ — AI and scale evaluation

Enable Maia for scenario building assistance; test Make AI Agents (Teams tier) if relevant to your use case; evaluate credit economics versus self-hosted n8n at your current volume

Practitioner tip: When your monthly credit spend exceeds ~$40–50/mo in packs, model the Hetzner VPS + n8n alternative ($12–50/mo infra depending on workload). The decision point is usually around 100,000+ credits/mo where self-hosting begins to beat Make's total cost.

Alternatives worth a look

Frequently asked questions

Is Make (formerly Integromat) worth it in 2026?

Yes, for the right use case. Make is the best-value hosted automation platform for complex multi-step workflows in 2026 — Core plan at ~$10.59/mo covers 10,000 credits, which represents the same effective operation count that costs ~$300/mo on Zapier. If your workflows involve branching logic, data transformation, or multiple processing steps per run, the cost savings are substantial and well-documented. The platform is worth it as long as you understand the credit model and architect your scenarios to avoid polling-heavy triggers.

What is the difference between Make and Integromat?

Make and Integromat are the same product. Integromat was founded in 2012 and rebranded to 'Make' on February 1, 2022, after being acquired by Celonis on Oct 14, 2020. The rebrand was purely a name change — the underlying platform, scenario structure, and feature set carried over. If you see references to Integromat in older tutorials, guides, or community posts, they apply to Make. The main thing to note: the Aug 27, 2025 switch from 'operations' to 'credits' means pre-Aug 2025 content uses different billing terminology, even if the product itself is the same.

How does Make pricing compare to Zapier?

At 10,000 effective operations per month, Make Core costs ~$10.59/mo versus approximately $300/mo on Zapier — a 28× cost difference for equivalent workflow complexity. The key is understanding the billing units: Make charges one credit per module execution in a scenario; Zapier charges one task per action in a Zap. A 10-module Make scenario processing 1,000 items = 10,000 credits ($10.59/mo). The same workflow on Zapier = 10,000 tasks (~$300/mo). Make's advantage grows with scenario complexity — the more modules per run, the larger the price gap.

What is the 40-minute execution timeout in Make and how do I work around it?

Make enforces a hard execution timeout of approximately 40 minutes per single scenario run (documented in-product; verify current limit in Make's official documentation). Any scenario that exceeds this — long-running data exports, bulk migrations, or extended API calls — will fail when it hits the wall. The architectural workaround is to chunk the operation: break the dataset into batches (using Make's iterator or a data store approach), process one batch per scenario run, and use a scheduler to trigger successive runs. This turns a single 2-hour job into twelve 10-minute runs triggered at intervals. It adds design complexity but is the only reliable solution within Make's constraints.

What changed in Make's billing on August 27, 2025?

Make switched from 'operations' to 'credits' as the billing unit on Aug 27, 2025. For standard modules, the effective cost is largely unchanged (1 operation ≈ 1 credit for most standard apps). The material change is in AI-native modules, which now consume variable credits based on tokens processed, file pages, or data volume — replacing a fixed per-module cost. The practical impact: teams running AI-heavy scenarios saw more variable billing post-change. The terminology change also means all guides, forum posts, and tutorials written before Aug 27, 2025 use 'operations' where you should now read 'credits.' When searching for Make help, filter for content published after Aug 2025 for accurate pricing references.

Does Make have a free plan?

Yes. Make's free tier offers 1,000 credits per month and 2 active scenarios, with access to 3,000+ app integrations and a 15-minute minimum polling interval. It is a genuine sandbox for testing scenario logic before committing to a paid plan — more useful than Zapier's 100-task free tier, though less generous than n8n's Community Edition (which offers unlimited executions on self-hosted infrastructure). Two active scenarios is a real constraint for production use, but sufficient for evaluating whether Make fits your workflow architecture.

Can Make handle HIPAA-compliant workflows?

Make's HIPAA and SOC 2 compliance posture was not fully verifiable from public primary sources at the time of this review — verify the current compliance status directly in Make's trust center and with their sales team before routing any PHI through the platform. Do not assume SOC 2 Type II or HIPAA BAA availability without primary confirmation. If HIPAA compliance is a hard requirement, self-hosted n8n (where your team controls the infrastructure and certification responsibility) is the documented alternative in this category.

How does Make compare to n8n for AI and agent workflows?

Both platforms have strong 2026 AI capabilities, but n8n edges ahead on agent depth. Make offers Maia (conversational scenario building), Make AI Agents (open beta Feb 2, 2026 with MCP tools), MCP server/client, and agent reasoning visibility on the canvas — genuinely strong. n8n offers native LangChain integration, MCP Client built-in, code nodes (JS/Python), human-in-the-loop approval (Jan 2026), and Microsoft Agent 365 Trigger (May 2026). The practical difference: n8n's code nodes and LangChain depth make it more flexible for custom agent architectures; Make's canvas visibility makes agent reasoning easier to audit and explain to non-technical stakeholders. n8n also wins on cost at high execution volumes via self-hosting.

What are the biggest hidden costs in Make?

Three patterns account for most unexpected Make bills: (1) Polling scenarios — a single polling trigger at 1-minute intervals consumes ~43,200 credits/mo, exhausting Core's 10,000-credit baseline in under 6 hours. Convert polling to webhooks wherever the trigger source supports it. (2) Iterator and router credit multiplication — every module in a branched or iterated path counts; a 10-item iterator through a 5-module chain = 50 credits per activation, not 5. (3) Extra credit packs costing ~25% more than in-plan credits (as of Nov 6, 2025) — sustained overage at pack prices means a tier upgrade is almost always cheaper than continued pack purchasing.

Can RapidDev help migrate from Make to n8n or build Make automations?

Yes — we've architected Make-to-n8n migrations for agencies that have scaled past Make's credit ceilings, as well as built complex Make scenario networks from scratch for teams that want the visual canvas without server management. If you're trying to decide whether to stick with Make or make the move to self-hosted n8n, a scoping call can help you model the cost break-even and migration timeline. Reach out at rapidevelopers.com/contact.

RapidDev

Outgrowing Make (ex Integromat)?

  • We build production apps on these platforms
  • Custom build when you hit the ceiling
  • Fixed price, you own 100% of the code
Get a free estimate

30-min call. No commitment.

Your next step

Still weighing your options?

Talk to a team that ships on all of these platforms. A free consultation gets you an honest recommendation for your specific project — even if the answer is a tool, not us.

Book a free consultation

We put the rapid in RapidDev

Need a dedicated strategic tech and growth partner? Discover what RapidDev can do for your business! Book a call with our team to schedule a free, no-obligation consultation. We'll discuss your project and provide a custom quote at no cost.