# Make

> Make (formerly Integromat) is a visual automation platform where workflows are built as scenarios on a drag-and-drop canvas, with native routers, iterators, aggregators, and error handlers that give no-code builders genuinely programmatic control. It connects around 2,000 apps, meters usage per operation, and undercuts the category on price with a 1,000-operation free plan and paid tiers from about $9 a month.

- Category: GTM Engineering (https://saastracker.org/categories/gtm-engineering)
- Website: https://www.make.com
- Starting price: $9/mo (Core, 10,000 operations, annual billing)
- Free plan: 1,000 operations/month, two active scenarios, 15-minute minimum interval
- Free trial: Free plan serves as the trial; paid features preview via plan upgrades
- Founded: 2016, HQ: Prague, Czech Republic, Ownership: Subsidiary of Celonis (acquired 2020)
- Profile last reviewed: 2026-08-22
- Canonical profile: https://saastracker.org/products/make

## Overview

Make occupies the deliberate middle of the automation market: far more expressive than Zapier's linear Zaps, far gentler than n8n's JSON-and-code culture, and cheaper at entry than either. Its canvas draws workflows the way processes actually look, circles for modules, lines for data flow, routers where paths split, and gives visual builders tools that are elsewhere reserved for code: iterate over a list, aggregate results back together, catch an error and handle it, all as drag-and-drop primitives.

The pricing does real strategic work. A free tier with 1,000 operations a month is enough to run genuine automations indefinitely, and the $9 Core tier's 10,000 operations undercut every serious rival at entry. The meter counts operations, each module execution, so long scenarios accumulate cost per step like Zapier's tasks do, but the per-unit price is a fraction of Zapier's, which is why cost-conscious agencies and European SMBs disproportionately standardize on Make.

The company began in Prague in 2016 as Integromat, was acquired by process-mining giant Celonis in 2020, and relaunched as Make in 2022 with a rebuilt platform. The Celonis ownership gives it enterprise-grade backing unusual for a tool this cheap, and the 2025 addition of AI agents, plus a grid view and an expanding template library, keeps it current in the agent era, though its AI tooling still trails n8n's LangChain-native depth.

## How it works

1. You build a scenario on the visual canvas: a trigger module starts the run (a schedule, a webhook, or a watched app event), and each subsequent module performs one action, search records, transform data, call an API, write a row. Modules connect with lines showing data flow, and clicking any module maps its inputs from any previous module's outputs with a visual picker, no expression syntax required for common cases.

2. The control-flow primitives are the differentiator: routers split a scenario into parallel branches with per-branch filters, iterators explode an array into individual bundles processed one at a time, aggregators collect them back into a single result, and error handlers attach to any module with retry, ignore, rollback, or alternative-path semantics. This is programming, expressed visually, and it handles pipelines that force Zapier users into contortions.

3. Each module execution is one operation against your plan's monthly allowance, and the scenario editor shows exactly how many operations a test run consumed, which makes cost visible while you build. Built-in tools (HTTP module for arbitrary APIs, JSON parsing, text and date functions, data stores for small persistent state, webhooks) cover gaps in the ~2,000-app catalog.

4. Scenarios run on schedules as fast as one minute (tier-dependent) or instantly via webhooks. Make AI agents add a goal-directed layer on top: give an agent access to scenarios and apps as tools, and it decides which to invoke to satisfy a request, with the deterministic scenarios remaining the workhorses underneath.

## Best for

Visually-minded builders and cost-conscious teams who need real workflow logic, branching, iteration, error handling, without writing code, especially agencies and SMBs whose per-month automation budget is closer to $20 than $200.

## Not the right fit for

- Buyers whose niche apps only Zapier connects; Make's ~2,000-app catalog covers the mainstream but loses the long tail to Zapier's ~8,000.
- Teams that want per-run pricing for very long pipelines; operations metering bills every module, so a 60-step waterfall at volume is where n8n's per-execution model wins decisively.
- Self-hosting or strict data-sovereignty requirements; Make is cloud-only (with EU data-center options, but no on-premise).
- Developers who prefer code-first automation; the visual canvas is the product, and code escape hatches are thinner than n8n's.
- Absolute beginners intimidated by a canvas; Zapier's guided linear editor remains the gentler first step, though Make's templates narrow the gap.

## Features

### Scenario building

The visual canvas where workflows look like the processes they are.

- **Drag-and-drop scenario canvas**: Workflows are drawn as connected modules with data flowing along visible lines, making structure, branches, and dependencies legible at a glance.
- **Routers and filters**: Split a scenario into parallel branches, each guarded by visual filter conditions, so one trigger can drive many outcomes without duplicate scenarios.
- **Iterators and aggregators**: First-class array handling: explode a list into per-item processing, then gather results back into one bundle, the primitive that makes batch work tractable without code.
- **Error handlers**: Attach retry, ignore, resume, rollback, or alternative-route handlers to any module, giving scenarios production-grade resilience that most no-code tools lack.
- **~2,000 app integrations**: Native modules for the mainstream SaaS surface, each typically exposing a deep set of actions and searches rather than a token trigger.
- **HTTP module and webhooks**: A generic HTTP client with OAuth support plus instant inbound webhooks extend coverage to any API beyond the catalog.
- **Data stores and variables**: Small built-in databases and scenario variables hold persistent state between runs, handling dedupe checks and counters without an external database.
- **Scheduling and instant triggers**: Scenarios run on intervals down to one minute (by tier) or instantly on webhooks, with per-scenario scheduling control.

### Data and functions

The transformation layer between modules.

- **Visual data mapping**: Map any prior module's output into any input with a point-and-click panel; nested structures unfold visually instead of as JSON paths.
- **Built-in function library**: Hundreds of text, math, date, and array functions compose inside mapping fields, covering most transformations without a code step.
- **JSON and XML handling**: Parse and build structured payloads natively, the daily bread of API work, with automatic structure detection from sample data.
- **Custom apps**: A developer platform for packaging any API as a reusable private or public Make app with its own modules and auth.

### AI capabilities

Agents and AI modules arriving on top of the deterministic core.

- **Make AI Agents**: Goal-directed agents that use your scenarios and app connections as tools, deciding at runtime which to invoke, deterministic automation underneath, model judgment on top.
- **AI app modules**: Native modules for OpenAI, Anthropic, and other providers drop completion, classification, and image steps into any scenario with managed auth.
- **AI-assisted building**: Describe an automation in plain language and get a draft scenario to refine on the canvas, lowering the blank-canvas barrier.

### Team and governance

Sharing an automation estate without losing control of it.

- **Teams and permissions**: Organizations contain teams with role-based access to scenarios and connections, separating client work in agency setups.
- **Scenario version history**: Restore previous versions of a scenario, the safety net for shared editing.
- **Execution history and logs**: Every run stores per-module inputs and outputs for inspection and replay, with incomplete executions queued for manual resolution.
- **EU data-center option**: Choose EU-region processing at signup, a meaningful compliance lever for European SMBs that Zapier does not offer.

## Use cases

- **Automation agency serving a dozen SMB clients**: Builds and maintains client automations where margins depend on platform cost, and clients balk at Zapier task bills that exceed the agency's fee. Outcome: Client workloads run on Core and Pro tiers at a fraction of task-priced equivalents, teams and permissions isolate each client, and the visual canvas doubles as client-facing documentation of what was built.
- **E-commerce operator syncing orders across systems**: Orders arrive from two storefronts and must fan out to fulfillment, accounting, and a customer-notification flow, with per-line-item handling that linear tools mangle. Outcome: One scenario ingests both storefronts via webhooks, an iterator processes line items individually, a router fans out to fulfillment and books, and error handlers queue failures for review instead of dropping orders silently.
- **Marketing ops lead on a tight budget**: Needs lead routing, enrichment, and Slack alerting that would cost real money in task-priced tools, with a monthly software budget already spoken for. Outcome: The whole pipeline fits inside the $9 to $16 tiers; operations metering with visible per-run costs lets the lead tune filters until the meter matches the budget, something opaque pricing never allowed.
- **EU company with data-residency requirements**: Legal requires customer data processed in the EU, which disqualifies US-only automation clouds without an enterprise contract. Outcome: Make's EU data-center option satisfies the requirement on self-serve tiers, and the compliance answer is a region selector rather than a procurement negotiation.

## Pricing

Freemium with operations-based metering: every module execution consumes one operation from a monthly allowance. Tiers scale the allowance, minimum scheduling interval, and team features; operations can be topped up, and unused allowance policies vary by tier. Prices quoted for annual billing; monthly billing runs higher.

- **Free**: $0 forever. 1,000 operations/month, two active scenarios; Full canvas including routers, iterators, and error handlers; Enough to run a couple of real automations indefinitely.
- **Core**: From $9 per month, annual billing. 10,000 operations/month, unlimited active scenarios; 1-minute minimum scheduling interval; The category's cheapest serious entry point.
- **Pro**: From $16 per month, annual billing. Higher operation allowances with priority execution; Custom variables and fuller execution-log searching.
- **Teams**: From $29 per month, annual billing. Multiple teams with role-based permissions; The agency and multi-department tier.
- **Enterprise**: Custom annual contract. SSO, advanced governance, dedicated support, higher limits; Celonis-grade enterprise apparatus behind a self-serve product.

Billing notes:

- An operation is one module execution: a 6-module scenario that runs 500 times consumes 3,000 operations. Model steps times volume before comparing tiers, exactly as with Zapier tasks.
- Per-operation cost at entry (about $0.0009 on Core) runs far below Zapier's per-task pricing at comparable tiers, which is the arithmetic behind Make's value reputation.
- The free tier's 15-minute minimum interval matters: near-real-time polling needs Core's 1-minute scheduling, or webhooks, which are instant on every tier.
- Operations top-ups are purchasable mid-month; scenarios pause when allowance exhausts unless top-ups or auto-purchase are configured.
- Annual billing saves roughly 15 to 20% versus monthly; prices current as of August 2026.

Value assessment: Make's claim to Best Value is straightforward arithmetic plus real capability: routers, iterators, and error handlers, the features that gate 'serious' automation elsewhere, are included from the free tier up, and the per-operation price at entry undercuts every comparable rival. For most SMB workloads (moderate volume, moderately complex scenarios) it delivers 90% of what either neighbor offers at clearly the lowest bill. The value case weakens at the two edges: long-tail app coverage (Zapier's game) and very long high-volume pipelines, where per-execution n8n beats any per-step meter, Make's included.

