Make

What is Make?

Make is a visual automation and AI agent platform that helps teams connect apps, move data, and build workflows that would otherwise need a lot of manual coordination or custom code. It started life as Integromat in 2012, then was acquired by Salanis in 2020 and rebranded as Make. Since then, it has grown into one of the biggest names in no-code automation, with more than 3.1 million users and 5.6 billion automation scenario executions in 2024 alone, up 26% from 2023.

What makes Make different, in our research, is not just that it connects 3,000+ apps. A lot of automation tools can claim a big app catalog. Make’s story is really about how much logic it lets people express visually. Instead of simple "if this, then that" chains, teams can build branching workflows with routers, filters, iterators, aggregators, error handlers, webhooks, HTTP calls, and even custom Python or JavaScript when the built-in modules are not enough. That puts it in an unusual middle ground. It is approachable for non-developers, but it does not stop where many no-code tools stop.

More recently, Make has pushed hard into AI agents. In February 2026, it introduced next-generation AI agents built directly inside the same scenario builder people already use for automation. That matters because Make is trying to avoid the black-box feeling that often comes with AI tooling. Its new Reasoning Panel shows how an agent is thinking, which tools it calls, and why it takes a path. For teams in support, operations, healthcare, sales, and research, that transparency is a big part of the appeal.

Key Features

• Visual scenario builder: Make’s core product is a drag-and-drop workflow canvas where each scenario represents a full business process. Unlike tools that cap complexity quickly, Make supports unlimited modules and routes, which is why teams use it for multi-step automations instead of just simple triggers.

• 3,000+ app integrations: Make connects with more than 3,000 applications across CRM, finance, marketing, support, databases, and collaboration tools. The more important detail is integration depth, for example Make supports 84 actions for Xero versus 25 in Zapier, which gives teams finer control over real business processes.

• HTTP and webhook connectivity: When a native integration does not exist, Make can still connect to almost any service with a public API through its HTTP module or custom webhooks. That changes the ceiling of the platform, because teams are not limited to the official app directory.

• AI agents inside the workflow canvas: Make’s 2026 AI agent release brought agent logic directly into the scenario builder instead of treating AI as a separate system. Builders can see reasoning steps in a dedicated panel, test agents in-canvas, and combine deterministic workflow steps with flexible AI decision-making.

• Support for major AI providers: Make integrates with OpenAI, ChatGPT, Google Gemini AI, Perplexity AI, Anthropic Claude, Deepseek, and Eleven Labs. For teams experimenting with AI, this means they can compare models inside the same automation stack instead of rebuilding workflows around each provider.

• Routers, filters, iterators, and aggregators: These are the building blocks that let Make handle branching, bundle splitting, and data consolidation. In practice, this is why a single scenario can triage support tickets, split attachments, process each one separately, then recombine outputs into a final report.

• Error handling and incomplete execution recovery: Make includes Continue, Retry, Break, Rollback, and Ignore error handlers, plus a way to inspect incomplete executions. For production workflows, this matters because a single API hiccup does not have to bring an entire business process to a halt.

• Make Code app for Python and JavaScript: Teams can write custom code directly inside scenarios, with support for common libraries like pandas, numpy, requests, lodash, and moment.js. Standard plans get up to 30 seconds of runtime, Enterprise goes up to 300 seconds, which is enough for many transformation-heavy tasks.

• Execution history and log search: Every run records status, duration, operations consumed, and data transfer. Pro plans add full-text execution log search, which becomes valuable when teams need to trace one order number, customer name, or failed condition across many runs.

• Make Grid for automation mapping: Make Grid visualizes how scenarios, apps, data stores, and AI components connect across an organization. For teams with dozens or hundreds of workflows, this gives them a live map instead of stale documentation.

• Credit-based pricing model: Make charges by operations rather than by user or broad task bundles. On paper, that can be much cheaper than competitors, around $0.0009 per operation on the $9 Core plan versus roughly $0.026653 per task on Zapier’s entry paid tier, but it also means workflow design has a direct impact on cost.

• Enterprise governance controls: Larger organizations get team limits, custom scenario properties, feature controls for AI and beta tools, advanced roles, and dedicated support. These controls matter once automation becomes shared infrastructure across departments rather than a side project for one team.

Use Cases

One of the clearest real-world stories we found comes from healthcare. Sterling Administration built a system where QR code scans trigger personalized care forms for caregivers. Those forms guide staff through care procedures, automatically capture outcomes, check patient history for concerning patterns like repeated medication refusal, and alert the right people when trends suggest risk. They also built a separate scenario that tracks patient health scores using weighted events such as eating, bathroom usage, and skin integrity, then sends daily email and text updates to family members. This is a good example of Make at its best, not just moving data between apps, but coordinating a sensitive process where automation, documentation, and human oversight all matter.

