IncomeWikiMake
Created by @namkyu · Updated Aug 31, 2026
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 |
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 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
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.
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
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 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.
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 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.
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.
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.
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.
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 service.
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
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.
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.
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.
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.
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.
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.
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.
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 or a broader automation agency.
Make itself is usually a tool inside the service rather than the product being sold.
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.
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.
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.
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.
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.
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.
No.
Most scenarios can be built visually. API knowledge and custom code become useful for advanced integrations and data processing.
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.
Make does not provide a standard general-purpose self-hosted version comparable to n8n Community Edition.
It is primarily a managed cloud automation platform.
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.
Make Pricing — current Free, Core, Pro, Teams, and Enterprise pricing, credit allowances, scheduling limits, and plan differences.
Make Credits — current credit model, operations, AI credit consumption, external AI provider costs, and dynamic credit usage.
Introducing Credits in Make — transition from operations to credits as Make's billing unit.
Make App Integrations — current integration ecosystem and supported application categories.
Make Webhooks — instant triggers, custom webhooks, webhook queues, sequential processing, and webhook limits.
Make Scenario History — execution logs, credit usage, module outputs, troubleshooting, and full-text history search.
Make Incomplete Executions — storing failed scenario runs and preventing data loss.
Managing Incomplete Executions — retrying, resolving, and deleting failed scenario executions.
Make API Authentication — API token and OAuth 2.0 authentication.
Creating a Make API Token — creating and managing Make API credentials.
Make API Rate Limiting — Core, Pro, Teams, and Enterprise API request limits.
Making Your First Make API Request — basic Make API request structure and authentication.
n8n Pricing — comparison pricing and workflow-execution model.
Zapier Pricing — comparison pricing and task-based model.
Linked Pages
Backlinks
No published pages link to this document yet.