## Strengths

- The best power-per-dollar in mainstream automation: full logic primitives on a $9 tier, and a genuinely usable free plan.
- The visual canvas makes complex flows legible; routers, iterators, aggregators, and error handlers are native drag-and-drop, not workarounds.
- Operations pricing is transparent while you build: the editor shows what each run costs, making optimization a visible activity.
- Deep per-app modules: integrations typically expose many actions and searches, not token connectors.
- EU data-center option on self-serve tiers, a compliance lever rivals reserve for enterprise contracts or lack entirely.
- Celonis ownership provides enterprise-grade financial backing unusual beneath a $9 product.

## Limitations

- Per-operation metering still bills every step, so Make loses the long-pipeline economics contest to n8n's per-execution model at scale.
- The ~2,000-app catalog covers the mainstream but concedes the long tail; niche-tool buyers routinely end up on Zapier anyway.
- The canvas intimidates true beginners relative to Zapier's guided linear editor, and error-handler semantics take study to use well.
- No self-hosted option; EU region processing exists but the platform is cloud-only.
- AI agent tooling arrived later and shallower than n8n's LangChain-native stack; agents are promising but not yet the reason to choose Make.
- Code escape hatches are thinner than rivals'; when the function library runs out, you feel the no-code walls.

## Comparisons

