Make Pricing (2026): Free Stops at Two Active Scenarios

Make is genuinely free, but the useful answer is narrower: Free stops at two active scenarios and 1,000 credits a month. Core is the default paid plan at $9 a month on annual billing or $12 month to month, unless polling, code, or AI empties the credit pool before the scenario does useful work.

Prices and limits were verified against Make's live pricing page and billing documentation on 16 August 2026. The annual prices below are monthly equivalents, not monthly payment plans: Make charges the full year upfront.

Make pricing at a glance

Make has five plans, but the first paid choice is simpler than the lineup makes it look. Free is a durable sandbox. Core removes the production constraints. Pro buys execution priority and observability. Teams adds governance. Enterprise is a negotiated operating model for security, support, and scale.

The paid prices in the table are the entry tiers with 10,000 credits a month or the annual equivalent. Make also lets you buy larger credit tiers. Core scales to 300,000 credits a month; Pro scales to 8 million. That distinction matters because a move from Core to Pro is often a feature purchase, not the cheapest way to buy more credits.

Annual billing saves $36 a year on Core, $60 on Pro, and $108 on Teams compared with paying month to month. Those are savings of 25%, 23.8%, and 23.7%, respectively. The trade is commitment: $9 Core means a $108 charge now, not nine dollars leaving the card each month.

Make's entry paid tiers all begin with the same 10,000-credit allowance. Core gives unlimited active scenarios, one-minute scheduling, 40-minute maximum runs, 100 MB files, 5 GB of data transfer, 30 days of logs, and Make API access at 60 calls per minute. Pro keeps that entry credit pool but adds priority execution, custom variables, full-text log search, 250 MB files, and 120 API calls per minute. Teams adds team roles, shared scenario templates, 500 MB files, and 240 API calls per minute. Enterprise reaches 1 GB files, 60 days of logs, and 1,000 API calls per minute, alongside custom functions, enterprise integrations, overage protection, advanced security, and 24/7 support.

The default call for a small business is Core. Buy Pro when its debugging and execution features return more time than the price difference. Buy Teams when permissions become an operational requirement. Neither upgrade should happen just because the names sound more professional.

Is Make free? What the free plan allows

Make Free costs $0 and has no time limit. It includes 1,000 credits each month, two active scenarios, access to more than 3,000 standard apps, routers and filters, and customer support. A free account can stay free indefinitely; this is not a trial that starts billing after a countdown.

The limits make Free suitable for a specific kind of work:

• One or two personal automations that run infrequently.
• A low-volume webhook that reacts only when an event occurs.
• A prototype used to validate the scenario before it becomes business-critical.
• A weekly digest or simple record sync where a 15-minute schedule is acceptable.

Free becomes the wrong plan when any one of four boundaries breaks. The first is the two-scenario ceiling. The third workflow cannot be active, even if the first two barely use credits. The second is the 1,000-credit allowance. The third is execution cadence: scheduled scenarios can run no more often than every 15 minutes. The fourth is production headroom, including a five-minute maximum run, 5 MB files, 512 MB of data transfer, and only seven days of execution logs.

Who never needs to pay? Someone with no more than two quiet automations, less than 1,000 monthly module actions, small files, and no need for fast polling or long debugging history. If a personal form sends a few submissions into a spreadsheet and a weekly summary sends an email, Free can be enough. The moment the workflow is tied to leads, orders, support tickets, or another process where a pause has a cost, Core's $9 annual equivalent is cheap insurance.

The free-plan mistake is counting completed business outcomes instead of module work. A scenario that receives a lead, looks up an account, creates a CRM record, adds a row, and sends a notification may spend several credits for one lead. A 1,000-credit allowance is not necessarily 1,000 leads. It is the sum of the billable operations that processed them.

How Make credits turn into a bill

Make calls its purchased unit a credit. Most ordinary modules consume one credit per operation, but the number of operations depends on module type and the bundles of data moving through the scenario. This is the part to model before choosing a plan.

A trigger uses one credit every time it checks, even when it finds nothing. A search uses one credit for the run even if it returns multiple bundles. An action usually uses one credit for each input bundle it processes. An aggregator uses one credit for each aggregation. An iterator uses one credit to split an array, then each downstream module can consume one credit for every item produced.

That creates two very different cost profiles. A search that returns ten rows can cost one credit. The following delete action can cost ten because it handles each row separately. The visual scenario still shows two modules, but the execution used eleven credits.

Make's current rules create an important exception. Its credit documentation, updated 13 August 2026, says routers and filters use zero credits. Error handlers also use zero, as do the subscenario control modules and Make Functions. A router can make a scenario look larger without increasing its credit count. The bill comes from the billable modules that run on each branch, not the branch itself.

