Make pricing

About

Make (formerly Integromat) is a visual, no-code automation platform — an iPaaS — that lets users build “scenarios” connecting more than 3,000 apps with a drag-and-drop interface, and increasingly with AI agents and an MCP server. It targets a spectrum from individual prosumers automating personal workflows to SMB teams and large enterprises orchestrating critical business processes. The platform is owned by process-mining company Celonis (the pricing page footer reads ”© 2026 Celonis, Inc.”).

Make positions itself against Zapier and other automation tools on the strength of its visual-first builder, generous app library, and a usage-metered model that scales by volume rather than per-task seat counts. Active scenarios and users are unlimited on paid plans — what you buy is throughput, measured in credits.

The defining pricing fact for Make is that its value metric is the credit. Make renamed its long-standing “operations” metric to “credits”: for non-AI apps, one operation (a single module run) still equals exactly one credit, so the rename is a re-labeling of the metric rather than a repricing. AI features layer dynamic, token-based credit consumption on top of this base unit.

Pricing summary : how Make’s credit-metered automation pricing works

Make uses a credit-metered (volume-tiered) model with a free tier, structured around two dimensions:

1. Credit volume (the value metric): You buy a monthly credit allowance. For non-AI apps, 1 operation = 1 credit, where an operation is a single module run. The Free plan includes up to 1,000 credits/mo; the paid Make Plan is priced by a slider that scales the monthly credit allowance from 5,000 credits/mo (at $9/mo) up to 8M+ credits/mo.
2. Dynamic AI usage: AI and some advanced apps consume credits dynamically rather than 1:1. With Make’s AI Provider, credits are based on tokens and operations, with conversion rates that vary by model (e.g. GPT-5 mini at 1,500 tokens per credit; Claude Sonnet 4.5 at 301 input / 60 output tokens per credit). The Make Code App consumes 2 credits per 1 second of code-execution time.

What makes this different: Make sells throughput, not seats — active scenarios and users are unlimited on the paid plan, and the entire paid tier is expressed as a single credit-volume slider rather than a ladder of named plans.

Pricing by product

Make platform (Individual and SMB plans)

Make platform (Enterprise)

Sales motions across products: PLG / self-serve for the Free and Make Plan tiers (sign up online, slider-driven checkout); sales-led for the Company (Enterprise) plan.

Credit value-metric: how credits are consumed

The credit is Make’s single billing unit, replacing the older “operations” term. How a feature consumes credits depends on its type:

For third-party AI apps with a custom connection (e.g. OpenAI, Anthropic, Gemini), you pay Make for credits based on operations and your AI provider for tokens directly. With Make’s AI Provider (available on all plans), Make handles the AI connection and charges credits based on both tokens and operations.

Hidden costs : what real Make users actually pay as volume scales

The “from $9/mo” headline is the entry 5,000-credit slider step, and it understates what an active account pays for two reasons: non-AI scenarios spend credits on every module run, so a multi-step workflow burns several credits per execution, and AI modules abandon the clean 1-op-1-credit rate for dynamic, token-based consumption that scales with prompt and response size. Two archetypes show how the bill actually grows.

Archetype 1 — a non-AI scenario fans out across modules. For non-AI apps the rule is simple (1 module run = 1 credit), but a useful scenario rarely has one module. A trigger that routes through a filter, two app actions, and a logger consumes a credit per app module on every run:

Because the Make Plan price scales on the credit slider, a couple of moderately wide scenarios move an account several steps up (5k → 10k → 20k → 40k). The credit unit is finer and far cheaper than Zapier’s per-task meter — community consensus puts Make at roughly 5–7× cheaper than Zapier at the same volume — but the meter still ticks per module, not per scenario, so picking the right value metric to model against matters before you commit to a tier.

Archetype 2 — AI modules turn a flat meter into a variable one. This is where the August 2025 rename bites. With Make’s AI Provider, credits are consumed dynamically by tokens and model choice, so the same agent costs wildly different amounts depending on which model it calls and how much it reads and writes:

