The Complete Guide to Make.com (2026)

What is Make.com?

Make.com lets you build automations by dragging and dropping modules on a canvas — no code required. Think of it as digital plumbing for your business: data flows in from one app, gets transformed, filtered, branched, and lands in another app, all on autopilot.

If you've ever thought "I wish my CRM would just talk to my email tool" or "I'm tired of copying data from one spreadsheet to another," Make.com solves exactly that problem — and dozens of others you haven't yet realized you have.

The platform was founded in 2012 in Prague (originally as Integromat by Czech entrepreneur Ondřej Hrubý) and rebranded to Make.com in 2022 after acquisition by Celonis. As of 2026, Make is one of the three giants of no-code automation alongside Zapier and n8n, and is widely considered the most powerful for visual workflow building.

Why Make.com matters in 2026

The automation landscape changed dramatically in 2024-2026. Three forces reshaped what businesses expect from automation tools:

1. AI is no longer optional

Every serious business workflow now involves AI somewhere — classification, generation, decision-making, content extraction. Platforms that treat AI as a first-class citizen have a massive advantage. Make's native modules for OpenAI, Anthropic Claude, Google Gemini, Mistral, Cohere and Replicate make AI integration trivial. Switching providers is a one-click change. Building agentic workflows is a documented pattern, not a hack.

2. Cost discipline is back

The era of "automation at any cost" is over. CFOs scrutinize SaaS spend, including automation tools. Make's pricing — typically 3-5x cheaper than Zapier at equivalent volume, with per-workspace billing — has become a compelling pitch in CFO conversations.

3. Visual builders win against code-only iPaaS

Enterprise iPaaS platforms (Workato, Mulesoft, Boomi) require dedicated integration engineers. Code-only solutions (custom services, n8n self-hosted) require DevOps. Make.com's visual builder lets PMs, CSMs and ops folks build their own automations without bottlenecking engineering.

Make.com vs Integromat — what changed?

The Integromat-to-Make rebrand happened in two phases:

• February 2022: New brand identity, new logo, new domain (make.com)
• April 2022: Full UI redesign, dark mode, redesigned module palette

Since then, Make has shipped major updates including:

Year	Major addition
2022	Rebrand, new UI, dark mode
2023	Make AI assistant (natural language scenario building)
2024	AI Agents (autonomous workflows), expanded LLM provider support
2025	MCP server support, native Claude integration, advanced agent patterns
2026	Improved templates marketplace, EU/US data residency, custom AI model support

Core concepts you must understand

Scenarios

A scenario is a single automation workflow. It has a trigger (the event that starts it) and one or more modules (the actions that follow). Each scenario lives on a visual canvas where you connect modules with lines, in the order data should flow.

You can have unlimited scenarios on any paid plan. Each scenario can be activated or deactivated independently. Scenarios run on schedules (every 15 min, hourly, daily) or instantly via webhooks.

Modules

A module is a single step in a scenario. There are five types:

Module type	What it does	Examples
Trigger	Starts the scenario	Watch new emails, watch new rows, receive webhook
Action	Performs an operation	Create a record, send a message, make HTTP request
Search	Finds matching records	Find a contact by email, search Google for...
Flow control	Routes or transforms flow	Router, iterator, aggregator, sleep, repeater
Transformer	Manipulates data	Text parser, JSON parser, set variable

Operations

An operation is one module run. If your scenario has 5 modules and processes 10 records, that's 50 operations. This is Make's primary pricing unit.

Most people overestimate operations consumption. Even at "heavy" use, a small business rarely exceeds 10,000 ops/month — well within the $10.59/month Core plan. Use our pricing calculator to estimate your specific volume.

Connections

A connection is the credentials Make stores to talk to an app on your behalf — typically an OAuth token or API key. You set it up once per app, and reuse it across all scenarios in your workspace.

Bundles

A bundle is one unit of data flowing through a scenario. If a trigger returns 10 emails, that's 10 bundles. Each bundle is processed independently, in sequence, through every subsequent module. Understanding bundles is the key to understanding why operations multiply quickly with iterators.

Your first scenario in 10 minutes

Let's build a real, useful automation: when someone fills out a form on your website, add them to a Google Sheet and send a Slack notification. This is the "hello world" of Make.com — and it covers 80% of what you'll do later with more complex scenarios.

1. Create a new scenario

   From the dashboard, click "Create new scenario." You'll land on the empty canvas with a single circle in the middle — that's where your trigger will live.

