Everything you need to go from zero to automating AI-powered workflows, building agentic systems, and running your entire business on autopilot — no code required.
Make (formerly Integromat) is a no-code/low-code automation platform that lets you visually connect apps, automate workflows, and build AI-powered systems — without writing a line of code. Think of it as the command center for your entire digital operation.
Make lets you visually build, scale, and automate AI and agentic workflows by connecting any app, data source, or AI model — through an intuitive drag-and-drop canvas.
Design workflows on a canvas using drag-and-drop modules. See data flowing in real time. No code needed for most tasks.
Connect Gmail, Slack, HubSpot, Notion, OpenAI, Airtable, Google Sheets, Stripe, and thousands more out of the box.
Embed AI models and agents directly in your workflows. Make handles judgment-based, adaptive tasks that traditional automation can't.
Watch your scenarios run live. Monitor every step, inspect data at each node, and debug instantly on the canvas.
SOC 2 Type II, GDPR compliant, SSO, encryption at rest and in transit, audit logs, and on-prem agent support.
Start free, scale to millions of operations. From a single workflow to an AI automation system running your whole business.
| Feature | Make | Zapier | n8n |
|---|---|---|---|
| Visual Canvas Builder | ✅ Full visual canvas with live data flow | ⚠️ Linear, list-based | ✅ Node-based |
| AI Agents | ✅ Native AI Agents on all plans | ⚠️ Limited | ✅ Supported |
| Pricing Model | Credit-based (per operation) | Task-based | Self-host free |
| Free Plan | 1,000 credits/mo, no time limit | 100 tasks/mo | Self-host only |
| No-Code Requirement | Zero code needed | Zero code | Some setup |
| Real-Time Monitoring | ✅ Live on canvas | ⚠️ Logs only | ✅ Supported |
| MCP Server | ✅ Native Make MCP | ❌ | ⚠️ Via plugins |
Before you build, understand these building blocks. Everything in Make is built on top of these concepts.
A scenario is your automated workflow. It defines how different apps communicate and work together. A scenario triggers when it receives data, transforms it, and sends it to another app.
Example: New Typeform submission → OpenAI generates a reply → Gmail sends it automatically.
Modules are the individual nodes in your scenario. Each module performs one action — triggering, searching, creating, updating, or transforming data. Each module execution = 1 credit.
Types: Trigger, Action, Search, Iterator, Aggregator, Router, Tools.
Every scenario starts with a trigger — the event that kicks off the automation. Can be a webhook (instant), a schedule (every X minutes), or polling (checks for new data at intervals).
Examples: New email, form submission, scheduled time, webhook from your app.
Routers split a scenario into multiple parallel paths based on conditions. One path might email VIP customers, another handles standard customers. No extra credits charged for the router itself.
Note: Filters inside routers let you add conditions like "only proceed if price > $100."
Built-in database for your scenarios. Store data between runs, track state, deduplicate records, and build persistent memory into your automations without an external database.
Limit: 1 MB per data store; up to 1,000 data stores per organization.
Connections are the authorized links between Make and your apps. You authenticate once (OAuth, API key, etc.) and reuse the connection across unlimited scenarios.
Tip: Share connections across team members for centralized credential management.
A unique URL that triggers your scenario instantly when called. Used for real-time automation — any app that can send an HTTP request can trigger your Make workflow.
Chain scenarios together. One scenario can call another, enabling modular, reusable automation. Build once, use across multiple parent workflows — like functions in programming.
Each module action in your scenario consumes 1 credit. Reading a Google Sheet row = 1 credit. Sending a Gmail = 1 credit. An OpenAI call = 1 credit. Error handler modules (Rollback, Break, Resume, Commit, Ignore) and Router modules do not consume credits. Plan accordingly — a scenario with 10 modules that runs 100 times/day uses ~1,000 credits/day.
Building a scenario in Make is faster than you think. Here's the complete process from account creation to your first running automation.
Go to make.com/en/register — no credit card required. You'll land in your Make dashboard (called your "organization"). The free plan gives you 1,000 credits/month with no time limit.
Hit the blue + button. You'll land on the visual canvas — an infinite whiteboard where you build your workflow. You can start from scratch or browse the template library for a pre-built starting point.
Click the empty circle to add your first module. Search for your app (Gmail, Slack, Typeform, webhook, etc.). Choose what event starts the workflow — "Watch Emails," "New Form Response," "Scheduled," or a custom webhook.
When prompted, click "Add a connection" to authenticate. Make uses OAuth for most apps (1-click Google/Slack login) or API key entry. You only do this once per app — the connection is saved and reusable.
Click the + after your trigger to add more modules. Each module represents an action — search a database, call an AI, create a record, send a message. Map data from previous modules by clicking output fields and dragging them into input fields.
Right-click on the connector arrow between modules to add a filter (conditional logic). Click the module edge to add a router (multiple paths). Use built-in tools for text manipulation, math, array functions, and date formatting.
Hit "Run once" to test. Watch data flow through each module live on the canvas. Click any module bubble to inspect exactly what data came in and out. Errors show inline with explanations.
Set your scenario's schedule (every 15 min on Free, every 1 min on paid plans). Toggle the ON/OFF switch to activate. Your scenario now runs automatically in the background.
This 5-module scenario watches Gmail, analyzes sentiment with AI, routes to Airtable logging, and pings Slack for negative emails — uses ~5 credits per email.
Free plan: run every 15 minutes minimum. Paid plans: run every 1 minute, or at an exact time. Webhook-triggered scenarios run instantly when called, consuming no polling time.
Add error handlers (Break, Retry, Ignore, Resume, Rollback, Commit) to specific modules. Set email alerts when scenarios fail. Incomplete executions are saved automatically for retry.
Make processes data in "bundles" — each record from a trigger becomes a bundle flowing through your scenario. The Iterator module splits arrays into individual bundles; Aggregator collects them back.
Every module output is mappable as a variable in downstream modules. Use the mapping panel to reference data like {{1.email}} — the output of module 1's email field.
Make is built AI-first. Every plan includes access to 350+ AI integrations, the Make AI Toolkit, and native AI features — no separate subscription needed.
Built-in AI tools using Make's own AI Provider — available on all plans. No external API key required to get started. Includes text processing, content generation, and classification tools.
All PlansExtract structured text and metadata from PDFs, docs, images, and web pages directly within your scenario. Turn unstructured content into clean, actionable data.
All PlansBring live web data into your automations with built-in AI search and structured outputs. Research topics, verify facts, or gather competitive intelligence — automatically.
BetaFollow these steps to add AI to any workflow:
In your scenario, click + to add a module. Search for OpenAI, Anthropic Claude, Google Gemini, Mistral, or the built-in Make AI Toolkit. Each has pre-built action modules for common AI tasks.
For external AI apps (OpenAI, Claude, etc.), add your API key as a connection. Alternatively, use Make's built-in AI Provider — no API key needed, credits deducted from your plan at a slightly higher rate per AI call.
In the AI module's "Messages" or "Prompt" field, type your prompt and insert mapped variables from earlier modules. Example: "Summarize this email: {{1.text.content}}" — the output from your Gmail trigger flows directly into the AI prompt.
The AI module's response becomes a mappable variable for all following modules. The generated text, structured JSON, or classification label can be used in any app — create a Google Doc, send a Slack message, update a CRM, etc.
Trigger: New product in Airtable → OpenAI writes 5 social captions + blog intro → Store to Google Sheets → Post to Buffer for scheduling.
Trigger: New customer review → Claude analyzes tone & category → Route to different Slack channels (#praise vs #issues) → Update NPS dashboard.
Trigger: Gmail new email → AI classifies intent (sales lead, support, spam) → Routes to appropriate team member via Slack + creates task in Asana.
Trigger: Typeform content brief → GPT-4 writes prompt → DALL-E 3 generates image → Upload to Dropbox → Share link in Slack thread.
Trigger: PDF uploaded to Google Drive → AI Content Extractor pulls structured data → Parse fields → Create CRM record in HubSpot with extracted info.
Trigger: Scheduled daily → AI Web Search for competitor news → Summarize with Claude → Add to Notion research database → Email digest to team.
Make AI Agents are the next evolution beyond traditional automation. While a standard scenario follows fixed logic, an AI Agent reasons, decides what to do next, and takes action across 3,000+ apps.
Deterministic — it always follows the same path. If X then Y. Great for predictable, repeatable processes. You define every step in advance.
Non-deterministic — the AI decides what action to take based on context. It can reason, handle exceptions, and choose from available tools dynamically.
Rule of thumb: "If it just needs doing, use automation. If it needs thinking, use Make AI Agents."
In your Make dashboard, go to AI Agents (left sidebar) → Create new agent. Or add an "AI Agent" module inside an existing scenario on the canvas.
Write a system prompt that defines what your agent does: its persona, goals, constraints, and tone. Be specific: "You are a customer support agent for [Company]. Always check the knowledge base before answering. Escalate to human if the issue involves billing."
Select from Make's AI Provider (all plans), or connect your own API key for OpenAI GPT-4o, Anthropic Claude, Google Gemini, Mistral, or others. Higher-capability models cost more credits per run.
Tools are Make scenarios that the Agent can call as needed. Example: "Search CRM" scenario, "Create Ticket" scenario, "Look Up Knowledge Base" scenario. The Agent decides which tool to use and when, based on the conversation context.
Define how the Agent receives input — webhook, chat interface, email trigger, or Slack message. Add memory modules to give the Agent context from previous conversations using a Data Store or external database.
Run the agent and open the Reasoning Panel — you see every decision the agent makes, which tool it chose and why, step by step. This transparent "thinking" is Make's key differentiator for building trustworthy agents.
For high-stakes actions, add approval steps: the agent pauses and sends a Slack message asking "Shall I proceed?" Your team confirms or redirects before the agent continues.
Make's Library of Agents has pre-built agents you can deploy and customize instantly:
Fetches resumes, evaluates candidates against job criteria, ranks applicants, and notifies hiring managers — automated from inbox to shortlist.
Handles complex queries, searches a knowledge base, creates tickets, escalates to humans when needed — 24/7 without a support team member present.
Reviews submitted expense reports, checks policy compliance, flags exceptions, and routes for approval — reducing audit time from hours to seconds.
Based on Make's real customer case study: reduced farmers' invoicing time from 15 minutes to 20 seconds — reading inputs, generating invoices, and sending via email.
Agentic automation is where traditional automation ends and intelligent, adaptive systems begin. It's AI that doesn't just execute — it reasons, adapts, and responds to real-world complexity.
Agentic workflows respond to new inputs and changing conditions dynamically. No need to pre-define every possible edge case — the AI adapts in the moment.
Traditional automation breaks when you add new products, markets, or edge cases. Agentic workflows grow alongside your business without constant rebuilding.
Unlike rule-based automation, agentic systems can interpret free-form text, context-heavy emails, PDFs, and natural language — without structured inputs.
Every AI-driven workflow is encrypted, logged with full execution history (including reasoning steps), and protected with third-party audits and DDoS protection.
Traditional automation: Structured, deterministic. If A happens, do B. No interpretation. Example: Copy Typeform response to Google Sheet.
AI-Assisted automation: Fixed workflow + AI for one step. Example: Send email body to GPT to generate a reply, then send that reply.
Agentic automation: The AI decides the entire path. It reads context, picks tools, takes actions, handles exceptions, and loops until the goal is achieved — adapting at every step.
Make MCP (Model Context Protocol) Server lets your AI tools outside Make — like Claude Desktop, Cursor, custom chatbots — connect to and trigger your Make scenarios directly. It's a bridge that turns Make into a backend for any AI interface.
Example: You're chatting with Claude and say "Create a new lead in my CRM from this email." Claude uses Make's MCP Server to call your "Create HubSpot Lead" scenario directly — no copy-paste, no switching apps. Available on all plans.
Make has the richest AI integration library of any automation platform. Every major model provider, voice AI tool, image generator, and AI infrastructure service is available as a native module.
Make has pre-built solution paths for every department. Here's what each team can automate — with concrete examples.
Make specifically highlights Social Media Posting and Content Creation as two of its most popular automations. Connect your content creation tools to auto-publish across platforms, repurpose long-form content, and scale your online presence without manual copy-paste.
Featured example from Make's how-to guides: "Repurpose TikTok Videos into LinkedIn Posts" — one of their most popular tutorials.
Make pricing is credit-based — each module action consumes 1 credit. No time limit on the free plan. All plans include AI features.
| Scenario Type | Modules | Runs/Day | Credits/Day | Credits/Month |
|---|---|---|---|---|
| Simple 2-app sync | 3 | 48× | 144 | ~4,300 |
| Email → AI → CRM | 5 | 20× | 100 | ~3,000 |
| Content pipeline (social) | 8 | 5× | 40 | ~1,200 |
| Lead qualification workflow | 10 | 30× | 300 | ~9,000 |
| AI agent (10 tool calls avg) | 15 | 10× | 150 | ~4,500 |
If you're a creator, Make is one of the highest-leverage tools you can learn. These workflows save 10+ hours per week and let you publish more, better, with less manual effort.
Turn one long video into 5+ pieces of content automatically
From idea to published across all channels automatically
Per Make's official how-to guide: TikToks → LinkedIn posts
Curate, write, and send — fully automated
Know what's working without manual analytics check
Make has one of the best free learning ecosystems of any automation platform. Here's where to go for every learning need.
Free structured eLearning at academy.make.com. Courses from beginner to advanced covering scenarios, AI, agents, and enterprise use cases. Self-paced with certification options.
Best for: Structured learners who want official certification.
Full documentation at help.make.com. Covers every module, app, feature, and billing question. Searchable, always updated. Start here when stuck.
Best for: "How do I do X exactly?" reference questions.
191+ step-by-step tutorials at make.com/en/how-to-guides. Practical, real-world use cases with screenshots. Updated weekly — new guides include LLM integrations and AI agent workflows.
Best for: "I want to build X" — find a near-exact template.
Active forum at community.make.com. 350,000+ users sharing templates, solving bugs, and posting workflows. The fastest way to get unstuck when you have a specific problem.
Best for: Debugging, edge cases, finding creative solutions.
Hundreds of pre-built scenarios at make.com/en/templates. One-click install to your account. Filter by app, use case, or department. Best place to get started fast.
Best for: Getting your first automation live in under 5 minutes.
Live expert-led sessions at make.com/en/webinars. Q&A with Make experts, live scenario building, and product deep-dives. Recordings available after.
Best for: Watching an expert build in real time.
Complete the "Make Foundations" course at academy.make.com. Takes ~3 hours. You'll understand scenarios, modules, connections, and the canvas.
Go to Templates, install a Gmail→Slack, a Google Sheets sync, and a form-to-email scenario. Run them, inspect the data, see how it works.
Follow the "How to create AI chatbots with Make" how-to guide. Build it without a template. This is where it clicks.
Follow "How to build AI agents with Make" guide. Deploy one from the Agent Library, customize the system prompt and tools. Test with the Reasoning Panel.
Bookmark community.make.com. Every time you're stuck for more than 10 minutes, search the community first. Subscribe to the Make blog for weekly automation inspiration.