Make Code has a different meter: two credits per second of execution. A short script can therefore cost more than several ordinary app actions. Make's built-in AI also breaks the one-operation, one-credit assumption. With Make's AI Provider, AI Toolkit and AI Agents use one credit per operation plus credits based on token usage. With a custom provider connection on a paid plan, Make charges a fixed one credit per operation, while the model provider sends its own token bill.

That is the app-versus-provider split to budget. Connecting an OpenAI or Anthropic key does not make AI usage free. It changes where part of the charge lands. Make meters the automation operation, and the model vendor meters tokens separately. The custom connection can make cost analysis clearer, but it creates two invoices.

The public Make API begins on Core. It is included as a plan capability, with rate limits rising from 60 calls per minute on Core to 120 on Pro, 240 on Teams, and 1,000 on Enterprise. Those limits are not the same as the scenario credit pool. A buyer choosing Pro for a higher API limit is buying throughput and observability, while a buyer simply running out of scenario credits should first inspect the larger credit tiers available inside Core.

Make cost math for real workflows

The most expensive Make module can be the one that returns no data.

Take a polling trigger scheduled every five minutes. It checks 288 times a day. Across a 30-day month, it consumes 8,640 credits even if the source never produces a new record. On the 10,000-credit Core entry tier, only 1,360 credits remain for the actions that do the actual work.

Set that same trigger to Make's one-minute minimum and the timer consumes 43,200 credits in a 30-day month. That already exceeds the Core entry allowance by more than four times before a useful record moves. Switching to a webhook, where the source supports one, changes the budget from constant checking to event-driven work.

Make Code can create the same surprise. A script that runs for five seconds costs ten credits. Run it 1,000 times and it consumes 10,000 credits, the entire entry Core allowance. The correct question is not whether five seconds sounds short. It is whether that code runs once per batch or once per item.

Now price a normal outcome. Suppose one completed lead requires four billable credits. At 500 leads, the scenario uses 2,000 credits. If Core is the only workflow on the account, the $12 monthly subscription works out to 2.4 cents per completed lead at that actual volume. On annual billing, the $9 monthly equivalent is 1.8 cents.

At full use of the 10,000-credit allowance, the same four-credit scenario can process 2,500 outcomes. The subscription component then falls to 0.48 cents per outcome month to month or 0.36 cents on annual billing. That difference shows why cost-per-credit comparisons need a utilization assumption. A cheap allowance that sits unused is not a cheap outcome.

The practical budgeting method is short:

1. Count each trigger check, search, aggregation, and ordinary action.
2. Multiply per-bundle actions by the expected number of bundles.
3. Price code by execution seconds and built-in AI by its separate token-credit rule.
4. Multiply credits per outcome by expected monthly outcomes.
5. Add a buffer for retries, errors, and volume spikes, then compare that total with the plan's credit tier.

That calculation is the Monday move: open the highest-volume scenario, read one successful execution, and write down credits per completed outcome. Then look at triggers with no returned data. Those two checks usually reveal whether the budget problem is useful volume, empty polling, or a bundle explosion downstream.

Which Make plan should you choose?

Make Free is for proving the scenario. Make Core is for operating it. Pro and Teams need a named reason.

Choose Free for two quiet workflows

Stay on Free when two active scenarios are enough, total usage remains below 1,000 credits, a 15-minute schedule is acceptable, and seven days of logs provide enough debugging history. This is a strong permanent plan for personal or low-stakes automation. It is a weak production plan when a missed order or delayed lead has a business cost.

Choose Core for most small businesses

Core is the best-value paid tier because it removes the active-scenario cap, allows one-minute schedules, extends runs to 40 minutes, raises file handling to 100 MB, and opens the Make API. At $9 a month equivalent on annual billing or $12 month to month, the price is lower than the labor cost of manually checking one failed workflow.

Start month to month if the workflow is still changing. The annual plan saves $36 a year, but that saving is not large enough to justify locking in a scenario whose volume and architecture are still unknown. Move to annual after one or two billing cycles expose the steady credit load.

Choose Pro for observability and priority

Pro starts at $16 a month equivalent annually or $21 monthly. Its case is not the same 10,000-credit entry allowance. The case is priority scenario execution, custom variables, full-text execution-log search, larger files, and a higher API rate limit.

The annual-equivalent premium over Core is $7 a month. At an operator value of $60 an hour, Pro pays for itself if its search and priority features save seven minutes a month. On month-to-month billing, the $9 premium needs nine minutes. If failures are rare and logs are easy to inspect, keep Core and buy the right credit tier. If one incident sends someone scrolling through execution history for half an hour, Pro has already justified the difference.

