Make logo

Make Review

Visit

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

8.2/10

6 AI reviews

Reviewed

AI Editor Approved

About Make

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.

Features

AI

  • Agentic Automation

    Goal-oriented automation systems that independently handle complex, ever-changing tasks and react to new information as it happens.

  • Maia

    A conversational AI feature that allows users to build automation scenarios using natural language with full transparency into what is being created.

  • Make AI Agents

    Intelligent agents that understand goals in natural language and dynamically adjust workflows in real time to automate complex business processes.

Analytics

  • Make Grid

    A visual map of an organization's entire automation and AI landscape that enables users to observe, manage, and scale their scenarios.

Automation

  • Real-Time Data Processing

    Processes and reacts to live data within workflows as new information arrives, enabling dynamic and responsive automations.

  • Visual Scenario Builder

    A drag-and-drop interface that lets users visually connect apps and services to build automated workflows without writing code.

Customization

  • Make Code App

    Runs native JavaScript and Python scripts directly inside automation scenarios to handle complex data transformations and custom logic without external services.

Integration

  • 3,000+ Pre-built App Integrations

    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.

  • MCP Client

    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.

  • MCP Server (Model Context Protocol)

    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.

  • Make Bridge

    Enables developers to embed pre-built integrations and custom automation scenarios directly into their own applications using Make's API.

Preview

Make desktop previewMake mobile preview

Pricing Plans

Free

Free

Try the visual-first interface with limited credits

  • 1,000 credits/month
  • Visual no-code workflow builder
  • 3,000+ apps
  • Routers and filters
  • 15-minute minimum interval

Core

$9/monthly

Fundamental automation with expanded capabilities

  • Unlimited active scenarios
  • Per-minute scheduling
  • Make API access
  • 40-minute max execution
  • Increased data transfer limits
Popular

Pro

$16/monthly

Advanced AI and automation with high-performance execution

  • Priority scenario execution
  • Custom variables
  • Full-text execution log search
  • 250 MB max file size
  • 30-day execution log storage

Teams

$29/monthly

Streamline collaborative AI and automation efforts

  • Teams and team roles
  • Shared scenario templates
  • 500 MB max file size
  • 1,000 API calls/min limit
  • Unlimited users

Enterprise

Contact sales

Powerful, scalable, and secure for large organizations

  • Custom functions support
  • Enterprise app integrations
  • 24/7 support
  • Value Engineering team
  • Overage protection

AI Panel Reviews

The Decision Maker

The Decision Maker

Strategic bet, vendor viability, timing, adoption approval
8.3/10

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.

Competitive Positioning8.0
Reputation Risk8.2
Speed to Value8.4
Strategic Fit8.3
Vendor Viability8.5

Pros

  • Twelve years in-market plus Celonis ownership puts vendor-survival risk near zero
  • Operations-based pricing scales to workflow complexity, not seat count
  • Sits between Zapier (too thin) and n8n (too engineering-heavy) in a real ICP gap
  • 3,000+ pre-built integrations covers the long-tail SaaS most ops teams hit

Cons

  • Roadmap priority depends on Celonis strategy, not standalone Make-team focus
  • Operations metering can surprise finance when scenarios loop or batch unexpectedly
  • Less brand recognition with non-technical buyers than Zapier in 2026

Right for

Ops and marketing teams who need branching, batching, and conditional workflows beyond Zapier's entry tiers.

Avoid if

Engineering teams who would rather self-host n8n and own the runtime than depend on Celonis priorities.

The Domain Strategist

The Domain Strategist

Craft and strategy in the product's domain — adapts identity per category, same lens
8.2/10

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.

Category Positioning8.0
Domain Fit8.5
Integration Surface8.4
Long-term Implications7.8
Strategic Depth8.3

Pros

  • Operations-based pricing matches how automation scales — by volume, not user count
  • Iterator, Aggregator, and Router are real visual primitives, not workarounds in the UI
  • Make Bridge supports the dev-to-prod scenario promotion mature ops teams need
  • AI Agents feature is the right next architectural bet for agentic automation

Cons

  • Scenario blueprint JSON is exportable but only runs on Make's runtime
  • AI Agents capability is newer than Zapier's and Workato's competing offerings
  • Visual canvas hits a complexity ceiling around 30+ modules per scenario

Right for

Ops-led organizations where automation volume scales faster than headcount and visual modeling matters.

Avoid if

Engineering orgs who want workflow code in version control on their own runtime.

The Finance Lead

The Finance Lead

