Make.com
The comprehensive guide

What is Make.com?

Make.com (formerly Integromat) is a visual automation platform that lets you connect apps and build complex automated processes with a drag-and-drop graphical interface. Instead of writing code, you connect "blocks" and create Scenarios that run on a schedule or are triggered by an event.

What sets Make apart is its true power: unlike simple No-Code tools, Make enables branching logic, complex data processing, loops, aggregators, data filters, and deep integrations. It's meant for those who want the power of programming — without programming.

Make vs Zapier vs n8n — a quick comparison

Anatomy of a Scenario

Every Scenario in Make is built from a chain of modules that pass bundles (data bundles) between them:

Make.com pricing (2026)

Operation = one operation of one module on one bundle. A Scenario that runs 5 modules on 10 items = 50 operations.

Quick start — your first Scenario

Let's build the classic Scenario: every new email in Gmail adds a row to Google Sheets.

Step 1 — creating a free account

• Go tomake.com and click "Get started free"
• Sign up with a Google Account — most convenient for Google integrations
• Choose a server region — EU1 (Europe) for good stability
• Confirm the email and you'll enter the main interface

Step 2 — creating a new Scenario

• Click "Create a new scenario" in the top-left corner
• An empty Canvas opens with a circle "+" in the center
• Click the "+" and search Gmail
• Choose the Trigger: "Watch Emails"

Step 3 — configuring the Gmail Trigger

• Click the Gmail module ← "Add connection" ← approve OAuth with your Google account
• Folder: INBOX
• Criteria: All emails / unread only — your choice
• Maximum number of results: 10 (enough for testing)
• Click OK to save

Step 4 — adding Google Sheets

• Click the "+" next to the Gmail module ← search Google Sheets
• Choose "Add a Row"
• Connect the Google account (the same OAuth)
• Choose a Spreadsheet and Sheet
• Map fields: A = {{1.subject}}, B = {{1.from[].name}}, C = {{formatDate(1.date; "DD/MM/YYYY")}}

Step 5 — running and scheduling

• Click "Run once" to test — you'll see green on every module
• Click the Scheduling clock at the bottom ← choose "Every 15 minutes"
• Enable the Scenario (the left toggle) — it will run in the background

play_circle

Make.com — visual automation from beginner to expert

YouTube • search for tutorials

open_in_new

Core concepts

To build powerful Scenarios, it's important to understand Make's building blocks:

Module types

Connections — connecting to services

Every module needs a Connection — access approval for an external service. Make supports:

• OAuth 2.0 — most services (Google, Slack, HubSpot). Click "Add" ← approve in a popup
• API Key — simpler services. Paste the key in the field
• Basic Auth — username + password
• Custom Headers — via the HTTP module for any API

A Connection is saved once and can be used in all Scenarios.

Data Structures — Items, Bundles, Arrays

• Bundle — one "bundle" of data that passes between modules (like one row)
• Item — a single value inside a bundle: string, number, date, boolean
• Array — a list of values inside a bundle. For example: a list of email tags
• Collection — a key-value map (like a JSON object)

When a module returns multiple bundles (e.g. 10 rows from Sheets), they pass one after another through the rest of the Scenario.

Routes — branching routes

The Router is one of Make's powerful tools. It lets you split the flow into parallel routes:

• Each route can contain a Filter — a condition that decides whether the bundle passes
• You can add a Fallback Route — a default route if no condition matches
• Multiple routes run in order (not in parallel)

Filters — filtering data

A Filter is added between two modules — click the line connecting them ← add a condition:

• Text operators: Equal, Contains, Starts with, Matches pattern (regex)
• Number operators: Greater than, Less than, Between
• Date operators: Before, After, Within the last X days
• Array operators: Contains, Length greater than
• You can combine with AND / OR

Aggregators and Iterators

Iterator — got an array? An Iterator splits it so each element in the array becomes a separate bundle that continues through the flow.

Array Aggregator — the opposite: collects multiple bundles back into a single array. Useful before sending a summary email or writing to a single row in Sheets.

Text Aggregator — like the Array Aggregator but produces a single text. Excellent for building dynamic content.

Error Handling

• Click a module ← "Add an error handler" to choose the behavior on an error
• Ignore — ignore the error and continue
• Break — stop the run, save it in Incomplete Executions
• Retry — retry X times with an interval
• Rollback — roll back previous operations (if the API supports it)

Scheduling

Make allows two ways to trigger a Scenario:

• Polling — runs every X minutes/hours and checks for new data (most Triggers)
• Instant Trigger (Webhook) — triggered immediately when new data arrives ← no delay
• Cron-like scheduling: specific minutes, days of the week, dates

Data processing — Functions and Expressions

Make comes with hundreds of built-in functions for processing data. They're written directly inside fields in the interface with the syntax {{ function(value; parameter) }}.

