Revision 1
Make

@namkyu · Aug 31, 2026, 9:22 AM
Added current pricing, credit usage, workflows, practical optimization techniques, business uses, advanced features, limitations, and alternatives.
+22,406−0
+# Quick Facts
+ 
+ 
+| Item                | Details                                                                    |
+| ------------------- | -------------------------------------------------------------------------- |
+| Main use            | Visual workflow automation between apps, APIs, and AI services             |
+| Best for            | Businesses, marketers, operations teams, agencies, technical no-code users |
+| Beginner friendly   | Moderate                                                                   |
+| Free option         | 1,000 credits/month                                                        |
+| Starting paid price | $9/month for 10,000 credits with annual billing                            |
+| Pricing model       | Credits                                                                    |
+| Coding required     | No                                                                         |
+| Deployment          | Cloud                                                                      |
+| API                 | Available on Core and higher                                               |
+| Integrations        | 3,000+ apps                                                                |
+ 
+ 
+# Pricing
+ 
+Make uses **credits** as its main billing unit.
+ 
+For most non-AI apps, one module operation consumes one credit. For example:
+ 
+New order → Google Sheets → Slack
+ 
+If the Google Sheets module and Slack module each run once, those actions normally consume one credit each.
+ 
+Make previously described this usage mainly in terms of operations. Operations still describe module activity, but credits are now the unit users purchase and consume.
+ 
+Current plans at the 10,000-credit level are:
+ 
+ 
+| Plan       | Price                         | Included Credits | Main Difference                                                      |
+| ---------- | -----------------------------: | ----------------: | -------------------------------------------------------------------- |
+| Free       | $0                            | 1,000/month      | Basic automation, 15-minute minimum scheduled interval               |
+| Core       | $9/month with annual billing  | 10,000/month     | Unlimited active scenarios, minute-level scheduling, Make API        |
+| Pro        | $16/month with annual billing | 10,000/month     | Priority execution, custom variables, full-text execution log search |
+| Teams      | $29/month with annual billing | 10,000/month     | Team roles and shared scenario templates                             |
+| Enterprise | Custom                        | Custom           | Enterprise integrations, security, support, governance features      |
+ 
+ 
+Make also offers monthly billing at higher prices. Larger credit allowances can be selected as workflow volume grows.
+ 
+The practical cost depends heavily on scenario architecture.
+ 
+Consider:
+ 
+Trigger → Search CRM → Update contact → Send email → Send Slack notification
+ 
+Each module that performs work can consume credits. A workflow processing thousands of bundles across several modules can therefore use credits much faster than its number of scenario runs suggests.
+ 
+## AI Credit Usage
+ 
+AI makes Make's pricing model more complicated.
+ 
+For third-party AI apps such as OpenAI, Anthropic Claude, or Gemini using your own provider connection, a normal module operation generally consumes Make credits while the AI provider charges separately for tokens.
+ 
+With Make's own AI Provider and some built-in AI features, credit consumption can instead depend on factors such as:
+ 
+- tokens
+- model
+- operation count
+- file size
+- page count
+- processing time
+ 
+This means an AI module does not always equal exactly one credit.
+ 
+Before deploying a high-volume AI scenario, estimate both:
+ 
+Make credits + external AI/API costs
+ 
+# What It Does
+ 
+Make connects applications visually using workflows called **scenarios**.
+ 
+A lead workflow could be:
+ 
+Website form → Validate lead → CRM → Email → Notify sales
+ 
+An e-commerce workflow might be:
+ 
+New order → Check payment → Update inventory → CRM → Fulfillment
+ 
+A reporting workflow could be:
+ 
+Schedule → Fetch advertising data → Fetch sales data → Aggregate → Send report
+ 
+Make becomes especially useful when data needs to be transformed, split into several branches, processed in batches, aggregated, or passed through several applications.
+ 
+Its visual scenario editor makes those relationships easier to inspect than a simple list of automation steps.
+ 
+# Getting Started
+ 
+The easiest way to learn Make is to use the cloud service and build one small scenario.
+ 
+Start with something like:
+ 
+Google Forms → Google Sheets
+ 
+Create a scenario, select the app that provides the trigger, and connect your account.
+ 
+Run the trigger once so Make can retrieve sample data.
+ 
+Then add Google Sheets and map values from the trigger into the appropriate columns.
+ 
+Run the scenario manually and verify that the expected row appears.
+ 
+After that, add a second action:
+ 
+Form → Google Sheets → Slack
+ 
+This introduces the basic Make concepts without requiring APIs, AI agents, or advanced routing.
+ 
+The main concepts to understand first are:
+ 
+- modules
+- bundles
+- mapping
+- credits
+- filters
+- scenario execution
+ 
+# How to Use
+ 
+A Make scenario is built from **modules**.
+ 
+A trigger module starts the scenario, while later modules search, create, update, transform, or send data.
+ 
+Data generally travels through Make as **bundles**.
+ 
+For example, a lead may contain:
+ 
+- name
+- email
+- company
+- country
+- message
+ 
+Those values can be mapped into later modules.
+ 
+A CRM module might use the email field to search for an existing contact, while Gmail uses the same email field as the recipient.
+ 
+## Filters and Routers
+ 
+Filters decide whether data should continue through a route.
+ 
+For example:
+ 
+New lead → Filter qualified leads → CRM
+ 
+This is useful when only part of the incoming data requires additional processing.
+ 
+Routers split a scenario into multiple paths:
+ 
+New order → Router
+ 
+- High-value order → Sales notification
+- Normal order → Standard processing
+- International order → Additional shipping process
+ 
+Filters are usually placed on individual routes so each bundle follows only the relevant path.
+ 
+## Iterators and Aggregators
+ 
+An iterator takes an array and separates it into individual bundles that can be processed separately.
+ 
+For example:
+ 
+Order with 5 products → Iterator → Process each product
+ 
+An aggregator does the opposite: it combines several bundles into a single output.
+ 
+These tools are useful, but they can also increase credit consumption because more bundles may cause later modules to run more times.
+ 
+## Webhooks and Scheduling
+ 
+Webhooks allow an external application to start a Make scenario immediately.
+ 
+For example:
+ 
+New payment → Webhook → Process order
+ 
+When a native instant trigger or webhook is available, it is often preferable to repeatedly checking an application for new data.
+ 
+Scheduled scenarios are useful when immediate execution is unnecessary.
+ 
+The Free plan currently has a minimum scheduled interval of 15 minutes, while Core and higher plans can schedule scenarios down to one-minute intervals.
+ 
+## HTTP and APIs
+ 
+If Make does not have the exact native integration or action you need, the HTTP app can connect to services that expose an API.
+ 
+This significantly expands what Make can automate.
+ 
+Instead of waiting for Make to add a specific module, an experienced user can often call the service's API directly.
+ 
+# Practical Workflows
+ 
+## Lead Qualification and CRM
+ 
+Website form → Filter → Search CRM → Create or update lead → Notify sales
+ 
+This automatically handles inbound leads and avoids manual CRM entry.
+ 
+Common integrations include Typeform, Facebook Lead Ads, HubSpot, Salesforce, Gmail, and Slack.
+ 
+Put simple qualification filters before enrichment services or AI analysis.
+ 
+The biggest risks are duplicate records and unnecessary credit consumption from processing leads that should have been filtered earlier.
+ 
+## E-commerce Order Processing
+ 
+New order → Router → Update inventory → CRM → Fulfillment notification → Customer email
+ 
+This can connect systems that would otherwise require employees to copy order information manually.
+ 
+Typical integrations include Shopify, WooCommerce, Stripe, Airtable, Google Sheets, and communication tools.
+ 
+The main risk is processing the same order or payment event twice.
+ 
+Store or check a unique order or payment ID before performing actions that should happen only once.
+ 
+## AI Content Processing
+ 
+New document → Extract content → Filter → AI processing → Store result → Notify reviewer
+ 
+This can be used for:
+ 
+- document classification
+- summarization
+- structured extraction
+- support-ticket processing
+- content operations
+ 
+AI should usually come after cheap deterministic filtering.
+ 
+For example:
+ 
+1,000 records → Filter → 120 relevant records → AI
+ 
+is generally more efficient than:
+ 
+1,000 records → AI → Filter
+ 
+This type of implementation can also be sold as part of an [AI Automation Agency](https://incomewiki.com/wiki/ai-automation-agency) service.
+ 
+# Tips &amp; Best Practices
+ 
+## Filter Before High-Cost Modules
+ 
+Make charges based partly on module activity, so scenario design directly affects cost.
+ 
+If a filter can eliminate 90% of records before five downstream modules run, place the filter first.
+ 
+This is particularly important before:
+ 
+- AI calls
+- enrichment APIs
+- email or SMS services
+- multi-step CRM processing
+ 
+## Understand Bundles Before Using Iterators
+ 
+One incoming record does not always equal one downstream operation.
+ 
+An iterator may turn one bundle containing 50 items into 50 individual bundles.
+ 
+If three later modules process all 50 bundles, that can create substantial additional activity.
+ 
+Use iterators when each item genuinely requires individual processing.
+ 
+## Prefer Webhooks to Frequent Polling
+ 
+Webhooks usually start a scenario as soon as data arrives.
+ 
+Polling triggers periodically ask an application whether anything has changed.
+ 
+When an instant trigger is available, using it can reduce unnecessary checks and shorten processing delay.
+ 
+Make currently supports both app-specific instant webhooks and custom webhooks.
+ 
+## Control API Rate Limits
+ 
+External APIs may reject large bursts of requests even when Make itself can process them.
+ 
+Typical symptoms include HTTP 429 errors.
+ 
+Use:
+ 
+- batching
+- delays
+- sequential processing
+- retries
+ 
+when the destination API cannot accept high request volume.
+ 
+The Make API itself also has plan-based limits. Current documented limits are 60 requests/minute on Core, 120 on Pro, 240 on Teams, and 1,000 on Enterprise.
+ 
+## Design for Duplicate Events
+ 
+Payments, orders, forms, and webhooks can occasionally arrive more than once.
+ 
+Before performing an irreversible action, check a unique identifier such as:
+ 
+- event ID
+- order ID
+- payment ID
+- email address combined with another business key
+ 
+Duplicate protection is particularly important before sending messages, provisioning accounts, issuing refunds, or creating orders.
+ 
+## Use Error Handling and Incomplete Executions
+ 
+Important scenarios should be designed for failure.
+ 
+Make can store **incomplete executions**, preserving unfinished runs when errors occur so they can be inspected or retried.
+ 
+This is useful for temporary failures such as connection errors or rate limits.
+ 
+Incomplete executions are disabled by default and must be enabled when you want this behavior.
+ 
+## Inspect Scenario History
+ 
+Scenario history shows information such as:
+ 
+- status
+- execution duration
+- operations
+- credits consumed
+- transferred data
+- module input and output
+ 
+Use it when a scenario technically ran but produced the wrong business result.
+ 
+Pro and higher plans currently include full-text execution-log search, which can make investigation easier in large histories.
+ 
+## Watch Time Zones and Scheduling
+ 
+Automations involving reports, appointments, invoices, or publishing can fail because the business timezone and the scenario timezone do not match.
+ 
+Set the expected timezone deliberately and test scenarios around date boundaries.
+ 
+# Business Uses
+ 
+Make is useful for businesses with several cloud applications that need to exchange data.
+ 
+**Sales and marketing** teams can connect lead forms, advertising platforms, CRMs, email tools, spreadsheets, and reporting systems.
+ 
+**Operations teams** can automate record transfers, approvals, internal notifications, database updates, and recurring administrative work.
+ 
+**E-commerce businesses** can connect orders, payments, customer records, fulfillment, inventory, and reporting.
+ 
+**Customer-support workflows** can retrieve account information, classify messages, update help-desk systems, and notify the correct team.
+ 
+**AI automation** can combine AI models with normal business applications instead of running AI as a separate isolated tool.
+ 
+Agencies and freelancers can sell Make scenario implementation, API integrations, automation audits, troubleshooting, and maintenance services. These services can complement [Freelancing](https://incomewiki.com/wiki/freelancing) or a broader automation agency.
+ 
+Make itself is usually a tool inside the service rather than the product being sold.
+ 
+# Integrations
+ 
+Make currently advertises **3,000+ apps** in its integration ecosystem.
+ 
+Common categories include:
+ 
+- **Google:** Gmail, Google Sheets, Google Drive
+- **CRM:** HubSpot, Salesforce, Pipedrive
+- **Communication:** Slack, Telegram, Microsoft services
+- **E-commerce:** Shopify and other commerce platforms
+- **Data:** Airtable, databases, spreadsheets
+- **AI:** OpenAI, Anthropic Claude, Google Gemini, Perplexity and other AI services
+- **Development:** GitHub, APIs and HTTP connections
+ 
+Use a native integration when it supports the required operation.
+ 
+Use a webhook when another system needs to trigger Make immediately.
+ 
+Use the HTTP app when the service exposes an API but Make does not provide the exact native action required.
+ 
+This ability to move from no-code modules to direct API calls is one of the most useful skills for advanced Make users.
+ 
+# Advanced Use
+ 
+Make provides an API on Core and higher plans for managing and interacting with Make programmatically.
+ 
+The Make API supports authentication through API tokens or OAuth 2.0.
+ 
+Current API request limits depend on plan:
+ 
+ 
+| Plan       | Make API Limit        |
+| ---------- | ---------------------: |
+| Core       | 60 requests/minute    |
+| Pro        | 120 requests/minute   |
+| Teams      | 240 requests/minute   |
+| Enterprise | 1,000 requests/minute |
+ 
+ 
+This API is different from using Make's HTTP module.
+ 
+The HTTP module allows a scenario to call an external service.
+ 
+The Make API allows another application to interact with the Make platform itself.
+ 
+Make also supports custom JavaScript and Python through its Code app for cases where normal modules and mapping tools are not sufficient. Code execution can consume credits based on execution time, so it should not automatically replace simpler built-in transformations.
+ 
+AI workflows can use Make AI Agents, Make AI Toolkit, third-party AI applications, and external model connections.
+ 
+Make is primarily a managed cloud platform. Unlike n8n, it does not provide a standard general-purpose self-hosted version of the Make automation platform.
+ 
+This reduces infrastructure work but also means users have less control over where and how the orchestration platform itself runs.
+ 
+# Limitations &amp; Common Mistakes
+ 
+The biggest practical limitation is that **credit usage can become difficult to estimate in complex scenarios**.
+ 
+A visual scenario may appear to contain only a few modules, but iterators, multiple bundles, routers, repeated searches, and AI processing can cause those modules to execute many times.
+ 
+This makes understanding the data flow important before scaling a scenario.
+ 
+Make is also more complex than simple trigger-and-action automation products. Users eventually need to understand:
+ 
+- arrays
+- bundles
+- mapping
+- iterators
+- aggregators
+- routers
+- APIs
+- HTTP
+- error handling
+ 
+Complex scenarios can become visually difficult to maintain when too many unrelated processes are placed on one canvas.
+ 
+Make is cloud-hosted, so users who specifically require full self-hosting should look at other platforms.
+ 
+External applications also impose their own API restrictions and costs.
+ 
+Common mistakes include:
+ 
+- filtering data too late
+- unnecessarily iterating large arrays
+- forgetting that each bundle can cause more module executions
+- ignoring API pagination
+- creating duplicate records
+- ignoring API rate limits
+- putting expensive AI processing before simple filters
+- failing to enable or inspect incomplete executions
+- ignoring scenario history after deployment
+ 
+The visual editor makes workflows easier to see, but it does not remove the need to design reliable data processing.
+ 
+# Alternatives
+ 
+The closest general alternatives are n8n and Zapier.
+ 
+ 
+| Factor                 | Make                              | n8n                                        | Zapier                |
+| ---------------------- | --------------------------------- | ------------------------------------------ | --------------------- |
+| Beginner friendliness  | Moderate                          | Moderate                                   | High                  |
+| Pricing model          | Credits                           | Workflow executions                        | Tasks                 |
+| Free option            | 1,000 credits/month               | Self-hosted Community Edition              | 100 tasks/month       |
+| Entry paid price       | $9/month annually at 10K credits  | €20/month annually                         | $19.99/month annually |
+| Visual workflow design | Very strong                       | Strong                                     | Strong                |
+| Technical flexibility  | High                              | Very high                                  | Moderate to high      |
+| Direct API workflows   | Strong                            | Very strong                                | Supported             |
+| Self-hosting           | No standard option                | Yes                                        | No standard option    |
+| Best fit               | Visual multi-step data automation | Technical and highly customized automation | Easy SaaS automation  |
+ 
+ 
+Choose **Make** when visualizing complex routes, transformations, and multi-app data flows is important.
+ 
+Choose **n8n** when self-hosting, infrastructure control, extensive custom code, or highly technical API orchestration matters more.
+ 
+Choose **Zapier** when ease of setup is the priority and the workflows mainly connect common SaaS applications without complicated data processing.
+ 
+The cheapest option depends on the structure of the workflow rather than only the entry subscription price.
+ 
+A Make scenario that expands many bundles across several modules may consume credits differently from the same business workflow on an execution-based platform.
+ 
+# FAQ
+ 
+## Is Make free?
+ 
+Yes. Make currently offers a Free plan with up to 1,000 credits per month.
+ 
+The Free plan also has a 15-minute minimum interval for scheduled scenarios.
+ 
+## What is a Make credit?
+ 
+Credits are Make's billing unit.
+ 
+For most normal non-AI modules, one operation consumes one credit. Some AI and advanced features can use credits dynamically based on factors such as tokens or processing.
+ 
+## Does Make require coding?
+ 
+No.
+ 
+Most scenarios can be built visually. API knowledge and custom code become useful for advanced integrations and data processing.
+ 
+## Can Make use AI?
+ 
+Yes.
+ 
+Make supports AI integrations, Make AI Agents, Make AI Toolkit, and connections to AI providers such as OpenAI, Anthropic, and Google Gemini.
+ 
+AI features may consume credits differently from ordinary modules.
+ 
+## Can Make be self-hosted?
+ 
+Make does not provide a standard general-purpose self-hosted version comparable to n8n Community Edition.
+ 
+It is primarily a managed cloud automation platform.
+ 
+## Is Make better than Zapier or n8n?
+ 
+It depends on the workflow.
+ 
+Make is particularly strong for visual, multi-step automation and complex data flows. Zapier is usually easier for straightforward SaaS automation, while n8n offers greater technical flexibility and self-hosting.
+ 
+# Sources
+ 
+- [Make Pricing](https://www.make.com/en/pricing) — current Free, Core, Pro, Teams, and Enterprise pricing, credit allowances, scheduling limits, and plan differences.
+- [Make Credits](https://help.make.com/credits) — current credit model, operations, AI credit consumption, external AI provider costs, and dynamic credit usage.
+- [Introducing Credits in Make](https://help.make.com/introducing-credits-new-billing-unit-live-in-make) — transition from operations to credits as Make's billing unit.
+- [Make App Integrations](https://www.make.com/en/integrations) — current integration ecosystem and supported application categories.
+- [Make Webhooks](https://help.make.com/webhooks) — instant triggers, custom webhooks, webhook queues, sequential processing, and webhook limits.
+- [Make Scenario History](https://help.make.com/scenario-history) — execution logs, credit usage, module outputs, troubleshooting, and full-text history search.
+- [Make Incomplete Executions](https://help.make.com/incomplete-executions) — storing failed scenario runs and preventing data loss.
+- [Managing Incomplete Executions](https://help.make.com/manage-incomplete-executions) — retrying, resolving, and deleting failed scenario executions.
+- [Make API Authentication](https://developers.make.com/api-documentation/authentication) — API token and OAuth 2.0 authentication.
+- [Creating a Make API Token](https://developers.make.com/api-documentation/authentication/create-authentication-token) — creating and managing Make API credentials.
+- [Make API Rate Limiting](https://developers.make.com/api-documentation/getting-started/rate-limiting) — Core, Pro, Teams, and Enterprise API request limits.
+- [Making Your First Make API Request](https://developers.make.com/api-documentation/getting-started/making-your-first-api-request) — basic Make API request structure and authentication.
+- [n8n Pricing](https://n8n.io/pricing/) — comparison pricing and workflow-execution model.
+- [Zapier Pricing](https://zapier.com/pricing) — comparison pricing and task-based model.