In sales and revenue operations, the outcomes are more bluntly commercial. Circula grew at a 1,987% rate over four years, with Make playing a significant role in how it scaled operations. Skai uses Make-powered automation to deliver more than 70 client solutions per year. ARETI reportedly closed deals worth $60K to $100K in just two months through automations that accelerated sales processes and improved how leads were handled. These stories suggest Make is often less about saving a few clicks and more about helping teams grow without hiring linearly.

There are also strong examples around AI-assisted business processes. Make highlights support ticket triage, candidate screening, market research, SEO analysis, sales outreach, and content marketing as agent-friendly workflows. The pattern is consistent. A deterministic workflow handles the structure, while an AI agent handles the judgment call. A support workflow might classify urgency and route to the right specialist. A hiring workflow might score resumes against role requirements before a recruiter steps in. A research workflow might gather data from multiple sources, structure it, and produce a report. The reason these use cases fit Make is that they need both orchestration and reasoning, not just one or the other.

Strengths and Weaknesses

Strengths:

• It handles more complexity than most no-code tools: In our research, this is the main reason advanced users move from Zapier to Make. Zapier is often easier for a quick two-app automation, but Make’s unlimited modules and routes let teams build workflows with branching logic, fallback paths, and nested processing that would hit limits elsewhere.

• The cost structure can be dramatically better at scale: The numbers here are hard to ignore. Make’s Core plan starts at $9 per month for 10,000 operations, while Zapier’s entry paid plan starts at $19.99 per month for 750 tasks. For teams running large volumes, that can mean nearly 30x lower cost per action, if the workflows are designed efficiently.

• Integration depth is unusually strong: The Xero comparison tells the story well. Make supports 84 actions where Zapier supports 25. For finance, operations, and back-office teams, that difference means the automation can actually reflect the process they run instead of forcing them into a simplified version of it.

• AI is more transparent than in many competing tools: Make’s newer AI agent approach focuses on visible reasoning inside the same visual builder. For teams nervous about black-box AI decisions, especially in regulated or sensitive environments, that is a meaningful design choice rather than a minor UI feature.

• There is an escape hatch when no connector exists: Between HTTP modules, custom webhooks, JSON/XML handling, and embedded code, Make rarely traps a team just because an app is obscure. That flexibility is a big advantage over platforms that depend heavily on official connectors.

Weaknesses:

• The learning curve is real: Make is no-code, but it is not simple in the way many people expect no-code to be. Teams need to understand bundles, operations, iterators, aggregators, polling behavior, and credit consumption. Users coming from simpler tools can get surprised by both complexity and cost if they build without understanding the execution model.

• Credits are transparent, but not always intuitive: Make’s pricing looks cheap, and often is, but complex scenarios can burn through credits quickly. Iteration-heavy workflows, frequent polling, AI usage, and code execution all add up, so the low headline price does not automatically mean a low monthly bill.

• Very complex visual workflows can become hard to maintain: The same flexibility that makes Make powerful can also make scenarios sprawling. Once a workflow has many branches, handlers, and dependencies, debugging can become time-consuming even with good logs and execution history.

• High-volume or heavy data workloads are not its strongest fit: Research points to limits when teams need to process millions of records or run extremely large-scale data transformations. At that point, database-native tooling or specialized data infrastructure may be a better fit than a visual automation layer.

• Cloud-first deployment will rule it out for some teams: Compared with n8n, which appeals to teams that want self-hosting and tighter infrastructure control, Make is less attractive if data residency or internal hosting is non-negotiable.

Pricing

• Free: $0 Includes 1,000 credits per month, 2 active scenarios, 3,000+ app integrations, routers, filters, and customer support. Scheduled scenarios are limited to a 15-minute minimum interval, so it works best for learning, prototyping, and low-volume personal workflows.

• Core: $9/month billed annually Includes 10,000 credits per month, unlimited active scenarios, Make API access, higher data transfer limits, and scheduling down to 1 minute. This is the tier where many small teams start running production workflows.

• Pro: $16/month billed annually Includes 10,000 credits per month plus features like full-text execution log search, custom variables, and priority scenario execution. This tier makes more sense once a team is maintaining enough workflows that debugging and observability start to matter.

• Teams: $29/month billed annually Adds team collaboration features such as scenario template sharing and role management. This is the first plan that feels built for shared operational ownership rather than one builder managing everything alone.

• Enterprise: Custom pricing Includes custom credit allocation, advanced security, 24/7 support, dedicated Value Engineering access, enterprise integrations, governance controls, and longer code execution limits. This is where Make starts competing more directly with enterprise automation platforms.

