How to Migrate From Zapier to Make.com
Zapier and Make.com (formerly Integromat) solve the same core problem, but they grew up with different philosophies. Zapier optimized for simplicity: linear steps, minimal configuration, a UI anyone can use in 20 minutes. Make.com optimized for power: a canvas where you can see every connection at once, a pricing model based on operations rather than tasks, and data structures that let you manipulate arrays and aggregate records without leaving the visual editor.
The teams moving from Zapier to Make.com usually reach the same tipping point: they've tried to build something with multiple paths, array manipulation, or iterating over a list, and Zapier's linear model has forced a workaround that's fragile or expensive. Make's visual scenario canvas and its Aggregator/Iterator pair handle those patterns natively. The pricing difference is real too: Make sells operations, and a single scenario execution with five modules costs five operations, regardless of complexity. Zapier counts every action step as a task. At volume, Make's per-operation model is often significantly cheaper.
What's actually different
The mental model shift is the biggest adjustment. Zapier workflows are a vertical list of steps. Make scenarios are a diagram. You can see data flow, branching, and merges visually, which helps with complex scenarios but can feel overwhelming when you first open the canvas.
| Dimension | Zapier | Make.com |
|---|---|---|
| Pricing unit | Task (per action step) | Operation (per module execution) |
| Visual model | Linear list | Canvas / diagram |
| Data iteration | Limited (line items) | Iterator + Aggregator native |
| Branching | Paths (up to 5) | Router with unlimited routes |
| Error handling | Basic catch-all | Error handler routes per module |
| Scheduling | Every 1-15 min (plan-dependent) | Every 1 min on paid plans |
| Webhooks | Instant | Instant |
On pricing: Make's free plan gives 1,000 operations/month. Their Core plan at ~$10.59/month gives 10,000 operations. Zapier's Starter plan at $19.99/month gives 750 tasks. For many real-world workflows, Make.com costs 60-70% less than an equivalent Zapier setup.
The operations count deserves attention. In Make, every module that executes costs one operation. A scenario with 6 modules that runs 100 times costs 600 operations. In Zapier, a 6-step Zap that runs 100 times costs 500 tasks (trigger is free). The math usually still favors Make.com, but it's worth modeling your specific workflows before assuming it's always cheaper.
Mapping your existing workflows
Zapier's building blocks translate to Make.com almost directly, though the names differ.
A Zap becomes a scenario. You build it on Make's canvas by clicking the circle to add modules. The first module is always the trigger.
A Zapier trigger maps to a Make trigger module. Most major apps have equivalents on both platforms. Make's trigger module often offers more configuration options for filtering at the source.
A Zapier Filter step becomes a Router with a filter condition on the route. In Make, you add a Router module, then set the filter on each route path. Routes that don't match simply don't execute. You can also use the Filter tool, which sits between two modules and stops execution if conditions aren't met.
A Zapier Paths step maps to Make's Router module. The Router splits execution into multiple paths, each with its own filter condition. Unlike Zapier's Paths limit of 5, Make's Router supports as many routes as you need.
A Zapier Formatter step is where Make.com genuinely shines. Make's built-in functions for string, date, and number manipulation are accessible inline in any field via its formula editor. You rarely need a dedicated transformation module. For complex transformations, the Tools module handles most cases.
Iterating over a list is the biggest capability gap that drives people to Make. In Zapier, if you want to loop through an array of records, you need Looping by Zapier, which is a paid add-on and limited. In Make, you drop an Iterator module to split an array into individual bundles, process each one, then optionally use an Aggregator to recombine results. This is a first-class, standard feature.
A Zapier AI step maps to Make's OpenAI module or any of the other AI modules (Anthropic, Google AI, etc.) in Make's app library. Make's AI modules support the same parameters: model selection, system prompt, temperature.
The actual migration steps
Step 1: Audit your Zapier account. Log into Zapier, go to My Zaps, and export or document every active Zap. For each one, note the trigger app, all action steps, any filters or paths, and the approximate monthly task count. This gives you a complete inventory and helps you prioritize.
Step 2: Create your Make.com account. Sign up at make.com and explore the interface. The canvas is different enough from Zapier that spending 30 minutes clicking through a sample scenario before building anything real is worth it. Make's scenario builder tutorial covers the core concepts.
Step 3: Reconnect your apps. In Make.com, go to Connections and authenticate each service you use. OAuth flows work the same way as Zapier, but the tokens are separate. Some apps require creating a new API key specifically for Make.
Step 4: Rebuild a pilot scenario. Choose a simple but real workflow: something with 3-5 steps, a clear trigger, and a measurable output. Rebuild it in Make, map each Zapier step to the equivalent Make module, activate the scenario, and run it. Compare outputs against your Zapier Zap running in parallel.
Step 5: Handle webhook URL updates. For any Zapier Zap triggered by an incoming webhook, Make will generate a new webhook URL. Before you activate the Make scenario and deactivate the Zap, update every external service that posts to the Zapier webhook URL to point to the Make URL instead.
Step 6: Migrate in batches. Once you're confident with one scenario, work through your inventory in order of volume or criticality. Deactivate each Zapier Zap after its Make equivalent has run successfully in production for a few days.
Gotchas you'll hit
Operations can add up faster than expected. If your scenario includes modules inside an Iterator loop, every iteration counts operations. A scenario that iterates over 50 records and runs 3 modules per record costs 150 operations per execution, not 3. Model your complex scenarios before choosing a Make plan.
Webhook URLs must be updated manually. This is the most time-consuming part of any migration. Make a list of every external service, Slack bot, CRM, or payment processor that posts to a Zapier webhook before you start. Changing these one by one is the migration's actual work.
Make's scheduling is real-time on paid plans. Zapier's free plan polls every 15 minutes. Make's free plan polls every 15 minutes too, but paid plans go to every 1 minute. If you're currently on Zapier Starter and relying on near-real-time triggers, Make's Core plan or higher gives you parity.
Error handling is more powerful but requires setup. Make lets you add error handler routes that only activate when a module fails. This is much better than Zapier's all-or-nothing error email, but you need to actually wire it up. Unhandled errors in Make will pause the scenario after a few failures until you acknowledge them.
Data types are stricter in Make. Zapier is fairly lenient about coercing field types. Make is stricter. If a field expects a number and receives a string, you'll get a module error. Use Make's formula functions to cast types explicitly when mapping data between modules.
Scenario version history is limited on lower plans. Zapier has some version history for Zaps. Make's version history for scenarios is more limited on the free and Core plans. If version history matters for compliance or rollback, check the plan details before committing.
When NOT to switch
Make.com isn't the right choice in every situation.
If your team has non-technical members who manage automations, Zapier's simpler linear interface is genuinely easier to learn and hand off. Make's canvas is powerful but has a steeper onboarding curve.
If you rely heavily on Zapier's 7,000+ app integrations for long-tail SaaS tools, Make's app library (~1,000+ apps) may not have a native module for everything you use. Check that all your key apps exist in Make before migrating.
If you run very high volumes with short-duration tasks, model the operation costs carefully. There are edge cases where Zapier's task pricing ends up cheaper for certain workflow shapes.
The visual scenario builder is genuinely better for complex automation logic, and the pricing advantage at mid-to-high volumes is real. Most teams that make the switch find the migration itself takes less time than expected: the webhook URL updates and credential reconnections are the main work, not the workflow logic translation.
Pick your most common workflow, rebuild it in Make this week, and let the cost and capability difference show you whether the full migration makes sense for your stack.