Choose Teams for control, not headcount alone

Teams starts at $29 a month equivalent annually or $38 monthly. It adds team roles and shared scenario templates, increases the file limit to 500 MB, and raises the API rate limit to 240 calls per minute.

The annual-equivalent premium over Pro is $13 a month. At $60 an hour, the governance features need to save thirteen minutes a month to cover it. Month to month, the $17 premium needs seventeen minutes. The stronger reason is risk: roles become worthwhile when several people can alter connections, templates, or production scenarios and access must be explicit.

Choose Enterprise for a procurement requirement

Enterprise is custom-priced. It is the correct conversation when the organization needs custom functions, enterprise applications, advanced security, overage protection, 24/7 top-priority support, or the Value Engineering team. A 1 GB file ceiling, 60-day logs, and 1,000 API calls per minute matter at scale, but security and support requirements will usually trigger the purchase before those numeric limits do.

The clean rule is to choose the lowest plan that contains the required capability, then select the credit tier that covers measured usage. Plan and capacity are two separate decisions.

Hidden Make costs and billing rules

Make's sticker price is not the full budget. Several rules determine whether the invoice stays predictable.

Extra credits carry a 25% premium

Under Make's extra-credit rules, both manual and automatic extra credits cost 25% more than credits included in the plan. Manual purchases come in 1,000-credit increments. Auto-purchasing buys 10,000 credits at a time and can repeat until it reaches the plan's configured cap.

On the $9 Core annual-equivalent rate, Make's own example prices 1,000 extra credits at $1.125 and 10,000 at $11.25. On the $12 Core monthly rate, the same calculation produces $1.50 and $15. Auto-purchase can therefore turn a small overrun into a full 10,000-credit purchase. Use it to protect an important workflow, not as the default capacity plan.

If usage regularly crosses the allowance, compare the next credit tier before accepting the premium. Overage is useful for a spike. It is expensive as a subscription strategy.

Credits expire, and Core annual behaves differently

Extra credits on a monthly plan expire at the end of the current billing cycle. Annual billing is more nuanced. Pro and Teams receive a flexible yearly credit package. Core retains monthly credit allocation even on an annual subscription, and its extra credits expire at each monthly reset.

This makes annual Pro or Teams more forgiving for seasonal usage than annual Core. A retailer with a holiday spike can draw from a yearly Pro or Teams pool. A Core buyer cannot assume unused monthly credits will accumulate for that season.

Annual means prepaid and refunds are not cash

Make charges annual subscriptions in full upfront. The company also states a no cash refund policy. On an upgrade, unused credits can convert into a dollar discount. On a downgrade, unused credits can transfer for 30 days on a monthly plan or 365 days on an annual plan. Those mechanisms are account value, not a cash refund.

Cancellation normally leaves the paid plan active through the current monthly cycle or annual term. The organization then moves to Free when eligible. That is useful if the purchase is already committed, but it does not remove the annual-lock risk.

Running out pauses the workflow

Make sends usage notifications at 75% and 90%. If the account reaches its credit limit without extra credits or an upgrade, scenarios stop. Incoming webhooks can queue within the account's webhook allowance, and polling scenarios search from the last successful run after service resumes. A queue is not the same as uninterrupted processing. Time-sensitive workflows need either headroom, auto-purchase, or Enterprise overage protection.

AI can create a second bill

Make's AI Provider is available on all plans, but AI Toolkit and AI Agents use one operation credit plus token-based credits. A custom AI provider connection is available on paid plans and fixes the Make side at one credit per operation, while the external provider charges for its own tokens. Budget both meters. A scenario can remain inside its Make allowance and still create a material model-provider invoice.

The same discipline applies to other connected services. Make prices the orchestration. It does not erase the commercial terms of the app or model being called.

Make vs Zapier vs n8n pricing

Make, Zapier, and n8n bill different units, so comparing only their monthly prices produces the wrong call. Make sells module credits. Zapier sells successful action tasks. n8n Cloud sells complete workflow executions. The deeper Make, Zapier, and n8n comparison covers the operating tradeoffs; the pricing decision starts with a normalized completed outcome.

Make vs Zapier

Zapier's Free plan includes 100 tasks a month and limits workflows to two-step Zaps. Its live pricing page advertises Professional from $19.99 a month at a 750-task entry package. Team starts at $69 a month and includes 25 users.

Zapier counts successful actions as tasks. Trigger checks and built-in controls including Filters, Formatter, Paths, Delay, Looping, Sub-Zap, Digest, and Storage do not count. Make charges a polling trigger even when it returns nothing, while its routers and filters are free. The cheaper platform therefore depends on where the work sits.