What people actually spend depends heavily on workflow design. A simple five-step workflow that runs 100 times a month uses about 500 credits. A 20-step scenario running 500 times uses 10,000 credits. That means the cheap entry price is real, but only if the scenario is designed thoughtfully. AI usage adds variable cost based on token usage, and the Make Code app adds a separate charge of $0.034 per second, or $2.04 per minute, which can become expensive fast if teams use code casually instead of sparingly.

Compared with Zapier, Make is usually much cheaper per action. Compared with self-hosted tools like n8n, the tradeoff is different. You may pay more for hosted convenience, but less in engineering time.

Alternatives

Zapier Zapier is still the most common alternative people compare with Make, and the choice often comes down to complexity versus simplicity. Zapier supports more apps overall, more than 7,000 compared with Make’s 3,000+, and its interface is often easier for quick automations. If a team just wants a clean way to connect a few SaaS tools with minimal setup, Zapier can be the faster answer. Make tends to win when the workflow gets messy, branches heavily, or needs deeper app actions and lower operating cost.

n8n n8n appeals to more technical teams, especially those that want open-source tooling or self-hosting. If infrastructure control, on-prem deployment, or strict data residency rules matter more than polished hosted convenience, n8n is a serious option. Make is generally the better fit for teams that want a mature hosted product, a larger no-code audience inside the company, and less engineering overhead.

Workato Workato sits further upmarket and is aimed squarely at enterprise automation. It is often considered by larger organizations with complex governance, security, and integration requirements. A company might choose Workato over Make if it needs a deeply enterprise-first vendor relationship and is prepared for enterprise pricing. Make is often the more accessible option for mid-market teams or enterprises that want strong capability without starting from a heavyweight implementation model.

Microsoft Power Automate Power Automate makes the most sense in organizations already standardized on Microsoft 365, Teams, SharePoint, and the wider Microsoft stack. In those environments, the integration story is naturally strong and procurement is often simpler. Make is usually the better cross-stack option when a company’s tooling is spread across many vendors and it wants one neutral automation layer.

Gumloop Gumloop is a more AI-first alternative, aimed at teams that care most about autonomous agent behavior and LLM-centric workflows. A company might choose Gumloop if AI-native experimentation is the center of the project and broad app integration is secondary. Make is stronger when the problem is not just AI reasoning, but operational orchestration across many systems.

FAQ

What is Make used for?

Make is used to automate workflows between apps, APIs, and internal systems. Teams use it for support triage, sales operations, healthcare workflows, reporting, lead handling, research, and AI-assisted decision flows.

Is Make no-code?

Yes, primarily. Most workflows are built visually with modules and logic tools, though advanced users can add JavaScript or Python when needed.

How do I get started?

Start with the free plan and build one small scenario around a process you already do manually every week. Make Academy is free and gives a structured path for learning the basics before you try more complex workflows.

How long to set up?

A basic two-app automation can take less than an hour. A production workflow with branching logic, error handling, and testing can take days or longer, especially if multiple teams or APIs are involved.

How does Make pricing work?

Make charges by operations, called credits, rather than by user. Each module execution consumes credits based on what it does, so the monthly cost depends on how often your scenarios run and how much data they process.

Is Make cheaper than Zapier?

Often, yes. Based on published pricing, Make’s Core plan works out to about $0.0009 per operation, while Zapier’s entry paid tier is roughly $0.026653 per task. The catch is that Make rewards efficient scenario design, so careless workflows can still get expensive.

How many apps does Make support?

Make supports 3,000+ applications natively. If an app is not in the library, you can often still connect it through HTTP requests or webhooks.

Can Make work with AI models?

Yes. It supports providers including OpenAI, ChatGPT, Google Gemini AI, Anthropic Claude, Perplexity AI, Deepseek, and Eleven Labs, and it now includes native AI agent building inside the scenario canvas.

What makes Make different from Zapier?

Zapier is generally simpler for quick automations and has a larger app catalog. Make gives you deeper app actions, more complex workflow logic, lower cost at scale, and more flexibility when you need branching, iteration, or custom API work.

Can Make handle enterprise use cases?

Yes, especially on Teams and Enterprise plans. It includes governance features like role management, team limits, feature controls, custom scenario properties, and support for security and compliance needs such as GDPR workflows.

Does Make support custom APIs?

Yes. Its HTTP module can connect to nearly any public API, and custom webhooks let external systems trigger scenarios directly.

Is Make good for beginners?

It can be, but beginners should expect a learning curve. It is easier to start than coding an integration from scratch, but harder than the simplest automation tools because Make exposes more of the logic and operational detail.