- **Make vs Zapier**: Zapier sells breadth and ease; Make sells depth per dollar. Zapier's catalog (~8,000 apps vs ~2,000) and guided editor get a non-technical team live fastest, but every action is a metered task. Make's visual canvas handles branching, iteration, and error handling more naturally and its per-operation pricing starts at $9, typically landing far cheaper at the same workload. Pick Zapier when your niche tools demand it or your builders are non-technical; pick Make when workflow complexity per dollar is the contest.
- **Make vs n8n**: The two power builders. Make gives you a visual scenario canvas with the category's cheapest entry pricing, but meters every operation, so long waterfalls still accumulate cost per step. n8n meters the run, not the steps, adds real code nodes and self-hosting, and has pulled decisively ahead on AI agent tooling. Make suits visually-minded builders who want power without code; n8n suits builders who will eventually want the code, and whose workflows are long enough for per-execution pricing to pay.
- **Make vs Serper**: A pairing rather than a contest: Serper is a data source, Make is the engine that calls it. Make's HTTP module drives Serper's search API cleanly (one POST per query, one operation per call), and the combination gives no-code builders programmatic Google results inside visual scenarios, the discovery step of the DIY enrichment stack without touching code.

## Implementation

- Setup time: Under an hour to a first live scenario for anyone who has used any automation tool; the template library shortcuts common patterns. Complex scenarios with error handling are a day of iterative building, made faster by per-module test runs.
- Learning curve: Moderate: the canvas and mapping panel are intuitive within hours, while iterators, aggregators, and error-handler semantics reward a deliberate afternoon with the docs. Sits clearly between Zapier's near-zero curve and n8n's technical one.
- Onboarding: Self-serve with documentation, an academy of structured courses, templates, and a community forum; paid tiers add support responsiveness, Enterprise adds dedicated contacts.
- Migration: No importer exists from Zapier or to n8n; migration is manual rebuilding, typically faster than the original build since logic is already designed. Scenario blueprints export as JSON for backup and duplication within Make, useful for agencies templating client work.