Money, total cost of ownership, contracts, procurement math
8.5/10

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.

Billing & Procurement8.4
Contract Flexibility8.5
Pricing Transparency9.0
ROI Clarity8.0
Total Cost of Ownership8.3

Pros

  • Full pricing public — Core $9, Pro $16, Teams $29 — no sales call to start
  • Operations-based unit means 50 builders cost the same as 5 if ops volume is constant
  • Free tier is 1,000 ops/month indefinitely, usable for prototyping
  • Self-serve cancellation in the dashboard, no auto-renewal contract trap

Cons

  • Operations forecasting is harder than seat-based — 30-40% first-six-month overruns are common
  • Iterators and Routers can multiply billable ops in ways scenario builders don't intuit
  • Enterprise pricing remains contact-sales without published bands

Right for

Finance teams who want public-tier transparency and would rather forecast operations than negotiate seats.

Avoid if

Companies with unpredictable workflow volume that need a flat-fee contract for budget certainty.

The Domain Practitioner

The Domain Practitioner

Daily hands-on reality in the product's domain — adapts identity per category, same lens
8.2/10

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.

Day-3 Reality7.9
Documentation Practitioner-Fit8.2
Friction Surface7.8
Power-User Depth8.5
Workflow Integration8.3

Pros

  • Iterator + Aggregator pairing handles batch patterns Zapier needs three Zaps to fake
  • Execution inspector retains data shape per module — closer to a real debugger
  • Data Stores give workflow-internal key-value state without bolting on Airtable
  • Rerun-from-failure is one click that ops practitioners use daily

Cons

  • Operations meter forces a mental model practitioners don't need on Zapier or self-hosted n8n
  • Learning curve to fluency is roughly 2 weeks longer than Zapier for the same person
  • Mobile app is monitoring-only — scenario building requires desktop

Right for

Ops, marketing-ops, and revops practitioners who think in flowcharts and live in branching workflows daily.

Avoid if

Practitioners who only need linear two-step workflows and would rather skip Iterator semantics.

The Power User

The Power User

Daily human experience, onboarding, polish, learning curve, reliability
8.0/10

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.

Daily Polish8.3
Learning Curve7.8
Mobile Parity7.5
Onboarding Experience7.5
Reliability Feel8.4

Pros

  • Bundle inspection per module shows every input and output for every run iteration
  • History panel retains 7-day execution data with full replay on paid tiers
  • Run-once-from-here keyboard shortcut is the kind of detail you only get from years of iteration
  • Module connection snapping and visual flow feels lived-in, not demo-grade

Cons

  • Empty state and first-scenario UX still feels older than the rest of the product
  • Mobile app is monitoring-only — no scenario editing, by design
  • Some niche connectors feel less actively maintained than first-party Zapier integrations

Right for

Ops practitioners who draw automations daily and care about scenario debugging polish.

Avoid if

First-time automators who would prefer the most-polished onboarding without branching workflows.

The Skeptic

The Skeptic

Contrarian. Watch-outs, deal-breakers, broken promises, category patterns
7.8/10

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.

Competitive Differentiation7.7
Exit Portability7.0
Long-term Viability8.0
Marketing Honesty7.6
Track Record Match8.3

Pros

  • Twelve years in a category that has consolidated heavily — survival is a real signal
  • Celonis acquisition gave runway without the usual post-acquisition roadmap rot
  • 3,000+ integrations create real switching cost that holds for the next 24 months
  • Operations-based pricing rewards the ICP that's actually growing — ops teams

Cons

  • AI Agents bet is contested by Zapier Agents and self-hosted n8n — outcome genuinely uncertain
  • Scenario blueprint JSON is proprietary and only runs on Make
  • Celonis priorities can override standalone Make-team direction over the next 3 years

Right for

Ops teams comfortable with Celonis-owned platform direction and a proprietary scenario format.

Avoid if

Teams whose 18-month exit plan requires running workflows on their own infrastructure.

Buyer Questions

Common questions answered by our AI research team

Pricing

How much does Make cost per month?

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.

Features

What is agentic automation in Make?

Make's AI agents interpret natural-language goals and adapt workflows in real time, choosing actions across 3,000+ integrated apps without predefined rules.

Integration

How many apps does Make integrate with?

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.

Setup

Do I need to code to use Make?

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.

Features

Can I schedule scenarios down to the minute?

Yes, on the Core plan and above. The Free plan caps the schedule interval at 15 minutes between runs.

Also in AI Productivity