An AI agent that reads a long document and replies on Sonnet 4.5 can consume thousands of credits in a single run — so a workflow that looked like “1 operation” under the old model now burns credits like an AI-agent cost monster. This is the core of the post-rename “bill shock” complaint: the headline metric stayed 1:1 for non-AI apps, but the AI modules people increasingly rely on consume a variable, harder-to-forecast number of credits. At very high volume (~50,000–100,000+ runs/mo) the math tips toward self-hosted n8n, whose per-execution model on a ~$5–6/mo VPS undercuts any credit meter.

Want to estimate your own Make bill? Use the Make pricing calculator to model your monthly cost based on credit volume and AI usage.

Pricing evolution : from Integromat operations to Make credits

Make’s pricing lineage runs from Integromat — a bootstrapped Prague startup priced per operation — through a Celonis acquisition and rebrand, to today’s credit-metered slider. Make publishes no Wayback-legible historical pricing snapshots for the make.com era, so the timeline below is anchored to dated company milestones (acquisition, rebrand, the operations → credits rename) and the live 2026 capture; dollar figures that were never independently legible are marked unknown rather than guessed.

Cadence

Tracked range: 2020-10 – 2026-06. “unknown” price-change cells mark quarters where a brand or structural change is dated and verifiable but the underlying dollar figures never rendered in an archive and are not independently legible — they are not guessed.

Notable changes

• 2020-10 — Celonis acquires Integromat (Make’s predecessor) for a reported $100M+; the platform keeps its per-operation pricing under the Integromat name.
• 2022-02-22 — Integromat rebrands to Make (make.com), relaunched as a semi-autonomous business unit inside Celonis led by Founder/CEO Fabian Q. Veit. (Make blog.)
• 2025-08-27 — Make renamed its billing unit from “operations” to “credits”; for non-AI apps 1 operation continues to equal 1 credit, while AI apps move to dynamic, token-based credit consumption. (Make Help Center — Credits.)
• 2026-06-02 — Current capture: Free / Make Plan (from $9/mo, 5,000-credit slider step up to 8M+) / Company (Enterprise, custom); annual billing saves 15%+.

What’s unique : credit-as-metric and the volume slider

1. The entire paid tier is a single credit-volume slider, not a ladder of named plans. Where Zapier and n8n surface three or four named tiers, Make collapses its paid offering into one “Make Plan” whose price is set by a “How many credits per month?” slider stepping from 5,000 to 8M+. You don’t choose a plan and then a volume — the volume is the plan. That makes the buying decision a single dimension (throughput) and keeps feature gating mostly out of the picture below Enterprise.

2. Throughput is priced, seats and scenarios are free. On the paid Make Plan, active scenarios and users are unlimited; what you buy is credits. This decouples the bill from headcount entirely — the opposite of seat-based SaaS — and means a 2-person team and a 200-person team running the same volume pay the same. It is a deliberate bet that usage-based expansion beats per-seat revenue.

3. A metric rename that quietly changed the math for AI users. The August 2025 “operations → credits” switch kept a strict 1:1 mapping for non-AI apps, so Make could honestly say plan pricing was unchanged. But it simultaneously moved AI modules onto dynamic consumption — tokens, file size, pages, run time — so the same abstract unit now meters two very different kinds of work. Renaming the unit to “credits” gave Make a single currency flexible enough to absorb variable AI cost, at the price of a less predictable bill for AI-heavy users.

4. Dynamic per-model credit conversion bakes the LLM cost curve into the meter. Under Make’s AI Provider, each model has its own token-to-credit rate (GPT-5 mini at 1,500 tokens/credit; Claude Sonnet 4.5 at 301 input / 60 output per credit), so the meter passes the underlying model economics straight through to the customer. This sidesteps the value-metric problem for Make’s margin — credits track real provider cost — but pushes forecasting complexity onto the buyer.

5. The visual-first middle ground between easy-but-pricey and cheap-but-technical. Make’s strategic position is explicit: more visual and approachable than self-hosted n8n, and materially cheaper per unit than Zapier (community consensus puts it ~5–7× below Zapier at equivalent volume). Its credit unit is finer-grained than Zapier’s per-task meter, which is what lets it occupy that price-and-usability middle.