## Platform, API & security

- Platforms: Web app, REST API, Developer platform (custom apps)
- API: A public API manages scenarios, connections, and executions programmatically; webhooks provide instant inbound triggers, and the custom-apps platform packages any API as a first-class Make app.
- Compliance: SOC 2, GDPR, ISO 27001
- Data residency: Cloud-only with selectable EU or US data centers at organization creation.
- SSO: SSO on Enterprise.
- Security notes: Encrypted connection storage, granular team permissions, and the EU-region option cover typical SMB requirements; Celonis's enterprise security posture stands behind the platform.

## Support

- Channels: Help center, Community forum, Ticket support (paid tiers), Dedicated support (Enterprise)
- Documentation: Thorough module-by-module documentation plus the Make Academy's structured courses; the template library doubles as worked examples of canvas idioms.
- Community: An active forum and a sizeable ecosystem of certified partners and freelance builders, particularly strong in Europe.

## Company

- Founded: 2016
- Headquarters: Prague, Czech Republic
- Ownership: Subsidiary of Celonis (acquired 2020)
- Employees: ~700 (2026 est., within Celonis)
- Funding: Bootstrapped as Integromat in Prague; acquired by process-mining leader Celonis in October 2020, reported around $100M, and relaunched as Make in February 2022.

Timeline:

- 2016: Launches in Prague as Integromat, a visual automation tool with unusually deep logic primitives for its era.
- 2018: The router-iterator-aggregator canvas earns a devoted technical-adjacent user base while Zapier owns the mainstream.
- 2020: Celonis acquires Integromat (reported ~$100M), pairing the SMB automation canvas with an enterprise process-mining giant.
- 2022: Relaunches as Make on a rebuilt platform; aggressive $9-entry pricing sharpens the value positioning.
- 2024: Catalog passes ~2,000 apps; AI provider modules and AI-assisted building keep the canvas current.
- 2025: Make AI Agents launch, layering goal-directed agents over deterministic scenarios as the category turns agentic.

## Integrations