Text functions

• toString(value) — convert any value to a string
• substring(text; start; length) — substring
• replace(text; search; replacement) — replace text
• trim(text) — trim whitespace from the edges
• lower(text) / upper(text) — case
• length(text) — string length
• split(text; separator) — split into an array by a separator
• join(array; separator) — join an array into a string
• contains(text; search) — containment check — returns true/false

Math functions

• 1.price + 1.tax — simple addition with standard operators
• round(number; decimals) — round
• ceil(number) / floor(number) — round up/down
• max(a; b) / min(a; b) — max/min
• abs(number) — absolute value
• parseNumber(text) — convert a string to a number

Date functions

• formatDate(date; "YYYY-MM-DD") — format a date
• formatDate(now; "DD/MM/YYYY HH:mm") — current date and time
• addDays(date; n) — add days
• parseDate(text; "DD/MM/YYYY") — convert a string to a date
• dateDifference(date1; date2; "days") — difference between dates
• now — the current date and time

Array functions

• length(array) — number of elements
• first(array) / last(array) — first/last element
• get(array; index) — element by index (starts at 1)
• flatten(array) — flatten a nested array
• arrayDifference(arr1; arr2) — difference between arrays
• deduplicate(array) — remove duplicates
• sort(array; order) — sort an array
• slice(array; start; end) — slice an array

JSON and HTTP

• parseJSON(jsonString) — parse a JSON string into an object
• toJSON(value) — convert a value to a JSON string
• keys(collection) — list of a collection's keys
• values(collection) — list of the values
• get(collection; "key") — a specific value from a collection

Expressions in practice

// format the current date
{{formatDate(now; "YYYY-MM-DD")}}

// trim an email subject to 50 characters
{{substring(1.subject; 0; 50)}}

// replace text in an email body
{{replace(1.text; "old_value"; "new_value")}}

// convert an object to a JSON string
{{toJSON(1.data)}}

// calculate the price including VAT
{{round(1.price * 1.17; 2)}}

// check if an email comes from a certain domain
{{if(contains(1.from[].address; "@company.com"); "internal"; "external")}}

// parse a date from a string
{{parseDate(1.date_string; "DD/MM/YYYY")}}

// concatenate strings
{{1.first_name & " " & 1.last_name}}

Regular Expressions

Make supports Regex via the functions match and replace:

// find a phone number in text
{{match(1.body; "\\d{10}")}}

// remove HTML tags
{{replace(1.html_body; "<[^>]*>"; "")}}

// trim after @
{{replace(1.email; ".+@"; "")}}

Webhooks — instant Triggers

A Webhook is a unique URL that lets an external service "knock on the door" and trigger your Scenario instantly, without polling.

Custom Webhook Trigger

• Create a Scenario ← "+" ← search Webhooks ← choose "Custom Webhook"
• Make will generate a unique URL like: https://hook.eu1.make.com/abc123xyz...
• Click "Determine data structure" ← send a test request
• Make will automatically learn the data structure

Instant vs Polling Triggers

Webhook URL + Secret

To protect your Webhook, add an IP whitelist or signature verification:

// a Header added to the request: X-Webhook-Secret
// in Make: Tools → Set Variable → check that the secret matches
{{if(1.headers["x-webhook-secret"] = "MY_SECRET"; true; false)}}

Testing Webhooks with Postman / curl

curl -X POST "https://hook.eu1.make.com/YOUR-WEBHOOK-ID" \
  -H "Content-Type: application/json" \
  -d '{
    "name": "John Doe",
    "email": "israel@example.com",
    "message": "Hello world"
  }'

Responding to Webhooks

You can respond to a Webhook request with a Response — important for integrations expecting a 200 OK with data:

• Add a module "Webhooks Response" at the end of the Scenario
• Set Status: 200, Body: {{ toJSON(collection) }}
• Useful for Chatbots, Forms, Slack slash commands

Example: Typeform → Make → Notion + Email

AI Modules — artificial intelligence inside Make

Make is a perfect tool for AI integration — you connect AI services to the rest of your apps and create smart automations.

The built-in OpenAI Module

Make includes an official OpenAI Integration with support for:

• Create a Chat Completion — GPT-4o, GPT-4 Turbo, GPT-3.5. Send a prompt ← get an answer
• Create an Image (DALL-E) — generating an image from a text description
• Create a Transcription (Whisper) — transcribing an audio file
• Create an Embedding — creating a vector embedding for RAG

Connect the OpenAI API Key once ← it will be available for all Scenarios.

HTTP Module — any AI API

For AI services without an official Integration, use theHTTP "Make a Request":

// Anthropic Claude API
URL: https://api.anthropic.com/v1/messages
Method: POST
Headers:
  x-api-key: YOUR_CLAUDE_KEY
  anthropic-version: 2023-06-01
  Content-Type: application/json
