MAKE · TECH
Make (formerly Integromat): visual scenarios with 1,500+ apps and EU hosting region
Make is a US/EU cloud platform for visual automation scenarios, 1,500+ apps, and operations-based pricing from USD 10.59/10k ops.
Researched & fact-checked by: DuneDive LLC · As of: 2026-05
What is Make?
Make (formerly Integromat, founded 2016 in Prague, owned by Celonis since 2020) is a proprietary cloud platform for visual workflow automation. The tool targets marketing, sales, and operations teams that want to wire several SaaS apps together without code skills. Inside the editor, scenarios are built: a trigger starts the chain, additional modules process the data, filters, routers, and iterators model the logic.
As of May 2026, Make connects more than 1,500 apps – from Google Workspace and Microsoft 365 through Salesforce, HubSpot, Notion, Airtable, Slack, Stripe to industry tools such as Bexio, Lexoffice, or DocuSign. Generic HTTP modules cover any REST/JSON API; a webhook module receives external input. Since 2024 dedicated AI modules for OpenAI, Anthropic, Mistral, ElevenLabs, and Stability AI are available; the "Make AI Agents" feature (2025+) adds tool-using agents directly inside scenarios.
Commercially Make runs as a cloud service only – self-hosting is not on the roadmap. Since early 2025 customers can pick the region (US or EU) when creating the org; a later switch is not possible. Pricing is operations-based: every module step in a scenario is one operation. The Pro tier starts at USD 10.59 per month for 10,000 operations, higher tiers up to Enterprise scale into the millions. A complex 20-step scenario therefore consumes 20 operations per run.
In the Swiss fiduciary context we see Make most often where marketing teams assemble lead funnels from HubSpot, Mailchimp, and LinkedIn Ads – the EU region allows a defensible risk position for marketing data, while client data typically still belongs on self-hosted platforms (n8n, Activepieces).
Why it matters
Make is roughly a third cheaper per operation than Zapier and offers a markedly more powerful visual editor at a comparable app range. Anyone automating a marketing stack with 1-3 people often gets there faster with Make than with any self-hosted alternative – no server setup, no updates, no backup plan.
For a Swiss fiduciary with marketing activities there are three concrete levers. First: lead capture funnel. A website form sends a webhook to Make, Make enriches the data via Clearbit or Apollo, runs an AI module to filter spam, creates a new contact in the HubSpot CRM, and notifies the sales team via Slack. 5-7 operations per lead, at 200 leads/month around 1,000-1,400 operations – the Pro tier at USD 10.59 covers this with headroom.
Second: content distribution. A new blog post in WordPress triggers a scenario that automatically posts to LinkedIn, X, Bluesky, and Mastodon, sends a preview mail to the newsletter list, and documents in the internal Notion workspace. Such multi-channel posts can be built in Make in 20 minutes; in Zapier they are often not possible due to limited filter logic.
Third: AI-assisted content classification. Incoming contact requests are classified by the OpenAI module by topic (VAT, payroll, year-end close, AML) and routed to the responsible person. The logic stays visually traceable – for marketing leads who rarely sit in code reviews, that is a real advantage over code-first solutions.
The EU region (selectable since 2025) reduces the data-protection risk for marketing data. For highly sensitive client data the transfer-impact-assessment duty still applies: Make processes the data in the EU but, as part of Celonis (a US-adjacent group), remains theoretically exposed to US CLOUD Act access. Anyone handling professional-secrecy data (Art. 321 SCC) does not belong on Make.
How it works
A Make scenario consists of modules connected by routes. Unlike n8n, modules run sequentially along the route – one module processes its input, hands the result downstream, then the next runs. The bundles concept allows iteration: a module can output several records (e.g. rows from a Google Sheet) and following modules process each record individually.
Key module types: triggers (time- or event-based), actions (HTTP calls, app operations), searches (read data from external systems), filters (conditional routing), routers (parallel paths with different logic), iterator (split list into individual items), aggregator (recombine items into a list), and tools (set variables, date conversion, JSON parsing).
A typical AI scenario for client triage: webhook module receives an incoming email (forwarded from the mail provider) -> OpenAI module classifies into 4 topics -> router splits into 4 branches -> each branch creates a different HubSpot ticket and sends a different Slack message -> aggregator collects all branches for a reporting module. In the operations counter that adds up to 5-7 operations per email.
Data structures are strictly typed. Make automatically parses responses into a structure (strings, numbers, dates, arrays, collections) and exposes them via drag-and-drop in following modules. Built-in functions (formatDate, parseDate, replace, get, map) cover all common transformation needs. Where real JavaScript is required, a "Custom JS Module" can be embedded or an external Lambda triggered via an HTTP module.
Error handling works per module: every module has an optional error-handler path triggered on exceptions. Three strategies are built in: Resume (ignore data, continue), Rollback (revert all previous changes), Commit (continue despite the error, keep changes). For client operations, Rollback is usually the right choice.
Make setup in 5 steps
- 01Create the organisation account, mandatorily picking the EU region (not changeable later). Subscribe the Pro tier for 10,000 operations.
- 02Connect apps: set up OAuth connections for HubSpot, Google Workspace, Slack, Stripe, and optionally Bexio/Lexoffice – connections are reusable across the org.
- 03Build the first scenario: webhook trigger -> 2-3 modules with filter -> action module. Test run inside the editor, check operations consumption.
- 04Add error-handler routes: per critical module a rollback or resume route with a Slack alert to the operations team.
- 05Set up monitoring: Make built-in dashboard for operations consumption and scenario success rate, alert when operations exceed 80% of the tier limit.
When to use Make
Make is the right pick when (a) a marketing or sales team should automate without engineering resources, (b) the apps in use are in the 1,500+ list, (c) data protection with the EU region is judged sufficient, and (d) the operations budget matches the expected workflow volume.
Concrete cases: marketing funnels (lead capture -> enrichment -> CRM -> nurturing sequence), social-media distribution (one post into multiple channels), e-commerce triggers (new Stripe charge -> bookkeeping -> confirmation mail -> customer onboarding), internal reporting automation (daily data from 5 SaaS tools into a Slack summary), and multi-app synchronisation (Notion <-> Airtable <-> Google Sheets).
For teams without DevOps capacity the trade-off is clear: Make costs around CHF 15-50/month for typical scenarios, covers 90% of common SaaS apps, and needs no server. The question is not "self-host or Make" but "Make or no automation at all". Anyone facing that question is better served by Make than by trying to run n8n without engineering support.
For AI-driven classification and routing, the native AI modules are convenient. Anyone deploying OpenAI or Anthropic in the marketing stack and judging the data non-critical finds Make a quick implementation.
When not to use
Make is wrong for professional-secrecy data (lawyer, fiduciary, doctor, banker). Even with the EU region, the cloud architecture remains a third-country risk through the parent company. Client mail, tax data, payroll data, VAT receipts belong on self-hosted n8n or Activepieces – not in Make.
Make is unsuited at very high operations volumes. Anyone needing 500,000+ operations per month quickly pays USD 500-2,000/month in the Enterprise tier – for that money, self-hosting on Hetzner including engineering effort is fundable.
Make does not fit complex code requirements. The custom JS module is limited (no npm install, no external libraries beyond what Make ships). Anyone needing Python pandas, Selenium, or specialised SDKs has to route through external Lambdas – at which point Pipedream, Windmill, or a direct code solution is faster.
For data pipelines (ETL, data-warehouse loading, cleansing), Make is overpriced. Per-operation pricing ruins any ETL scenario that writes more than 50k rows per run. Airflow, dbt, or Airbyte are the more productive tools.
No self-hosting option – anyone needing data on own hardware for regulatory reasons has no path in Make.
Trade-offs
STRENGTHS
- Visual editor with router, iterator, aggregator – more powerful than Zapier
- 1,500+ apps, broad SaaS coverage for marketing and sales stacks
- EU region selectable since 2025, reduces data-protection risk for marketing data
- Operations pricing typically 30-50% cheaper than Zapier on complex scenarios
WEAKNESSES
- No self-hosting, not suitable for professional-secrecy data
- Per-operation model ruins data ETL and high-volume scenarios
- Custom JS module limited, no npm libraries or Python packages
- Region selection is final – switching from US to EU means rebuilding all scenarios
FAQ
How is Make different from Zapier?
Make bills per operation (every module step counts), Zapier per task (one action counts). For complex scenarios with filters, routers, and several actions, Make is often 30-50% cheaper. The visual editor in Make is more powerful (router, iterator, aggregator native), Zapier has more apps (7,000+ vs. 1,500+). For marketing teams with complex logic, Make is usually the better choice; for broad app coverage, Zapier.
What does Make cost in production?
Pro tier from USD 10.59/month for 10,000 operations. Teams tier from USD 18.82/month for 10,000 operations plus team features (permissions, audit log). Enterprise on request, typically USD 500+/month. Additional operations packs can be purchased (e.g. 20,000 ops for USD 18.82 Pro). A five-person fiduciary with a marketing stack typically lands at 30-100k operations/month – Pro tier with top-up or Teams tier fits.
Can Make be self-hosted?
No. Make is a cloud service only. The EU region (selectable since 2025) shifts data processing into the EU but does not change the cloud model. Anyone needing self-hosting goes to n8n, Activepieces, or Windmill.
Are the AI modules in Make safe for client data?
The AI modules call external providers (OpenAI, Anthropic, Mistral). Using the OpenAI default endpoint flows data to the US – third-country transfer. Mistral has EU hosting, Anthropic is US. Make itself stores operations logs in the chosen region. For professional-secrecy data the "Make + OpenAI" combination is not admissible; for less sensitive marketing data it can be defensible after a transfer-impact assessment.