Google Sheets, Gmail, Slack, HubSpot, Airtable, Notion, OpenAI, Anthropic, Shopify, Stripe, Telegram, WordPress, Monday.com, ClickUp, Webhooks / any REST API (HTTP module)

## FAQ

### What is Make?

Make, formerly Integromat, is a visual automation platform where workflows are built as scenarios on a drag-and-drop canvas with native routers, iterators, aggregators, and error handlers. It connects around 2,000 apps, meters usage per operation, and is the mainstream category's price leader with paid plans from about $9 a month.

### How much does Make cost?

Free covers 1,000 operations a month with two active scenarios. Paid annual-billing tiers run from about $9 (Core, 10,000 operations) through $16 (Pro) and $29 (Teams) to custom Enterprise pricing, with operation allowances scaling by tier and top-ups available mid-month.

### What counts as an operation in Make?

Each module execution is one operation: a scenario with six modules consumes six operations per run. Filters and routing decisions are effectively free, but every acting module bills, so cost scales with both volume and scenario length, the same shape as Zapier's tasks at a much lower per-unit price.

### Is Make cheaper than Zapier?

At comparable workloads, usually much cheaper: entry per-operation cost is a small fraction of Zapier's per-task pricing, and the $9 Core tier includes logic features Zapier gates behind higher plans. Zapier justifies its premium with a four-times-larger app catalog and an easier editor, not with unit economics.

### Is Make or n8n better for complex workflows?

Both handle complexity well by different philosophies. Make expresses logic visually (routers, iterators, error handlers) without code and is easier for non-developers; n8n adds real code nodes, self-hosting, and per-execution pricing that beats any per-step meter on long pipelines. Visually-minded and budget-anchored teams pick Make; technical teams with long waterfalls pick n8n.

### What happened to Integromat?

It became Make. Integromat launched in Prague in 2016, was acquired by Celonis in October 2020, and relaunched as Make in February 2022 on a rebuilt platform. Legacy Integromat scenarios were migrated; the product's logic-rich canvas philosophy carried over intact.

### Does Make have AI features?

Yes: native modules for OpenAI, Anthropic, and other providers drop AI steps into any scenario; AI-assisted building drafts scenarios from plain-language descriptions; and Make AI Agents (2025) act goal-directedly, using your scenarios and connections as tools. The agent layer is newer and shallower than n8n's, but the core AI modules are solid.

### Can Make handle processing lists and batches?

This is a signature strength: iterators explode arrays into per-item bundles, aggregators reassemble results, and per-branch filters control flow, so row-by-row and order-line-by-order-line processing is native canvas work rather than the workaround it is in linear tools.

### Does Make offer EU data residency?

Yes, uniquely among the mainstream self-serve automation platforms: you choose an EU or US data center when creating your organization, which satisfies most European SMB residency requirements without an enterprise contract.

### Who owns Make?

Make is a subsidiary of Celonis, the process-mining company, which acquired it (as Integromat) in October 2020 for a reported ~$100M. It operates from Prague with Celonis's enterprise resources behind it, unusual financial stability for a product with a $9 entry price.

## Editorial verdict

Make is the category's honest bargain: the logic primitives that make automation genuinely programmatic, branching, iteration, aggregation, error handling, delivered visually, included at every tier, and priced beneath everyone. For the typical SMB workload it does 90% of what either neighbor does at clearly the lowest bill, with an EU-residency option nobody else offers self-serve. Its concessions are the catalog's long tail (Zapier's) and long-pipeline unit economics plus AI-agent depth (n8n's), which mark the two exits power users eventually take. Between those edges sits most of the market, and for it, Make is the value pick without much argument.

## SaaSTracker awards

- Best Value (GTM Engineering, Summer 2026): "Routers, iterators, and error handlers on a $9 tier: the logic features rivals gate behind higher plans, at the category's lowest per-operation price."

---

Source: SaaSTracker (https://saastracker.org), an independent editorial project. This profile is compiled from public information, carries no peer reviews or paid placement, and was last reviewed 2026-08-22. Awards are judged on published criteria: https://saastracker.org/methodology