At the $19.99 for 750-task entry package, Zapier costs $26.65 per 1,000 tasks when normalized. A completed outcome with four billable actions extrapolates to $106.61 per 1,000 outcomes at that unit rate. The comparable four-credit Make outcome costs $3.60 per 1,000 at full Core annual utilization or $4.80 month to month.

That is not a promise that every Make workflow is dramatically cheaper. Zapier's free trigger checks and built-in steps can remove billed work, while an inefficient Make polling design can burn the allowance before processing an event. It does show why multi-action, high-volume workflows usually favor Make on unit economics. For a fuller treatment of task tiers and overages, see the current Zapier pricing breakdown.

Choose Zapier when its workflow model or app support removes enough setup and maintenance to offset the higher task rate. Choose Make when scenario complexity and action volume make unit cost the deciding constraint.

Make vs n8n

n8n Cloud Starter costs $20 a month billed annually for 2,500 complete workflow executions. It allows unlimited workflow steps and users, one shared project, and five concurrent executions. Pro costs $50 a month billed annually for 10,000 executions. Business costs $800 a month billed annually for 40,000 executions and is self-hosted.

n8n Starter works out to $8 per 1,000 complete executions. That meter favors long, step-heavy workflows because adding steps does not add execution charges. Make's annual Core entry rate is $0.90 per 1,000 credits. A four-credit outcome costs $3.60 per 1,000 completed outcomes, but a nine-credit outcome reaches $8.10 per 1,000 and crosses n8n Starter's entry unit rate.

The crossover is only the software meter. n8n Community Edition is free software, but the user supplies and operates the infrastructure. That can be an advantage for control and data residency, or a hidden labor bill for backups, upgrades, monitoring, and incidents. n8n Cloud removes most of that burden but keeps the per-execution plan limits.

Choose n8n when workflows are step-heavy, technical ownership is available, or self-hosting is a requirement. Choose Make when the visual builder, managed service, and low cost for short to medium scenarios matter more.

The verdict

Make Core is the best plan for most small businesses. Its $9 annual equivalent or $12 monthly price buys unlimited active scenarios, one-minute schedules, API access, and enough capacity to learn what production usage looks like. Start monthly, measure credits per completed outcome, eliminate empty polling, then commit annually if the scenario is stable.

Stay on Free if two quiet workflows and 1,000 credits cover the job. Upgrade to Pro only when priority execution, custom variables, or searchable logs return at least seven minutes a month on annual pricing. Upgrade to Teams when permissions and shared templates reduce operational risk. If a workflow routinely uses about nine or more Make credits per completed run, price n8n's execution model beside it before buying a larger allowance.

The important budget line is not the plan name. It is credits per useful outcome, plus the cost of the person who notices when the workflow stops.

Make pricing FAQ

Is Make.com totally free?

Yes. Make Free costs $0, has no time limit, and includes 1,000 credits a month. It stops at two active scenarios, 15-minute scheduled intervals, five-minute maximum runs, 5 MB files, 512 MB of data transfer, and seven days of logs.

How much does Make.com cost?

Make Core starts at $9 a month equivalent with $108 paid upfront for the year, or $12 month to month. Pro starts at $16 annual equivalent or $21 monthly. Teams starts at $29 annual equivalent or $38 monthly. All three entry paid tiers include 10,000 credits per month or the annual equivalent; Enterprise is custom-priced.

Is Make AI free to use?

Make's AI Provider is available on all plans, including Free, but AI usage is still metered. AI Toolkit and AI Agents use one credit per operation plus token-based credits. Paid plans can use a custom provider connection, which costs one Make credit per operation while the external model provider bills tokens separately.

Does Make offer a student discount?

Make does not publish a general student discount as of 16 August 2026. Its live pricing page publishes savings for annual prepayment and asks NGO or NPO customers to contact the company for nonprofit support.

Can I get a refund from Make?

Make states a no cash refund policy. Cancellation keeps the paid plan active through the current monthly billing cycle or annual term, then moves the organization to Free when eligible. Upgrades can convert unused credits into a discount, and downgrades can transfer unused credits, but those are not cash refunds.

Did Make pricing change?

Make changed its purchased billing unit from operations to credits on 27 August 2025. On 6 November 2025, it standardized both manual and automatic extra-credit purchases at a 25% premium, capped Core at 300,000 monthly credits, and expanded Pro to 8 million. Documentation that still uses operations or different overage rules describes the prior system.

Get the AI Business Workflow Audit Checklist

A practical checklist for finding costly steps, choosing the right automation model, and budgeting the workflow before it scales.