Make

Make at a glance

Make is a visual automation platform for connecting applications, transforming data, calling APIs, and orchestrating multi-step business processes. Automations are called scenarios and are built from modules connected on a canvas. Routers, filters, iterators, aggregators, variables, webhooks, error handlers, and data stores let non-developers create logic that would otherwise require custom integration code.

Make is especially strong when a workflow has branches, data transformations, multiple records, or several connected systems. Its flexibility also makes cost and reliability less obvious than a simple “one trigger, one action” tool. Every module run, bundle, retry, poll, and AI step can affect consumption and outcomes.

Current Make pricing

As of September 2026, Make’s public pricing for 10,000 credits per month is $12 monthly for Core, $21 for Pro, and $38 for Teams. Annual billing is advertised as saving at least 15%, and larger credit tiers change the effective unit price. Enterprise uses custom sales pricing.

• Free: 1,000 credits per month, no time limit, visual builder, more than 3,000 apps, routers and filters, and a minimum 15-minute schedule interval.
• Core: $12 per month at 10,000 credits; unlimited active scenarios, scheduling down to one minute, higher transfer allowances, and Make API access.
• Pro: $21 per month at 10,000 credits; priority execution, custom variables, and full-text execution-log search.
• Teams: $38 per month at 10,000 credits; team roles and shared scenario templates.
• Enterprise: custom pricing; custom functions, enterprise apps, 24/7 enterprise support, value engineering, overage protection, advanced security, SSO, audit logs, and domain controls.

Quoted prices are starting points and exclude taxes, extra credits, third-party AI tokens, and external application fees. Unused credits expire at the end of the billing term. Additional credits currently carry a 25% premium over included credits, making the correct base tier cheaper than repeated overages.

Credits versus operations

Make changed its purchased billing unit from operations to credits. An operation still describes a module run that processes or checks data. Most ordinary operations consume one credit, preserving the historical one-to-one relationship. Make’s built-in AI provider can use additional credits based on token consumption or the feature’s usage model.

Third-party AI modules using a customer’s own OpenAI, Anthropic, or other provider connection generally consume Make credits for the operation while the provider separately charges for tokens. Budget for both invoices.

A workflow diagram is not a cost estimate. One visible module may run once for every bundle. If a trigger returns ten records and three downstream modules handle each record, the run can consume one trigger operation plus thirty downstream operations. Retries, polling triggers, iterators, routers, and error paths add more.

How to estimate credit usage

1. Estimate trigger checks or webhook events per month.
2. Estimate average bundles returned per trigger.
3. Count modules that run for each bundle and each route.
4. Add expected retries, errors, replay, polling with no new data, and manual testing.
5. Add AI token-based credits and the AI provider’s own token bill.
6. Apply peak volume, not only the monthly average, to queues and rate limits.
7. Set usage alerts and review actual credits per scenario after launch.

Polling every five minutes produces 8,640 trigger checks in a 30-day month before processing any records. An instant webhook can be cheaper and faster when the source supports it. Aggregating ten notifications into one digest may reduce downstream module runs substantially.

Scenarios, modules, bundles, and routes

A scenario defines the workflow. Modules read, create, update, search, transform, or send data. A bundle is a structured item passed between modules. Routers split bundles into branches; filters decide which route continues; iterators split arrays into individual bundles; aggregators combine many bundles into one.

Understanding bundle multiplication is essential. A scenario that looks short can fan out into hundreds of module runs. Inspect the operation bubbles and execution history using realistic data rather than assuming one canvas node equals one monthly credit.

Name scenarios, modules, routes, variables, and webhooks for the business purpose. Add notes explaining ownership, data contracts, dependencies, failure behavior, and the authoritative system. Visual clarity becomes operational documentation during incidents.

Scheduling and webhooks

Free scenarios can run at intervals no shorter than 15 minutes. Core and higher tiers can schedule down to one minute. Supported instant triggers and webhooks can run as data arrives. Other schedules include daily, weekdays, weekly, monthly, specified dates, and on demand.

Faster polling increases credit use even when no business record changes. Use the slowest interval that meets the service objective. For instant webhooks, configure rate limits and understand queue capacity. When a scenario exceeds its maximum starts per minute, requests may queue; a webhook response workflow can return HTTP 429, requiring the caller to retry safely.

Webhooks should authenticate callers where possible, validate payloads, reject oversized or malformed data, and use idempotency controls so retries do not create duplicate invoices, contacts, or orders.

Error handling and recovery

A production scenario needs explicit failure behavior. Make supports error-handler routes, rollback or commit patterns for applicable modules, incomplete executions, retries, and history inspection. The right design depends on whether a step is safe to repeat.

Classify errors as temporary, permanent, data-quality, authentication, rate-limit, permission, or business-rule failures. Retry temporary network errors with limits and delay. Send malformed records to a review queue. Stop and alert on credential or permission failures. Never retry a non-idempotent payment or fulfillment step blindly.

Create alerts for failed or incomplete runs, unusual credit consumption, queue growth, repeated 429 responses, expired connections, and declining record counts. A green scenario schedule does not prove that downstream data is correct.

Execution history and observability

Scenario history records run time, status, duration, operations, credits, transferred data, and execution details. Pro and higher tiers add full-text log search, useful for locating a customer ID, email address, or order in historical module outputs.

