How to migrate from Make to n8n

Export Make blueprints and run history, rebuild each live scenario as an n8n workflow, map routers and error handlers, move webhooks and cut over.

Start with one workloadThe steps

Written for
The engineer who will do the work
Or run by Pilae
At a fixed price, then operated

In short

  • n8n cannot import Make blueprints, but each blueprint holds every module, setting and mapping of a scenario, so it is the specification each workflow is rebuilt from.
  • Make keeps run history only as long as the plan allows, so it is exported more than once, and the monthly and quarterly jobs are found from their schedules.
  • Every Make connection is created again as an n8n credential, and each webhook sender is switched to n8n before the Make queue is drained and the scenario turned off.
  • Make error handlers become node settings and error workflows; writes that relied on Rollback are grouped into one database transaction.
On this page (13)

Moving from Make to n8n is an export followed by a rebuild. Make hands over each scenario as a blueprint, a JSON file that records every module, setting and mapping, and n8n has no way to import it. So each scenario that still does work is built again as an n8n workflow, its connections are created again, and the systems that call its webhooks are pointed somewhere new. People who know Make find their way around n8n quickly, because both are visual canvases where data flows through branches, loops and error handling. The differences sit in the details, and this guide takes them in the order we run the move.

Why teams move from Make to n8n

Make has one of the most capable visual builders on the market, and many teams reach it after outgrowing simpler tools. When they leave, it is usually for these three reasons.

  • Every module run is metered. Make bills in credits, and most module runs cost one. A scheduled scenario that wakes up, checks for new data and finds none still uses a credit, so a scenario that polls every few minutes spends credits all day. On your own n8n instance the cost is the machine and its operation, whatever the volume.
  • Systems that were never meant to face the internet. Make runs in its own cloud, in EU or US data zones, and reaches what can be reached from there or, on the Enterprise plan, systems behind an on-premises agent you install in your network. n8n runs inside your network, next to the ERP, the database and the file share it automates.
  • Credentials under your own key. A Make organisation collects connections to the CRM, the mailbox and the accounting system. In n8n they sit in your own database, encrypted with a key you hold.

What you give up is Make’s polish and its catalogue of ready-made modules, which covers some apps n8n has no node for. The HTTP Request node reaches any of them that has an API, at the cost of building the call yourself. Make’s commit and rollback on transactional modules has no direct equivalent either, as step 3 explains. And someone else runs the platform today: that is the part Pilae takes on.

Step 1: export blueprints, run history and data stores

Take three exports before anything changes. None of them is complete on its own.

  1. Blueprints. Open each scenario and, in the Scenario Builder, click the three dots in the upper-right corner, then Export blueprint. Make downloads a .json file named after the scenario, holding its modules, their settings and their mapped values. It does not hold connections. With many scenarios, script it: the Make API returns each blueprint, and its scenario list says for each one whether it is active, how it is scheduled, which apps it uses and which webhook starts it.
  2. Run history. In each scenario, the History tab has Export to CSV in its three-dot menu: one row per run, with its status, time, operations and duration. The same menu hides check runs, the scheduled runs that found no new data, which leaves the runs that did something. Make keeps run history only as long as your plan allows, so export it now and again at shorter intervals than that until the cutover.
  3. Data store records. A blueprint describes a scenario, not the data it keeps. Records in Make data stores come out through the Make API, which lists a store’s records page by page, or through a short scenario that searches the store and writes a CSV file. Write down each store’s data structure as well: its fields and their types become the columns of the table that replaces it.

Step 2: sort the scenarios by what they actually do

A Make organisation keeps every scenario anyone ever switched on. With the history exports and the scenario list side by side, give each scenario one of three outcomes. It is rebuilt if it ran and did work in the period and someone can say what depends on it. It is merged if several scenarios do variations of one job, or a chain of scenarios calls one another: in n8n these usually become one workflow, or a workflow and its sub-workflows. It is left behind if it is switched off, if its history holds only check runs, or if nobody can say what it is for.

For each scenario you keep, record the following.

What to record Where Make shows it
The trigger: a schedule, an instant trigger, a webhook, a mailhook or another scenario The first module and the schedule settings
The schedule, with any start and end dates The scenario’s schedule settings
Every connection, and the account it belongs to Credentials, then Connections: the scenarios icon lists the scenarios that use each one
Every system that calls its webhook The webhook’s logs show recent requests; the owners of the sending systems confirm the rest
The data stores it reads or writes Its data store modules
The error handler on each module The handler routes in the editor, onerror in the blueprint
Runs waiting to be finished The scenario’s Incomplete executions tab

Find the monthly, quarterly and yearly jobs from their schedules, not from the history. A scenario set to run Monthly or on Specified dates may not appear in a month of history at all, and it is exactly the job a short parallel run misses.

Step 3: map Make concepts to n8n nodes

Most Make ideas have a direct counterpart. The names differ more than the behaviour.

