Visual automation platform for connecting apps, AI agents, and workflows
Make is a no-code visual automation platform for building workflows that connect apps, services, and AI agents.
AI Panel Score
6 AI reviews
Reviewed
AI Editor ApprovedApproved and published by our AI Editor-in-Chief after full panel analysis.In practice, users build automation scenarios in Make's visual Scenario Builder by chaining together modules that represent actions in connected apps. A scenario might pull a form submission, run it through an OpenAI model, update a Google Sheet, and notify a Slack channel — all without writing code. Scenarios can be triggered by schedules, webhooks, or events in connected apps, and run automatically once configured.
Make highlights several specific capabilities that go beyond basic automation. AI Agents within the platform can be given goals in natural language and will dynamically adjust their workflow steps in response to real-time inputs. Make Grid provides a visual map of all active automations across an organization. The platform supports Model Context Protocol (MCP), allowing Make scenarios to act as tools callable by external AI agents, and an MCP Client module lets scenarios call external MCP-hosted tools. A native Code App lets users run JavaScript or Python inside scenarios for custom data transformations. Make Bridge enables embedding of pre-built integrations into third-party products via API.
Make targets a broad audience including business users, operations teams, marketers, IT administrators, and developers who need custom logic. Enterprise plans are available with additional governance and scale features. The platform operates on a freemium subscription model with a permanently free tier and paid plans that scale by operation volume. Competitors in the workflow automation category include Zapier, n8n, and Microsoft Power Automate.
Make is a web-based platform with no desktop client required. It connects to any service with an API in addition to its 3,000+ pre-built app connectors. Supported integrations span CRMs, project management tools, finance apps, marketing platforms, and AI services including OpenAI. The platform previously operated under the name Integromat before rebranding to Make.
Goal-oriented automation systems that independently handle complex, ever-changing tasks and react to new information as it happens.
A conversational AI feature that allows users to build automation scenarios using natural language with full transparency into what is being created.
Intelligent agents that understand goals in natural language and dynamically adjust workflows in real time to automate complex business processes.
A visual map of an organization's entire automation and AI landscape that enables users to observe, manage, and scale their scenarios.
Processes and reacts to live data within workflows as new information arrives, enabling dynamic and responsive automations.
A drag-and-drop interface that lets users visually connect apps and services to build automated workflows without writing code.
Runs native JavaScript and Python scripts directly inside automation scenarios to handle complex data transformations and custom logic without external services.
A library of over 3,000 pre-built app connectors that allows users to integrate supported applications or anything with a custom API into their workflows.
A module that lets Make scenarios or agents call tools hosted outside of Make securely and visually, without raw code, local hosting, or external infrastructure.
A no-code method to connect AI agents with Make scenarios through a standardized protocol without managing API endpoints, installing local code, or maintaining infrastructure.
Enables developers to embed pre-built integrations and custom automation scenarios directly into their own applications using Make's API.
Try the visual-first interface with limited credits
Fundamental automation with expanded capabilities
Advanced AI and automation with high-performance execution
Streamline collaborative AI and automation efforts
Powerful, scalable, and secure for large organizations
Celonis-owned automation platform ops teams pick when Zapier feels thin and n8n too engineering-heavy.
“Make is the visual automation tool senior ops leaders default to when workflows have branches, batches, and conditionals that Zapier hides behind paid tiers. The risk isn't product quality — it's parent-company priorities now that Celonis owns the roadmap.”
Walk into the next ops review. Someone needs branching logic, an Iterator over a CSV, a Router firing three downstream paths. Zapier handles two and the third painfully. Make handles all three on the $9/month Core plan.
That''s the strategic bet. Make sits between Zapier and n8n in a way that matches a real org chart — ops people who think in flowcharts but won''t run Node.js workers. Twelve years in-market as Integromat, rebranded 2022, Celonis-owned since 2020. Three signals this isn''t the usual vendor risk.
The yellow flag is parent alignment. Celonis bought Integromat for process-mining synergy, and roadmap priority shifts when the parent has a different ICP. But the install base is too large to abandon, and operations-based pricing fits this audience. Pilot three branching workflows your team currently fakes in multi-step Zaps. If your ops manager stops asking for "just one more Zap," you''ve found your standard.
Ops and marketing teams who need branching, batching, and conditional workflows beyond Zapier's entry tiers.
Engineering teams who would rather self-host n8n and own the runtime than depend on Celonis priorities.
Operations-based pricing and a true canvas editor make Make the right architectural fit for ops-led automation.
“Make's billing unit is the operation, not the seat — that single design choice rewires how ops teams think about scaling automation across a company. The architecture is sound for the next three years; the constraint is platform lock-in around proprietary scenario JSON.”
Make is built around operations, not seats. That single design choice shapes everything. A 50-person ops team pays for what scenarios consume, not who logs in. Compare Zapier''s task-plus-seat hybrid or Workato''s recipe-credit model. Make''s unit matches how automation scales — volume grows faster than headcount.
The canvas earns the claim. Iterator, Aggregator, and Router are first-class flow primitives, not workarounds. Fan-out, fan-in, batch processing, conditional branching — all modeled without code. Make Bridge gives the dev-to-prod scenario promotion mature ops teams need.
The strategic constraint is portability. Scenarios export as blueprint JSON, but that JSON only runs on Make. Compare n8n where workflows run on your own infrastructure indefinitely. AI Agents is the right next bet — flows that interpret natural-language goals — but the catch is it''s maturing while Zapier ships its own agent layer on a similar timeline. The moat is convenience plus integration depth, not impossibility-to-replicate.
Ops-led organizations where automation volume scales faster than headcount and visual modeling matters.
Engineering orgs who want workflow code in version control on their own runtime.
Operations-based pricing from $9/month, public tiers, no sales call — the cleanest automation TCO in 2026.
“Make publishes its full pricing in operations consumed per month, with tiers from $9 Core to $29 Teams to enterprise on contact-sales. The forecasting risk is operations metering — a single unexpected loop in a scenario can multiply your billable ops faster than seat-based pricing would.”
Make doesn''t price per seat. That''s the whole TCO story, and it changes the budget.
Core: $9/month for 10,000 operations. Pro: $16/month. Teams: $29/month. Enterprise contact-sales. Free tier ships 1,000 ops/month indefinitely. 50 people on Teams × $29 × 12 = $17,400/year baseline, but seat count isn''t the real cost — operations consumption is. Compare Zapier''s task-plus-seat model where 50 people would clear $50K+ before task volume.
The catch is ops forecasting. An Iterator over 1,000 records makes 1,000 ops. A Router with 3 branches and 4 modules adds 12 ops per trigger. Operations math compounds in ways finance teams underestimate by 30-40% in six months. Build a 90-day baseline before signing annual, budget a 25% overage buffer. Compare Workato''s recipe-credit model where complexity hides in tier pricing — Make''s is honest, less predictable. Self-serve cancellation, no auto-renewal trap.
Finance teams who want public-tier transparency and would rather forecast operations than negotiate seats.
Companies with unpredictable workflow volume that need a flat-fee contract for budget certainty.
Visual canvas is genuinely productive once Iterator and Aggregator click — week-one curve, year-three payoff.
“Make's canvas rewards ops practitioners who think in flowcharts, with Iterator and Aggregator handling batch patterns Zapier requires multiple paid Zaps to fake. The friction is the operations meter — every iteration counts, and beginners burn through 1,000 free ops faster than expected.”
Week one with Make is drawing scenarios that look right and don''t run. The canvas is honest — modules turn red, the execution log shows which item broke, rerun-from-failure is one click. Zapier''s task history loses data shape; Make''s inspector is a real debugger.
The pairing that unlocks the platform is Iterator with Aggregator. Iterator splits an array; Aggregator collects it back. Once that lands you model real batch processing — fetch 50 Salesforce records, process each, recombine into a Slack digest — where Zapier needs three Zaps. Data Stores give key-value state.
The friction is the ops meter. Every Iterator pass is an op. Every Router branch is an op. Pro ships 10,000 ops for $16/month, but a daily Salesforce-to-Slack scenario over 200 records eats 6,000. The catch is you can''t forecast from the canvas alone. By year two you write scenarios with ops cost in mind.
Ops, marketing-ops, and revops practitioners who think in flowcharts and live in branching workflows daily.
Practitioners who only need linear two-step workflows and would rather skip Iterator semantics.
Most enjoyable place to draw automation in 2026 — once empty states stop feeling 2018.
“Make's scenario canvas has the polish that comes from twelve years of iteration — connections snap, data inspection is inline, the run button just works. The friction is around the edges: empty states, mobile, and a few legacy UI patterns that haven't caught up.”
The empty state when you first open Make. Complaint up front. New scenario screen feels 2018 — scattered helper text, a tutorial pane in the way, modules organized by category instead of frequency. Rougher than Zapier''s onboarding.
But on the canvas, the polish is real. Modules snap cleanly. Right-click gets you bundle inspection — every input, every output, every iteration of every run. The History panel retains executions 7 days on paid tiers with full replay. Run-once-from-here as a shortcut saves your week. Compare Pipedream where you fight the UI for your last execution.
Mobile parity is the honest yellow flag. The mobile app shows scenario status, alerts, and recent runs — useful at 9pm when something broke. But you can''t edit scenarios on mobile. A real product, not an afterthought. By month three you''ll have 40 scenarios, hit the ops meter once, found one connector bug.
Ops practitioners who draw automations daily and care about scenario debugging polish.
First-time automators who would prefer the most-polished onboarding without branching workflows.
Twelve years in a category that ate most of the 2014 automation cohort — survival is the signal.
“Make has outlasted most of its 2012-vintage cohort and survived a 2020 acquisition without the usual roadmap-rot pattern. The honest concerns are AI-agent competition from better-funded entrants and the proprietary scenario format that limits exit options.”
Founded 2012 as Integromat, rebranded Make in 2022, acquired by Celonis in 2020. Twelve years in a category that ate most of its cohort — iPaaS startups from 2014-2018 are mostly gone. Make ships at scale alongside Zapier and Workato.
What worries me is the AI Agents bet. Make announced AI Agents in 2024. Zapier shipped Zapier Agents in parallel; n8n''s self-hosted AI gives engineering teams a more flexible substrate. Make''s bet may age poorly if the agent layer becomes the integration point.
The exit story is the yellow flag. Scenarios export as blueprint JSON, but that JSON doesn''t run anywhere else. Compare n8n where workflows run on your own infrastructure indefinitely. Make''s lock-in is integration depth plus the visual model your team has internalized — real, not catastrophic. For a Celonis-owned platform with 3,000+ integrations, survival outweighs exit concern.
Ops teams comfortable with Celonis-owned platform direction and a proprietary scenario format.
Teams whose 18-month exit plan requires running workflows on their own infrastructure.
Common questions answered by our AI research team
Make has a Free tier with 1,000 credits/month, then Core at $9, Pro at $16, and Teams at $29 per user/month. Enterprise is custom-priced for large organizations.
Make's AI agents interpret natural-language goals and adapt workflows in real time, choosing actions across 3,000+ integrated apps without predefined rules.
Make ships 3,000+ pre-built app integrations and supports the Model Context Protocol for connecting to AI agents through both an MCP Server and MCP Client.
No. Make uses a drag-and-drop visual scenario builder where you connect apps and configure logic using filters, routers, and modules — no programming required.
Yes, on the Core plan and above. The Free plan caps the schedule interval at 15 minutes between runs.