Strengths & weaknesses

Billing UX : the credit slider, billing toggle and overage controls

• Credit-volume slider — “How many credits per month?” sets the Make Plan price directly, stepping from 5,000 credits/mo up to 8M+ (5k, 10k, 20k, 40k, 80k, 150k, 300k, 500k, 750k, 1M … 8M+).
• Monthly / annual billing toggle — “Pay monthly” vs “Pay annually” with a “Save 15% or more” label, switching the displayed Make Plan price between monthly and annual billing.
• Credit usage flexibility with yearly billing — prepay annual credits that only expire after 12 months instead of each month (paid-plan benefit).
• Credits overage protection — uninterrupted scenario execution once the credit limit is reached (Enterprise plan).
• Buy extra credits / auto-purchase — if credits run out before the next cycle, users can upgrade, buy extra credits, or enable extra-credit auto-purchasing.
• Credits toggle on the scenario canvas — each module’s white bubble shows operation count (checkmark icon) and credits consumed (coin icon), toggled next to the scenario name.

Strategic wins : why Make’s metric choices worked

1. Undercutting Zapier on a finer, cheaper unit

Make’s per-operation (now per-credit) meter is granular and priced well below Zapier’s per-task model — roughly 5–7× cheaper at equivalent volume by community consensus. That price gap is Make’s primary wedge against the category leader: it concedes Zapier’s integration breadth and brand while winning the cost-sensitive automation buyer. Choosing a cheaper, finer value metric than the incumbent is a textbook challenger move, and it is worth comparing against the rest of the automation field in the pricing blueprint.

2. Selling throughput, not seats

By making active scenarios and users unlimited on the paid plan and pricing only credits, Make lets automation spread across an organization without per-seat procurement friction, then recovers value as usage grows. That is the land-and-expand logic of usage-based SaaS applied cleanly — the bill follows the work, not the org chart, which is exactly the usage-based packaging pattern that suits a tool meant to touch every department.

3. Collapsing the lineup into one slider

Replacing a ladder of named tiers with a single credit-volume slider turns plan selection into a one-dimensional throughput choice. It reduces decision friction at the point of purchase and makes self-serve checkout almost frictionless — pick a number, see a price. It also future-proofs the model: new capacity is just another slider step, not a new SKU to design and market.

4. Using “credits” as a single currency for mixed AI and non-AI work

Renaming “operations” to “credits” gave Make one abstract unit flexible enough to meter both flat non-AI runs (1:1) and variable, token-driven AI work in the same wallet. That lets Make pass per-model LLM economics straight through the meter without inventing a separate AI add-on the way Zapier did — a structurally simpler answer to the problem of pricing AI-agent workflows whose cost is a moving target.

Areas to improve : gaps and proposed fixes

1. Make AI credit consumption predictable before the run

The biggest post-rename complaint is that AI modules consume a variable, hard-to-forecast number of credits — the same workflow can cost wildly different amounts depending on model and payload. A pre-run estimate (“this run will cost ~X credits at current model rates”), per-model cost previews in the module builder, and budget caps on AI scenarios would defuse the bill-shock pattern that variable AI metering creates. The canvas already shows credits consumed after a run; showing the projected cost before is the missing half.

2. Add spend alerts and circuit-breakers on credit burn

Make offers extra-credit auto-purchasing and Enterprise overage protection, but a self-serve account can quietly accelerate its credit burn — especially via AI modules — without an early warning. Approaching-limit alerts, a configurable hard cap, and an anomaly circuit-breaker on a runaway scenario are the thresholding and alerting controls usage-priced vendors are now expected to ship, and they would convert “buy more credits” from a surprise into a deliberate choice.

3. Publish per-step slider prices and an Enterprise band

Only the entry $9/5k-credit step is shown as a headline; the price at 80k, 300k, or 1M credits appears only as you drag the slider, and Enterprise is fully “Talk to sales.” Surfacing the full per-step price ladder (or indicative bands) and an entry Enterprise range would let buyers model real cost before committing — the transparency the better usage-invoicing playbooks call for, and a low-friction way to shorten the procurement conversation.