Make n8n
Scenario, module, bundle Workflow, node, item
Scheduled trigger (regular intervals, daily, monthly) Schedule Trigger node, or the app’s trigger node
Instant trigger, or Webhooks > Custom webhook The app’s trigger node, or the Webhook node
Webhook response Respond to Webhook node
Custom mailhook Email Trigger (IMAP) node, reading a mailbox
Filter between two modules Filter node, or If node
Router, with a fallback route Switch node, with an extra output for the fallback
Iterator Usually nothing: nodes run once per item. Split Out for a nested list
Array aggregator Aggregate node
Numeric and text aggregators Summarize node: Sum, Average, Count, Concatenate
Data store and its data structure n8n data table, or a PostgreSQL table
Scenarios > Call a scenario Execute Sub-workflow node
HTTP modules HTTP Request node
Functions in mapped fields Expressions, written in JavaScript
Connection Credential
Keep data confidential (scenario setting) Workflow settings that stop n8n saving successful executions

Bundles already behave like items

Make users have an advantage here. A Make module that outputs several bundles makes every module after it run once per bundle, and n8n does the same with items. The difference is that n8n needs no iterator to start the loop: a node that returns fifty rows passes fifty items on. Most Make iterators therefore disappear in the rebuild. Keep the Split Out node for the case where one item holds a list, such as an email with its attachments. At the other end, use Aggregate or Summarize wherever Make had an aggregator, so that one summary email is sent instead of fifty.

Routers become Switch nodes

Make processes a router’s routes one after another, in the order you set, and its fallback route takes the bundles that matched no other route. The n8n Switch node sends each item to the first matching output by default. Where a Make router let one bundle down several routes, turn on Send data to all matching outputs. Where it had a fallback route, set Fallback Output to Extra Output. n8n also runs branches one at a time, from the topmost on the canvas to the bottom, so place the branch that must finish first at the top.

Error handlers become settings and branches

Make attaches an error handler route to a module. n8n puts the same decisions in the node’s On Error and Retry On Fail settings, plus an error workflow for the whole workflow. Make renamed two of its handlers in May 2026, so older notes and tutorials still say Break and Ignore.

Make error handler In n8n
No handler: the run stops Stop Workflow, the default, with an error workflow that alerts the owner
Skip (formerly Ignore) Continue (using error output), with the error output logged or left unconnected
Resume Continue (using error output) into an Edit Fields node that supplies the substitute value
Retry (formerly Break) Retry On Fail for temporary errors; failed executions are retried from the Executions list
Commit Stop Workflow: what earlier nodes wrote stays written
Rollback No transaction across nodes: put the writes in one database node, run as a single transaction

Rollback is the one that needs thought. In Make it only ever reverted the modules labelled ACID, such as Data Store and MySQL; a sent email stayed sent. In n8n, writes that must succeed or fail together go into one node: the Postgres node’s Query Batching option set to Transaction, for example, rolls back every query if one fails. When you retry a failed n8n execution, the nodes that completed are not rerun, but the failed node processes all of its input again, so check the target system for duplicates first.

Mapped functions become expressions

Make’s functions in a mapped field become expressions in n8n, written in JavaScript between double curly braces. Dates are where copied formats break: Make writes a four-digit year as YYYY and the day of the month as DD, while n8n’s expressions use the Luxon library, where they are yyyy and dd. Test every date field against a real run.

Step 4: rebuild and test each workflow

Start with scheduled scenarios that read more than they write, and keep the webhook-triggered ones until their addresses can move in step 5.

  1. Recreate the trigger and fire it once with real data. For a Webhook node, send the request to its test address while the editor listens; n8n keeps the output to build the rest against.
  2. Pin that output, so the following nodes can be rerun without firing the trigger again or writing to a live system.
  3. Rebuild from the blueprint, module by module. Each module in its flow array lists its mapped values under mapper and its error handler under onerror. Where a mapping is unclear, a run’s details in the Make history show what the module actually produced.
  4. Recreate the data stores. In n8n, open the Data tables tab, create a data table and choose Import CSV to load the records exported in step 1. Data tables share one size limit across the instance, so a large store, or one that other systems should read, belongs in a PostgreSQL table instead.
  5. Set an error workflow. One workflow that starts with the Error Trigger node can serve every migrated workflow: it alerts the owner and records the input that failed. Select it in each workflow’s settings.
  6. Compare outputs. Send the same input to both systems and diff what each one wrote.

Step 5: re-create connections and move webhooks