Body (JSON):
{
  "model": "claude-opus-4-5",
  "max_tokens": 1024,
  "messages": [
    {"role": "user", "content": "{{1.email_body}}"}
  ]
}

A full example: an Email Intelligence Scenario

Prompt Engineering inside Make

// a System Prompt for classifying emails
You are an email classifier. Classify the following email into exactly one category:
- SALES: inquiry about buying, pricing, demo request
- SUPPORT: bug report, help request, complaint
- SPAM: unsolicited marketing, irrelevant

Reply with ONLY the category name in uppercase.

// User message (mapped from the Scenario)
Email Subject: {{1.subject}}
Email Body: {{substring(1.body; 0; 500)}}

play_circle

Make.com AI Automation — OpenAI + GPT in practice

YouTube • search for Make.com AI videos

open_in_new

Templates — a shortcut to automation

Make offers a library of over 1,000 Templates ready-made ones — Scenarios built by Make's team or the Community, which you can import and adapt within minutes.

How to use Templates

• Go toTemplates in the side menu ← search by app or category
• Click "Use Template" on a Template that fits your need
• Make will create a Scenario with all modules configured — just connect the Connections
• Adjust fields, Filters and Routing to your needs

Popular Templates

Advanced Features

Custom Apps — custom integrations

Make lets you build a custom App for any API without an official Integration:

• Go toConnections → Custom Apps
• Set up Authentication (OAuth2, API Key, etc.)
• Add Modules with an endpoint description, input/output fields
• The App will appear in search like any official integration

A faster alternative: use theHTTP module for a one-off API call.

Data Stores — a built-in database

A Data Store is a simple database built into Make — useful for keeping state between Scenario runs:

• Storing IDs that were already processed (to not process twice)
• A counter/accumulator between runs
• Caching expensive AI results
• A simple data sheet for a small app

Accessible via modules: Data store: Add/Update a Record, Search Records, Delete a Record.

Teams & Organizations

• Teams — sharing Scenarios, Connections and Data Stores between team members
• Roles — Admin, Member, Viewer
• Organizations — manages multiple Teams with unified billing
• Environment Variables — variables shared across all Scenarios

Versioning & Rollback

• Make automatically keeps a version history for every Scenario
• You can revert to a previous version with one click
• Check: Scenario ← History ← choose a version ← Restore

Make API — triggering Scenarios from outside Make

You can trigger any Scenario programmatically via the Make API:

// trigger a specific Scenario
curl -X POST "https://eu1.make.com/api/v2/scenarios/{SCENARIO_ID}/run" \
  -H "Authorization: Token YOUR_API_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"responsive": true}'

// trigger a Webhook
curl -X POST "https://hook.eu1.make.com/YOUR-WEBHOOK-ID" \
  -H "Content-Type: application/json" \
  -d '{"name": "test", "email": "test@test.com"}'

The Make API also allows: listing Scenarios, managing Data Stores, Connections, Executions and more.

Make vs n8n vs Zapier — a decision guide

There's no "best" — there's what fits you. Here's a framework for deciding:

Choose Zapier if:

• You want maximum simplicity — a new Zap within 5 minutes
• You need the largest number of integrations (6,000+)
• Your team isn't technical and can't learn a complex interface
• Your Workflows are Linear only — A → B → C

Choose Make.com if:

• You want Complex logic — Routes, Aggregators, Iterators
• Heavy data processing — transforming, filtering, reshaping
• A limited budget — Make is significantly cheaper than Zapier at high volume
• You want a visual Canvas interface (not a list)
• AI Automation is a central part of your Workflows

Choose n8n if:

• You're a developer and want total flexibility with JavaScript/Python
• You want Self-host full — data doesn't leave your server
• GDPR / compliance is critical to you
• You want to pay $0 (forever, with self-hosting)

5 practical projects

From easy to hard — each project includes the architecture and key steps:

Cheat sheet — Make.com Cheatsheet

The most common functions

Common Patterns

Common error codes

Operations calculator

Before choosing a Plan, calculate Operations consumption:

// calculation formula:
Operations/month =
  number of Modules in the Scenario × number of Bundles × run frequency × days in the month

// example: a Scenario with 5 modules, 100 bundles/run, 4× a day:
5 × 100 × 4 × 30 = 60,000 operations/month → Pro Plan

// tip: a Trigger doesn't count as an Operation
// tip: an Error Handler module that isn't triggered doesn't count

Keyboard shortcuts in the Make interface

• Ctrl/Cmd + Z — undo the last action
• Ctrl/Cmd + S — save
• Space + drag — move the Canvas
• Ctrl/Cmd + +/- — Zoom in/out
• F — Fit to screen (show everything)
• Delete — delete the selected module/connection