Logs can contain personal, confidential, or credential-like data. Minimize fields, mask secrets, restrict access, and align log retention with policy. Do not paste production payloads into public support forums or screenshots without redaction.

Track business outcomes alongside platform metrics: orders created, leads routed, duplicates prevented, failures resolved, and processing delay. Credits per successful business transaction is more useful than credits alone.

Make AI, Maia, and AI agents

Make connects hundreds of AI applications and also offers built-in AI tools, conversational building through Maia, AI agents, and an MCP server. AI can classify messages, extract structured data, summarize documents, draft responses, route requests, and choose actions in a workflow.

AI introduces variable cost and nondeterministic output. Constrain inputs, request structured schemas, validate outputs, cap token use, set confidence thresholds, and require human approval before sensitive actions. Do not allow an agent to issue refunds, change bank details, publish legal statements, or delete records without narrow permissions and explicit controls.

Prompt injection can arrive through email, documents, websites, CRM notes, or uploaded files. Treat external content as untrusted data, not instructions. Separate system rules from user content, restrict available tools, verify destinations, and log consequential actions.

Connections, credentials, and access

Connections authorize Make to act in other systems. Use dedicated service accounts for shared production automations rather than an employee’s personal account. Grant the minimum scopes, rotate credentials, and document who owns renewal and incident response.

Core adds Make API access. Teams adds collaboration roles. Enterprise provides stronger controls such as SSO, audit logs, domain claim, custom roles, and administrative visibility. Private spaces help individual builders, but production scenarios should live where ownership and access survive staff changes.

Review connections quarterly and after role changes. Removing a Make user does not necessarily revoke an OAuth token in the connected service, so offboarding must cover both sides.

Data protection and compliance

Automation moves data across vendors and jurisdictions. Map each scenario’s source, destination, fields, purpose, retention, legal basis, and failure queue. Avoid transferring full records when a small subset is sufficient.

Evaluate Make’s current security documentation, processing terms, subprocessor list, hosting region options, encryption, access controls, audit capabilities, and certifications against the workflow’s requirements. Enterprise security features do not make an unsafe scenario compliant automatically.

Secrets belong in managed connections or an approved vault, not plain-text variables, notes, URLs, spreadsheets, or error messages. Treat webhook URLs as credentials when possession can trigger a workflow.

Testing and deployment checklist

1. Write the business outcome, owner, source of truth, service objective, and manual fallback.
2. Use a sandbox or test records and prevent test messages, orders, or invoices from reaching customers.
3. Test empty values, duplicates, large arrays, unexpected types, expired tokens, rate limits, and partial outages.
4. Add idempotency keys or duplicate checks before irreversible actions.
5. Configure error routes, alerts, incomplete-execution handling, and a dead-letter review process.
6. Estimate credits with realistic bundles and peak volume, then set thresholds.
7. Document deployment, rollback, connection ownership, data flow, and downstream dependencies.
8. Run a controlled pilot and reconcile source and destination totals before full activation.

Maintenance and offboarding

Every production scenario needs an owner, backup owner, review date, change log, and measurable outcome. Retire unused workflows rather than leaving them active. Re-test after connected apps change APIs, fields, permissions, or authentication.

When a builder leaves, transfer scenarios, templates, data stores, webhooks, variables, service accounts, API keys, billing responsibility, and documentation. Revoke sessions and organization access, rotate personally controlled credentials, and verify that production continues under an organizational account.

For a decommissioned scenario, disable triggers, drain queues, export required records, revoke connections, remove external webhooks, update downstream systems, and preserve audit evidence according to policy.

Best Make alternatives

• Zapier: simpler for common linear automations and a large integration catalog, though complex multi-step usage can become expensive.
• n8n: attractive for technical teams wanting code flexibility, execution-based pricing, and a self-hosting option.
• Microsoft Power Automate: strong inside Microsoft 365, Dynamics, Azure, and Power Platform environments.
• Workato: enterprise integration and governance for organizations prepared for sales-led pricing.
• Pipedream: developer-friendly workflows with code steps, APIs, and event-driven execution.
• Custom integration: appropriate when performance, domain logic, testing, version control, or platform independence outweigh low-code speed.

Who should choose Make?

Make is an excellent fit for operations teams, agencies, marketers, RevOps, support teams, and technically curious builders who need more visual control than simple trigger-action automation. Core is the practical starting point for production workflows; Pro is valuable when priority execution, variables, and searchable logs matter; Teams adds shared governance for multiple builders.

Choose a simpler platform for a handful of standard automations. Choose n8n, Pipedream, or custom code when engineering control and deployment flexibility dominate. Choose an enterprise integration platform when centralized governance, support, and complex system programs outweigh self-service speed.

Verdict

Make is one of the most capable visual automation platforms for its price. Its routers, transformations, webhooks, data tools, broad integration catalog, and transparent execution detail support sophisticated workflows without hiding all of the underlying logic. The tradeoff is operational responsibility: credit forecasting, bundle multiplication, credentials, errors, retries, and data governance require deliberate engineering habits.

Plans, prices, and credit rules checked in September 2026. Make changes credit tiers, AI consumption rules, allowances, and feature packaging; verify the official pricing page and workspace usage dashboard before purchase.