2. Add the webhook trigger

   Click the circle, search for "Webhooks," select "Custom webhook." Give the webhook a name (e.g., "Form submissions"), then Make generates a unique URL like https://hook.eu1.make.com/abc123.... Copy this URL — your form will POST data to it.

3. Determine the data structure

   Click "Re-determine data structure" on the webhook. Submit a test from your form. Make will show you what fields the form sends — these become available as variables in subsequent modules.

4. Add the Google Sheets action

   Click the "+" next to your trigger. Search "Google Sheets," select "Add a row." Connect your Google account (first time only), pick the spreadsheet, then map form fields to columns: drag {{1.email}} into the Email column, etc.

5. Add the Slack action

   Click "+" again. Search "Slack," select "Create a message." Connect Slack, pick a channel (e.g., #leads). Write your message: 🎉 New lead: {{1.name}} ({{1.email}}) — Make's mapping panel makes this drag-and-drop.

6. Test and activate

   Hit "Run once" and submit your form. The modules light up green if everything works. You'll see the actual row added to the Sheet and the message sent to Slack. Then toggle the scenario ON in the bottom-left corner. Done — your automation now runs forever, every time someone submits the form.

Total time: ~10 minutes. No code, no servers, no maintenance. This pattern (trigger → action → action) is the foundation of every more complex scenario you'll build.

Make.com pricing — the honest breakdown

Make.com's pricing is operations-based. The most important thing to understand is the difference between Make and competitors:

• Per workspace, not per user — your whole team builds in one workspace
• All apps included — no "premium connector" tax like Power Automate
• Predictable scaling — buy more ops without changing plans

Plan	Operations / month	Active scenarios	Min interval	Monthly price
Free	1,000	2	15 min	$0
Core	10,000	Unlimited	15 min	$10.59
Pro	10,000+	Unlimited	1 min	$18.82
Teams	10,000+	Unlimited	1 min	$34.12
Enterprise	Custom	Unlimited	1 min	Contact sales

Annual billing saves roughly 16%. Lock in once you've validated your usage pattern (typically 2-3 months in).

Extra operations are available at $9 per 10,000 ops on any paid plan — useful for occasional spikes.

For an in-depth breakdown of all plans, hidden costs, and how to estimate your bill, read our complete Make.com pricing guide.

How to estimate your operations volume

The simplest formula:

(modules per scenario) × (executions per day) × 30 × (number of scenarios)

Real-world examples:

• 5-module scenario, webhook-triggered ~50 times/day → 5 × 50 × 30 = 7,500 ops/month
• 4-module scheduled scenario every 15 min → 4 × 96 × 30 = 11,520 ops/month
• 3-module form scenario, 200 submissions/month → 3 × 200 = 600 ops/month

Make.com vs Zapier pricing — the real difference

This is the question we get asked most. The short answer: at equivalent volume, Make is typically 3-5x cheaper than Zapier.

Use our interactive pricing calculator to see the exact difference at your specific volume — including annual savings projections.

The 12 patterns every Make builder should master

1. Filter pattern

Add a filter between two modules to skip records that don't match a condition. Example: only forward emails from VIP domains. Filters are clickable on the connection line — set conditions like "email contains @bigcustomer.com." Each filter consumes 1 operation, regardless of whether it passes or blocks.

2. Router pattern

The Router module sends bundles down different paths based on conditions. Example: if a lead is from the US, send to sales-us; if from EU, send to sales-eu; otherwise send to sales-other. Each route can have its own sequence of modules.

3. Iterator pattern

If a module returns an array (like 10 line items in an order), the Iterator splits them into 10 individual bundles for downstream processing. Essential for any "for each item, do X" logic.

4. Aggregator pattern

The opposite of an iterator — combines multiple bundles back into one. Use cases: collect all order line items into a single Slack message instead of 10 separate ones; build a daily digest from individual events; combine multiple API responses into one record.

5. Error handler pattern

Right-click any module → "Add error handler." This creates a fallback path when the module fails. Pair with one of these directives:

Directive	Behavior	When to use
Resume	Retries the failed module	Transient API failures (5xx errors)
Rollback	Undoes previous module actions	Transactional consistency required
Break	Stops the scenario completely	Critical failures where stopping is safer
Commit	Marks the bundle as processed	Skip and continue
Ignore	Continues silently	Non-critical optional steps

6. Data Store pattern

Make's built-in lightweight database. Use it for caching API results, deduplicating events, sharing state between scenarios, or storing reference data. Up to 1 million records on paid plans.

Common use case: a "seen webhook IDs" data store to deduplicate webhook events that fire twice.

7. Webhook + scheduler hybrid

Combine a webhook trigger (real-time intake) with a scheduled scenario (nightly cleanup or batch reprocessing). Example: real-time order processing via webhook + nightly inventory reconciliation via scheduler.

8. Custom variables pattern

The "Set Variable" module stores a value within a scenario for reuse. Cleaner than repeating the same expression multiple times. Especially powerful when combined with Math.parse for converting AI string outputs to numbers.

9. AI structured output loop

The most reliable AI pattern in 2026. Ask the LLM to return JSON, parse it in the next module, and act on the structured data. Pair with retry logic in case the LLM produces malformed JSON. Use response_format: json_object on OpenAI or proper output schemas on Claude.

10. MCP server integration

New in 2025. Make can act as an MCP (Model Context Protocol) server, exposing your scenarios as callable tools to Claude, ChatGPT and other LLMs. Use case: a sales agent in Claude that can call your Make scenario "create_pipedrive_deal" autonomously.

11. Sub-scenarios pattern

For workflows exceeding the 40-minute scenario timeout, split logic across multiple scenarios. Scenario A processes 1,000 records and triggers Scenario B for each. Use a Data Store for shared state.

12. Sleep + retry pattern

For rate-limited APIs (Stripe, HubSpot, Shopify), insert Sleep modules with exponential backoff. Combine with error handler "Resume" for graceful degradation when rate limits hit.

Working with AI in Make.com (2026 edition)

AI is where Make.com really shines in 2026. The platform has first-class modules for:

• OpenAI — GPT-4o, GPT-4o-mini, o1, DALL-E 3, Whisper, embeddings
• Anthropic — Claude Opus 4.7, Sonnet 4.6, Haiku 4.5 (the latest models)
• Google AI — Gemini 2.5 Pro, Gemini Flash
• Mistral — Large 2, Small, Codestral
• Cohere — Command R+, embeddings
• Replicate — Stable Diffusion, Flux, custom models
• HuggingFace — open-source models via Inference API

The structured output pattern (most reliable)

The single most important AI pattern: ask the model to return JSON, parse it, act on it. Avoid free-form text outputs in production scenarios — they break parsers.

Example prompt for an email classifier:

You are an email classifier. Analyze the email below and return JSON.

Schema:
{
  "category": "lead" | "support" | "spam" | "other",
  "urgency": "high" | "medium" | "low",
  "sentiment": "positive" | "neutral" | "negative",
  "needs_human": boolean,
  "summary": "max 100 chars"
}

Email subject: {{1.subject}}
Email body: {{1.body}}

Return ONLY the JSON object, no preamble.

Then add a JSON Parse module after the AI call. The parsed fields become available as variables for downstream modules.

Common AI workflows in 2026

• Email triage — classify urgency and route accordingly
• Lead scoring — score prospects against your ICP
• Content generation — blog posts, social captions, product descriptions
• Document Q&A — RAG over internal docs via embeddings + vector DB
• Image generation — featured images, product mockups, social assets
• Audio transcription — meeting notes, podcast subtitles
• Voice agents — Whisper + LLM + TTS pipelines for IVR replacement

For a deeper dive, read our getting started with GPT-4 and Make.com guide.

Make.com Agents — autonomous workflows

Released in late 2024 and expanded throughout 2025-2026, Make.com Agents are an evolution of scenarios. Instead of a fixed sequence of modules, an agent has:

• A goal — natural language description of what to accomplish
• A set of tools — functions the agent can call (Make modules, custom HTTP, web search)
• An LLM brain — Claude Opus 4.7 or GPT-4o handles decision-making
• Memory — conversation history within a session

Use cases where agents shine over regular scenarios:

• Research — "find the top 5 competitors of company X and summarize their pricing"
• Customer support triage — read inbound email, decide whether to respond, escalate, or create a ticket
• Lead enrichment — given a name and company, gather all relevant data from multiple sources
• Multi-step decision flows — when the path depends on intermediate results

MCP integration — turning Make into an AI tool provider

One of the most significant additions in 2025 was MCP server support. Here's why it matters:

Before MCP, integrating an LLM with your business workflows required custom code on both sides. Now, with Make as an MCP server, you can:

1. Build a scenario in Make (e.g., "Create a deal in Pipedrive with these fields")
2. Expose it as an MCP tool
3. Connect Claude or ChatGPT to your Make MCP server
4. Have natural-language conversations that trigger real actions in your CRM, ERP, etc.

Concrete example: a sales rep types in Claude "Create a new deal for Acme Corp, $50k, decision in Q3." Claude calls your Make MCP scenario, which creates the Pipedrive deal, sends a Slack notification, and assigns to the right rep — all from one chat message.

10 common mistakes to avoid

Mistake 1 — Not using error handlers

Without error handlers, a single API failure stops the entire scenario. Always add error handlers on critical modules, especially HTTP requests and third-party API calls. Use "Resume" for transient failures, "Break" for critical, "Ignore" for optional steps.

Mistake 2 — Looping API calls inefficiently

If your scenario hits an API 100 times per run, you're consuming 100 operations. Often, you can replace this with a single "Search" or "List" call that returns everything at once. Always check the app's documentation for batch endpoints before building loops.

Mistake 3 — Storing secrets in Data Stores

Data Stores are not encrypted at the field level. Never store API keys, passwords, or sensitive credentials there. Use Make's Connections feature instead — credentials are properly encrypted and scoped.

Mistake 4 — Ignoring scheduling intervals

By default, scheduled scenarios run every 15 minutes. Increase the interval to every 1-6 hours when real-time isn't needed — you'll save 4-24x in operations. Most "real-time" use cases work fine at hourly intervals.

Mistake 5 — Not testing with realistic data

"Run once" with empty inputs misses 90% of real-world bugs. Build scenarios with messy, real-world test data — typos, missing fields, weird Unicode characters, multiline strings, special characters. Then add edge case handling.

Mistake 6 — One scenario per client (in agencies)

Agencies often build one scenario per client. DON'T. Build one master scenario that handles all clients with variables. Easier to maintain, fewer bugs, simpler to update.

Mistake 7 — No webhook deduplication

Webhooks can fire twice (Stripe, GitHub, etc. all do this occasionally). Without deduplication, you'll process the same event twice — creating duplicate records, sending duplicate emails. Use a Data Store to track processed event IDs.

Mistake 8 — Hardcoded values that should be variables

Email addresses, channel names, API endpoints — anything that might change should be a custom variable, not hardcoded. Saves you from editing 12 modules when one value changes.

Mistake 9 — Skipping the dev/staging workspace

If you have a Teams plan, create a separate "Dev" team for testing changes before promoting to production. Saves you from breaking live workflows during iteration.

Mistake 10 — Not monitoring failed runs

Make won't tell you when a scenario starts failing — you have to check. Set up a monitoring scenario that watches the execution log and alerts on Slack when failure rate spikes.

Tools, integrations and the 2026 ecosystem

The most heavily used integrations in 2026:

Category	Top integrations
Productivity	Gmail, Outlook, Slack, Notion, Asana, ClickUp, Trello, Monday
CRM & Sales	HubSpot, Pipedrive, Salesforce, Close, Attio, Folk
Marketing	Mailchimp, Brevo, Klaviyo, ActiveCampaign, ConvertKit, Beehiiv
E-commerce	Shopify, WooCommerce, Stripe, Square, Recharge, BigCommerce
Data & analytics	Google Sheets, Airtable, BigQuery, Supabase, PostgreSQL, MongoDB
AI	OpenAI, Anthropic, Google AI, Mistral, Replicate, ElevenLabs
Communication	Twilio, WhatsApp, Telegram, Discord, Microsoft Teams
Forms	Typeform, Tally, Jotform, FluentForms, Google Forms
Scheduling	Calendly, Cal.com, SavvyCal, Acuity
Storage	Google Drive, Dropbox, OneDrive, AWS S3

Don't see your tool? Make has a generic HTTP module that lets you call any REST API, plus full webhook support for inbound triggers from any platform.

Make.com vs alternatives

We've published in-depth comparisons for the most important alternatives:

Make.com for specific industries

We've published industry-specific automation playbooks:

Security and compliance

Make.com's certifications as of 2026:

• SOC 2 Type II — independently audited security controls
• ISO 27001 — international information security standard
• GDPR compliant — for EU data protection, with EU data residency available
• HIPAA — available on Enterprise plans for healthcare data
• SSO/SAML — Enterprise plans support SAML 2.0 SSO

The main consideration for sensitive data is execution log retention. By default, Make stores input/output of every module run for 30-90 days for debugging. For scenarios processing PII or PCI data, disable execution data retention in scenario settings.

For a deep dive on Make.com security practices, read our Is Make.com Safe? guide.

What's new in 2026 — the trends shaping Make.com

1. AI agents in production, not labs

Through 2024 and 2025, AI agents were experimental. In 2026, they're entering production for narrow use cases: support triage, lead enrichment, content workflows. Make.com's Agents feature has matured significantly — better tool calling, persistent memory, lower failure rates.

2. MCP becomes the integration standard

Anthropic's Model Context Protocol, launched in 2024, is now widely adopted. Make.com supports both being an MCP server (exposing scenarios as LLM tools) and an MCP client (calling external MCP servers from scenarios). This is the biggest shift in how AI integrates with business workflows.

3. Voice automation

Whisper (transcription) + LLM (reasoning) + ElevenLabs (TTS) pipelines are replacing IVR systems and basic phone bots. Make.com makes building these voice agents accessible without writing pipeline code.

4. Tighter compliance options

Make expanded EU data residency in 2025 and added German-only zones in 2026 for highly regulated industries. SOC 2 Type II is now table stakes; HIPAA-ready scenarios are common in healthcare.

5. Native Claude integration

Anthropic's Claude family (Opus 4.7, Sonnet 4.6, Haiku 4.5) has dedicated Make modules with full tool calling, structured outputs, and prompt caching support. Many teams are migrating AI workflows from OpenAI to Claude for cost and quality reasons.

How to get started with Make.com today

1. Sign up free at make.com — no credit card required
2. Build the form-to-Sheet-to-Slack scenario from the section above (10 minutes)
3. Browse our template library for copy-paste starting points
4. Read our other guides on keyboard shortcuts, security, and pricing
5. Try our pricing calculator to estimate your monthly cost vs Zapier
6. Subscribe to our newsletter below for new templates weekly

Become a Make.com expert.

One email per week with new templates, advanced patterns, and deep dives. Used by 1,000+ Make builders.

Subscribe

✓ Thanks! You'll hear from us soon.

Frequently asked questions

What is Make.com?

Make.com is a visual no-code automation platform that connects apps and services through workflows called scenarios. Previously known as Integromat, it lets you build automations by dragging modules on a canvas, with no coding required. Make has 1,800+ native integrations and serves over 500,000 businesses worldwide.

Is Make.com free?

Yes, Make.com offers a free plan with 1,000 operations per month, two active scenarios, and access to all apps. The free plan is enough to test the platform and run a few personal automations. Paid plans start at $10.59/month for 10,000 operations.

What is the difference between Make and Integromat?

There is no functional difference. Integromat was rebranded to Make.com in 2022 with a refreshed UI, but all features and existing scenarios were migrated automatically. Old Integromat tutorials still apply — only the visuals have changed.

How long does it take to learn Make.com?

Most people build their first working scenario within 30 minutes. Becoming proficient with branching, error handling and advanced patterns takes 2 to 4 weeks of regular practice. Mastering AI agents and complex multi-scenario systems typically takes 2 to 3 months.

Do I need to know how to code to use Make.com?

No. Make.com is fully no-code. Knowing basic JavaScript helps for advanced data transformations using built-in code modules, and reading API docs helps for the generic HTTP module — but neither is required for 90% of use cases.

Is Make.com better than Zapier?

For most use cases yes. Make is 3 to 5 times cheaper at equivalent volume, has a far more powerful visual builder with branching and loops, and has better AI integrations. Zapier wins on app catalog size (7,000+ vs 1,800+) and pure simplicity for absolute beginners.

What is an operation in Make.com?

An operation is one module run. If your scenario has 5 modules and processes 10 records, that consumes 50 operations. Operations are Make's primary pricing unit, with plans starting at 1,000 ops/month free and scaling to enterprise volumes.

What are Make.com AI Agents?

AI Agents are autonomous workflows introduced by Make.com in late 2024. Unlike scenarios where the flow is predetermined, an agent has a goal, a set of tools, and an LLM brain that decides which tools to call and in what order. Use cases include research, customer support triage, and lead enrichment.

Does Make.com support MCP (Model Context Protocol)?

Yes. As of 2025, Make.com supports MCP servers, allowing Claude, ChatGPT and other LLMs to call your Make scenarios as tools. This lets you build conversational AI assistants that can trigger automations on your behalf.

Can I self-host Make.com?

No, Make.com is cloud-only. If you need self-hosting for compliance or cost reasons at very high volume, n8n is the main self-hostable alternative. Make offers EU and US data residency on Enterprise plans.

What happens if I exceed my operations limit?

Your scenarios stop running until the next billing cycle, or until you upgrade. You can also buy extra operations on the fly ($9 per 10,000 ops) without changing plans.

Is Make.com GDPR compliant?

Yes, Make.com is GDPR compliant. EU data residency is available on Enterprise plans, ensuring data never leaves European data centers. Make also offers DPAs (Data Processing Agreements) on request.

Continue learning

Now that you've got the foundations, dive deeper with these guides: