Make Pricing for Small Business (2026): Plans, Credits, Extra Usage, and Real Monthly Cost

Make pricing starts at $0 for 1,000 credits a month. At 10,000 credits, Core costs $10.59 month-to-month or $9 a month billed annually; Pro costs $18.82 or $16; and Teams costs $34.12 or $29. Enterprise uses custom pricing. For most small businesses, Core is the practical starting point. Pro is mainly an execution and troubleshooting upgrade, while Teams is the first sensible tier for shared ownership and role controls.

The subscription price is only half the answer. Make usually charges one credit each time a module runs, and bundles can make downstream modules run repeatedly. Polling consumes credits even when no new data appears. AI features may add dynamic token-based credit use or a separate provider bill. Price Make from actual scenario runs—not from the number of automations you hope to build.

The right Make plan depends on both workflow volume and who must build, monitor, and govern the automations.

Prices and plan limits below were verified against Make's first-party pricing page and help documentation on August 21, 2026. Prices are in US dollars and exclude taxes, currency conversion, implementation labor, and third-party AI charges.

Make pricing at a glance

Core is the best-value Make plan for a solo owner; Teams is the better default when several people jointly operate automations. Pro makes sense when priority execution, custom variables, or searchable execution logs solve an actual operating problem.

Make's paid-plan selector scales beyond 10,000 credits. The plan and the credit tier are separate decisions: moving from Core to Pro buys capabilities, while moving from 10,000 to 40,000 credits buys more usage. At 40,000 credits, Core is currently $34.12 monthly or $29 a month billed annually. Annual prices require payment in advance.

What each Make plan includes

The plan ladder adds execution, collaboration, governance, and support features; it does not make every scenario cheaper per run. All plans provide the visual builder and access to Make's app ecosystem, but meaningful operating limits differ.

Free is useful for learning, but two active scenarios, 15-minute scheduling, smaller files, and 1,000 credits make it a poor foundation for time-sensitive operations. Core removes the active-scenario cap, enables one-minute scheduling, raises file and transfer limits, and provides API access.

Pro adds priority scenario execution, custom variables, and full-text execution-log search. Those features improve reliability and diagnosis; they do not automatically reduce credit use. Teams adds team roles and shared scenario templates. Enterprise adds custom functions, enterprise app integrations, advanced security, overage protection, 24/7 support, and Value Engineering access. Obtain a written quote and controls matrix because public feature labels are not contractual scope.

Make lists unlimited users in its comparison table, but collaboration quality is not identical across tiers. Private spaces exist across plans, while team roles and shared templates begin on Teams. Enterprise adds stronger organization-wide governance such as custom roles, SSO/domain controls, audit capabilities, and higher-touch support.

What consumes a Make credit?

Most non-AI modules use one credit per operation, and an operation is one module run that processes or checks data. The number of credits is therefore driven by module executions and bundles—not merely by the number of scenarios.

• A polling trigger uses one credit each time it checks, even when it finds nothing.
• A search module normally uses one credit per run, even if it returns several bundles.
• An action module uses one credit for each input bundle it processes.
• An aggregator uses one credit to combine multiple bundles into one array.
• An iterator uses one credit to split an array; each downstream action then runs once per iterated bundle.
• Routers, filters, Make Functions, and listed error-handler modules do not consume credits themselves, but modules reached through their routes can.
• Make Code uses two credits per second of execution time.
• Some AI and advanced modules use dynamic rates based on tokens, file size, page count, or run time.

Suppose one scheduled trigger returns ten new leads. The trigger costs one operation. If three later action modules each process all ten lead bundles, those modules use 30 more operations. The run totals 31 credits before any AI usage. An aggregator can sometimes reduce downstream repetition, but it adds an operation of its own and changes the data shape.

Bundles multiply downstream module runs; AI usage may add a second variable meter or provider bill.

How loops, polling, and incomplete executions change usage

The expensive scenario is often the one that repeats quietly. A simple diagram can hide substantial consumption when it polls frequently, expands arrays, retries work, or processes old incomplete runs.

Polling deserves attention first. A scenario checking every minute runs 43,200 times in a 30-day month. If the trigger uses one credit per check, that trigger alone can consume 43,200 credits—even when most checks find nothing. Use webhooks where available, or choose a schedule that matches the business's real latency requirement.

Iterators and repeaters fan work out. If one order contains eight line items, an iterator can emit eight bundles. Each subsequent lookup, update, and notification can then run eight times. Routers and filters are free modules, but a bundle traveling through two paid branches can still cause paid actions on both branches.

An incomplete execution is stored when configured error handling leaves work unfinished. Credits already consumed before the error are not magically refunded. Retrying or resolving the incomplete execution can run modules again and consume more credits. That is why idempotency—preventing the same order, invoice, or message from being applied twice—is both a reliability control and a cost control.

Extra credits, upgrades, and usage allowance

Paid customers can upgrade, manually buy extra credits, or enable automatic extra-credit purchases. Extra credits carry a 25% surcharge. They are an overflow mechanism, not a substitute for choosing the right recurring tier.

Make says extra credits are consumed after the subscription allowance. Auto-purchasing buys 10,000-credit bundles and is available on Core, Pro, and Teams. Manual purchases may be available in 1,000- or 10,000-credit bundles. If payment fails, scenarios pause until billing is fixed.

Extra credits expire with the applicable term. On monthly plans they expire at the end of the current billing cycle. For annual Pro and Teams plans, they can remain valid to the end of the billing year; annual Core is a notable exception because its regular and extra credits reset monthly. Confirm the displayed expiry before buying.

Usage allowance scales with purchased credits. For each 10,000 monthly credits, Make currently lists 5 GB data transfer, 10 MB data storage, 10 MB incomplete-execution storage up to 2 GB, and 667 queued webhooks up to 10,000. Extra credits add data-transfer allowance but do not raise every other plan parameter. Buying credits will not turn Core collaboration controls into Teams controls or increase a plan-specific file-size limit.

The cheaper long-term move is usually to move to a higher recurring credit tier once overflow becomes predictable. Paying a 25% premium every month for the privilege of discovering your own baseline is SaaS's version of renting the same ladder forever.

Ordinary credits and AI charges are different

A normal Make credit pays for platform activity; AI usage can add dynamic Make credits or a separate model-provider invoice. Treat these as separate budget lines.

With Make's AI Provider, available on all plans for Make AI Agents and AI Toolkit, Make charges an operational credit plus token-based credits. Model choice and input/output length affect the conversion. Automatic-provider features such as AI Web Search or some Content Extractor modules can use credits based on tokens, operations, files, pages, or other factors.

With a custom OpenAI, Anthropic, or Gemini connection on a paid plan, Make generally charges the module operation while the AI provider bills token usage directly. A third-party AI module may therefore show modest Make consumption while creating a separate provider cost. Large prompts, long histories, retrieved documents, embeddings, repeated tool calls, and retries increase that second bill.

This guide covers general Make platform pricing. Make AI Agents has its own pricing and usage questions around agent chats, model tokens, context, and tool calls; see the separate Make AI Agents pricing guide for that intent.

Real monthly cost for light, moderate, and higher-volume workflows

Estimate monthly business events, polling checks, and modules per bundle, then add a safety margin. The following models are planning examples, not promises about a particular build.

The light case leaves enough room for edits, reruns, and ordinary variance. Free could technically carry a narrower workload, but a business process that matters should not be designed around a 1,000-credit ceiling and 15-minute schedule.

The moderate case illustrates why plan tier and credit tier should be separated. Core 40k is cheaper than Pro 40k if the team does not need Pro's execution priority, custom variables, or log search. If the operation is customer-facing or hard to troubleshoot, Pro may be worth the capability premium even though both plans include the same chosen credit volume.

The higher-volume case uses the next published Core tier above the estimate rather than 150,000 credits with no buffer. A webhook-heavy design, aggregation, or fewer downstream actions could reduce usage; polling, iterators, errors, or AI could increase it. At this size, export real usage by scenario, price the staff time needed to operate it, and compare Make vs n8n as well as Zapier vs Make.

Which Make plan fits your team?

Buy the lowest tier that meets both your usage and governance needs, with enough credit headroom for retries and growth. Do not upgrade solely because a pricing card calls itself “recommended.”