Key takeaways

1. A finer, cheaper unit can be a wedge against the incumbent. Make’s per-credit meter is granular and ~5–7× cheaper than Zapier’s per-task model at volume, and that price gap — not feature parity — is its primary way of winning the cost-sensitive automation buyer.
2. Collapsing tiers into one slider reduces purchase friction. By making the paid plan a single credit-volume slider rather than a ladder of named SKUs, Make turns plan selection into a one-dimensional throughput choice and makes self-serve checkout almost frictionless.
3. A metric rename is never just cosmetic. Renaming “operations” to “credits” let Make truthfully say plan pricing was unchanged while simultaneously moving AI work onto dynamic consumption — proof that the unit you bill in shapes the bill even when the headline number holds.
4. Pricing seats out of the model is a growth bet. Unlimited scenarios and users on the paid plan remove procurement friction and let automation spread org-wide, with value recovered on the credit dimension as usage grows.
5. Abstract units trade intuition for flexibility. “Credits” is flexible enough to meter both flat non-AI runs and variable AI work in one wallet, but it is less intuitive than a “task” or a “run,” which is why predictability tooling (estimates, alerts, caps) becomes essential rather than optional.

UBP implications

1. One abstract unit can absorb mixed workloads — at a forecasting cost. A credit that maps 1:1 for non-AI runs but flexes dynamically for AI work lets a vendor price two very different kinds of usage in a single currency, but it shifts forecasting burden onto the buyer and demands strong pre-run visibility.
2. Dynamic, pass-through metering protects margin but moves the value-metric problem downstream. Tying credits to per-model token rates keeps the vendor’s margin aligned with real provider cost; the unpredictability that creates for customers is the recurring tension in pricing AI-era usage.
3. A slider can be the whole plan. Expressing an entire paid tier as a single volume control shows that usage-based pricing can dispense with named tiers entirely — provided the per-step price ladder is transparent enough for buyers to model before they commit.

Sources

• Make pricing page (accessed 2026-06-02)
• Make AI Agents (accessed 2026-06-02)
• Make Help Center — Credits (accessed 2026-06-02)
• Make Help Center — Operations (accessed 2026-06-02)
• Make Enterprise plan (accessed 2026-06-02)
• Compare other automation pricing in the pricing blueprint

Bottom line

Make sells automation throughput by the credit: for non-AI apps the metric is dead simple (1 operation = 1 credit), the paid plan is a single volume slider from $9/mo, and AI usage layers dynamic, token-based credit burn on top — a clean, scale-with-usage model wrapped around an unlimited-seats promise.

Want to compare Make against other automation and usage-based pricing? Browse the pricing blueprint.

Pricing timeline : Major events on a vertical axis

Each milestone below corresponds to a public pricing change, product launch, or material adjustment. Major events use a filled marker; minor adjustments use a faded one.

Current credit-metered plan structure

Jun 2026

Free ($0/mo, up to 1,000 credits/mo), Make Plan (from $9/mo at 5,000 credits/mo on a credit-volume slider), and Company/Enterprise (custom pricing). AI features billed via dynamic credit usage.

Operations renamed to credits

Aug 2025

Make rebranded its core billing unit from 'operations' to 'credits'. For non-AI apps, 1 operation continues to equal 1 credit; AI apps can consume credits dynamically based on tokens, file size, pages, or run time. Make states existing plans and pricing remained unchanged.

Integromat rebrands to Make (make.com)

Feb 2022

Integromat relaunched as Make, a semi-autonomous business unit inside Celonis, led by Founder/CEO Fabian Q. Veit (formerly Celonis COO). The rebrand carried over the per-operation value metric; the visual scenario builder and app library were preserved under the new make.com brand.

Celonis acquires Integromat (Make's predecessor)

Oct 2020

Process-mining company Celonis acquired Integromat — a bootstrapped automation startup from Prague, Czech Republic — for a reported $100M+. Integromat continued operating under its own name while Celonis folded it into its product portfolio. No public pricing change accompanied the deal.