Make connections do not transfer. Each one is created again as an n8n credential, by someone with access to the account on the other side. Work from the list in step 2, so a connection that served ten scenarios is created once.

  • Use service accounts wherever the target system offers them, rather than a person’s login. It saves a rebuild when that person leaves.
  • Keep the encryption key safe. n8n encrypts every credential in its database with a key set when the instance is created. Store that key in your secrets store and in your backup plan: a database restored without it cannot decrypt a single credential.
  • Move webhook senders one at a time. Each custom webhook becomes an n8n Webhook node with its own address on your host. Give senders the production address, which answers once the workflow is published. Where the Make scenario answered with a Webhook response module, set the Webhook node to respond through a Respond to Webhook node.
  • Repoint mailhooks. A mailhook is an address Make generated, fed by a forwarding rule in your mail system. In n8n, the Email Trigger (IMAP) node reads a mailbox, so the forwarding rule points at a mailbox on your own mail service.
  • Drop the internal webhooks. Scenarios that called one another, through Scenarios > Call a scenario or through a webhook, become sub-workflow calls with the Execute Sub-workflow node. There is no address left to move.

Make stores every incoming request in that webhook’s queue until a scenario processes it. Before you switch off a webhook scenario, open Webhooks in the left sidebar and check that the webhook’s queue is empty: anything still in it has not been processed.

Step 6: run both in parallel, then cut over

Run the two side by side, and let only one of them act on the outside world at a time. While n8n proves itself, point its writing nodes at a test target or a log. When it takes over, switch the Make scenario off, or remove its writing modules, so nothing is created twice. The Make history and the n8n Executions list are the two records you compare.

The cutover, in order

  1. Senders: Each webhook sender moves to n8n, and the Make queue is empty before its scenario goes off.
  2. Schedules: Scheduled scenarios go off in the order they were rebuilt, on the day their n8n workflow takes over.
  3. Loose ends: Incomplete executions in Make are finished or written down, so no half-done run is left behind.
  4. Full cycle: Every kept workflow runs a full cycle in n8n, including the monthly and quarterly jobs found in step 2.
  5. Archive: The last history export, the blueprints and the data store exports are kept as the record of what ran; then the subscription ends.

Running n8n in production

A migrated estate needs the same foundations as any production n8n: PostgreSQL rather than the default SQLite, queue mode with Redis and separate workers once the volume calls for it, pruning of execution data, and the encryption key backed up apart from the database. Teams used to Make’s Keep data confidential setting can turn off saving of successful executions per workflow, so payloads are not kept after a run.

Pilae operates n8n on that basis, with daily encrypted backups stored offsite and, on Enterprise, a restore test every month recorded in the console. It runs on your premises or on dedicated machines in Pilae Cloud, answering only on your private network, with the webhook addresses that outside systems call published through its one public gate. If part of your estate runs on Zapier, the Zapier to n8n guide covers that half; for a wider comparison first, see our page on Make alternatives.

Let Pilae run the move

Pilae runs Make to n8n migrations at a fixed price: the exports and inventory, the rebuild, the credential and webhook moves, the parallel run and the cutover. Then we operate n8n for you under a contract that, from the Business plan, includes a monthly availability commitment with service credits. See migration services for what the fixed price covers, or tell us about your Make organisation and we will scope it.

Questions

Can n8n import Make blueprints?

No. A Make blueprint is a JSON file holding every module, its settings and its mapped values, but n8n has no importer for it, and the two tools handle errors and transactions differently. Community converters exist; at best they produce a draft that still has to be checked node by node. The blueprint is still where the rebuild starts: it is the written specification of each scenario.

What replaces routers, iterators and aggregators?

A router becomes a Switch node, with every matching output turned on where routes overlap and an extra output for the fallback route. Most iterators disappear, because n8n nodes already run once per item; the Split Out node handles a list held inside one item. The Array aggregator becomes the Aggregate node, and the numeric and text aggregators become the Summarize node.

What happens to our error handlers?

Each one becomes a node setting or a short branch. Skip and Resume use the node's error output, Retry becomes Retry On Fail, and a run that stops is reported by an error workflow. Rollback has no direct equivalent, because n8n does not hold a transaction open across nodes: writes that must succeed or fail together go into one database node.

What happens to our data stores and webhook URLs?

Data store records are not in the blueprint. They are exported through the Make API or a short scenario, then imported into an n8n data table from CSV, or into PostgreSQL. Webhook URLs change: every system that calls a Make webhook is pointed at the address of the matching n8n Webhook node.

Is n8n open source?

n8n is source-available under the Sustainable Use Licence. You may run it for your own internal business purposes without paying n8n, and Pilae runs a dedicated instance for your organisation, which fits those terms; we confirm the licence position with n8n before deployment. Reselling access to it as a hosted service needs an agreement with n8n.

How long does a Make to n8n migration take?

It depends on how many scenarios still do work, not on how many sit in the organisation. The inventory settles that first. Pilae quotes the rebuild, the parallel run and the cutover as one fixed price once the inventory is done.

Let us run the move for you

An inventory, a parallel run and a cutover plan, at a fixed price. Then we operate the app.

Start with one workload

  • Go deeperSaaS migrationA fixed-scope migration off Google Workspace, Microsoft 365, Zapier, Airtable and ChatGPT to open-source apps, with a parallel run and a cutover plan.
  • CheckManaged operationsPatching, daily encrypted backups, monitoring and incident response for your open-source apps, under an SLA with an availability commitment of up to 99.9%.