Plan fit changes with collaboration and governance needs, not only with credit volume.

Solo owner: choose Core

Core is the best default for a solo owner running lead routing, notifications, record synchronization, and scheduled reporting. It removes Free's two-scenario limit and permits one-minute schedules. Start at 10,000 credits, measure two full business cycles, then change the credit tier if sustained usage exceeds roughly 70% to 80% of the allowance.

Avoid Free for critical workflows. Choose Pro only if priority execution, custom variables, or execution-log search clearly saves operating time.

Operations team: choose Teams, or Pro with one owner

Teams is the cleanest fit when several people build or manage scenarios because it adds team roles and shared templates. If one automation owner builds everything and colleagues only consume outputs, Pro may be enough. Document credential ownership, alert routing, change approval, and who handles failed runs before multiplying builders.

Agency: choose Teams and price clients separately

Teams fits an agency that needs roles, reusable scenario templates, and multiple operators. Do not combine every client into one undifferentiated credit pool without internal allocation. Track consumption, data transfer, credentials, failure ownership, and model-provider charges per client. Enterprise may be required for stronger access controls or contractual support, but the quote must be evaluated against actual client requirements.

Technical team: choose Pro first; compare Enterprise at the governance edge

Pro is usually the right starting point for a technical team because priority execution, custom variables, and log search improve operations. Enterprise becomes relevant for custom functions, enterprise apps, advanced security controls, higher API limits, formal support, and organization-wide governance. Technical teams should also compare Make vs n8n when long workflows, code, or self-hosting materially change the economics.

How to estimate your own Make bill

The reliable estimate comes from a representative scenario, not a feature list. Use this short process:

1. List each trigger and its monthly frequency, including empty polling checks.
2. Estimate how many bundles each trigger returns.
3. Count paid downstream module runs per bundle and per route.
4. Add iterator, aggregator, search, and code-module costs using Make's current rules.
5. Add expected retries, incomplete-execution recovery, manual reruns, and testing.
6. Separate Make AI Provider credits from external AI-provider token charges.
7. Check data transfer, file size, execution time, log retention, API limits, and collaboration controls.
8. Add 20% to 30% headroom, then select the lowest plan and credit tier that clears both usage and feature constraints.

Monitor the first two full billing cycles by scenario. Optimize pathological polling and bundle fan-out before purchasing permanent excess capacity. If usage is consistently high, upgrade the recurring credit tier rather than leaning on surcharged extras.

Methodology and limitations

This article is a vendor-independent editorial synthesis verified against Make's first-party pricing page and help-center documentation on August 21, 2026. It is not based on hands-on product testing. The live pricing payload was used to confirm plan names, USD monthly and annual prices, credit tiers, and current feature limits. Make can change prices, model conversion rates, plan entitlements, and usage rules; verify checkout and obtain written Enterprise terms before buying. Google Search Console and GA4 evidence was unavailable, so no first-party traffic or conversion claims were used.

Frequently asked questions

Is Make free for small business?

Make Free has no time limit and includes 1,000 credits a month, but it allows only two active scenarios and a 15-minute minimum scheduled interval. It is best for learning or very light noncritical automation.

How much does Make Core cost?

At 10,000 credits, Make Core costs $10.59 month-to-month or $9 a month billed annually. Higher credit tiers cost more; annual billing requires advance payment.

Does every Make module cost one credit?

Most non-AI modules use one credit per operation, but exceptions exist. Make Code uses two credits per second, some modules are free, and AI or advanced modules can use dynamic rates.

Do failed Make scenarios still use credits?

Modules that ran before a failure already consumed credits. Retrying or resolving an incomplete execution can consume additional credits, so error handling and idempotency affect both reliability and cost.

Are AI tokens included in Make pricing?

It depends on the connection. Make's AI Provider converts token use into Make credits. With a custom provider connection, Make charges operations while OpenAI, Anthropic, Gemini, or another provider bills tokens separately.

What happens when Make credits run out?

Scenarios pause unless credits are added through an upgrade, manual extra-credit purchase, or enabled auto-purchasing. Extra credits carry a 25% surcharge, and failed payment can pause scenarios.