⚙️

Make

Automate workflows and integrations for scalable operations

Free | Freemium | Paid | Enterprise ⭐⭐⭐⭐☆ 4.0/5 ⚙️ Automation & Workflow 🕒 Updated
Visit Make ↗ Official website
Quick Verdict

Make is a visual automation platform for building multi-step workflows (“scenarios”) that connect apps, APIs, and data via drag-and-drop modules, routers, iterators, and an HTTP client. It suits operations, product, and agency teams that need granular data mapping and complex branching without code. Pricing is approachable, with a usable Free plan and low-cost paid tiers for higher operations, faster schedules, and collaboration.

Best For
Ops, product, and agencies needing complex workflows
Free Tier
Yes, 1,000 operations/month, webhooks, basic scheduling
Starting Price
Core at $10.59/month USD, billed annually
Standout
Visual canvas with routers, iterators, aggregators
Integrations
1,000+ native apps plus universal HTTP module
Triggers
Webhooks, schedules, and instant app event triggers

Make is an automation and workflow platform that connects apps, APIs and data with a visual, modular scenario builder. Its primary capability is constructing multi-step workflows (scenarios) that run on schedules, webhooks, or event triggers and manipulate data between over 1,000 app integrations. Make’s key differentiator is a visual canvas with granular data mapping, built-in iterators/aggregators and an HTTP module for custom API calls, serving product teams, ops, and agencies. Pricing is accessible: a usable free tier for light automations and tiered paid plans for scale.

About Make

Make (formerly Integromat) launched as an API-centric automation platform focused on bridging apps and data with a visual, modular canvas. Founded in 2012 and rebranded to Make, the company positioned itself as an alternative to no-code automation tools by offering deeper control over data transformation, error handling, and scheduling. The core value proposition is enabling non‑engineers and developers to build multi-step integrations (called scenarios) with conditional logic, iterators, and native HTTP calls, reducing the need to build bespoke middleware or cron-based scripts.

Make’s feature set focuses on practical integration capabilities. The scenario builder is a drag‑and‑drop canvas where modules execute sequentially or in parallel; modules include HTTP request/response, JSON and XML parsing, iterators/aggregators for handling arrays, and error handlers with automatic retry logic. Make connects to 1,000+ apps via prebuilt modules and supports custom API work through its HTTP and JSON modules; users can map individual fields and apply inline transforms using functions for date, text, math, and conditional logic. Scheduling options include cron-like timing and webhook triggers, and Make provides built-in logging, operation history, and execution details for debugging at the module level.

Pricing is tiered with a free plan and paid subscriptions. The Free plan provides a limited monthly operation quota (typically 1,000 operations/month) and up to 100MB transfer with one active scenario; Core paid plans start from a low monthly fee for higher operation counts and shorter minimum interval scheduling. The standard/paid plans (as listed on Make’s pricing page) increase operations, data transfer limits, number of active users, and scenario complexity—Team and Business plans unlock shared workspaces, role-based access, SSO, and higher operation volumes. Enterprise options are available with custom SLAs, higher throughput, and dedicated support for mission‑critical integrations.

Make is used across many real workflows: marketing ops teams build lead enrichment and routing scenarios to reduce manual CSV handling, product managers synchronize user data across analytics and CRM, and e-commerce teams automate order-to-fulfillment notifications. Example roles: a Marketing Operations Manager using Make to route and enrich 3,000 leads/month between a form, enrichment API, and Salesforce; a Product Manager using Make to sync user events from a webhook to analytics and a data warehouse for daily reporting. For teams requiring deep developer-style API control, Make is often compared to Zapier; Make favors complex data transformations and custom HTTP calls while Zapier targets simpler one-to-one automations.

What makes Make different

Three capabilities that set Make apart from its nearest competitors.

  • A canvas-first scenario builder with per-field data mapping, routers, iterators, and aggregators lets you branch and transform arrays natively—no custom code or scripts.
  • An execution inspector logs every module’s inputs, outputs, and timings, enabling step-level debugging and transparent troubleshooting beyond form-based, black-box task runners.
  • A first-class HTTP module plus Data Stores handle arbitrary REST calls and lightweight state, covering long-tail APIs without native apps or external databases.

Is Make right for you?

✅ Best for
  • RevOps and sales ops teams who need bi-directional CRM–billing syncs
  • Product managers and developers who need fast API orchestration
  • Agencies serving many clients who need repeatable, maintainable automations
  • Marketing and data teams who need array/CSV transforms and enrichment
❌ Skip it if
  • Skip if you require self-hosted/on‑prem automation or private VPC deployment
  • Skip if ultra‑high‑volume event streams exceed monthly operation quotas

Make for your role

Which tier and workflow actually fits depends on how you work. Here's the specific recommendation by role.

Solopreneur

Buy for flexible, multi-step automations and granular data mapping that outgrow basic single-step tools without needing code.

Top use: Sync Stripe charges to a Notion ledger, send a personalized receipt via Gmail, and log a CSV backup to Google Drive.
Best tier: Free
Agency / SMB

Buy to standardize client operations with reusable scenarios, robust HTTP calls, and fine-grained filters/routers across many apps.

Top use: Centralize lead routing from web forms to HubSpot/Pipedrive, enrich via Clearbit API, and alert client channels in Slack with owner assignment.
Best tier: Teams
Enterprise

Conditional buy—excellent for complex data flows and API work, but lack of published SOC 2 and data residency specifics may block security review.

Top use: Orchestrate multi-system incident workflows: PagerDuty trigger routes to Jira, updates ServiceNow, posts status to Slack and sends customer notifications.
Best tier: Enterprise

✅ Pros

  • Granular data mapping and inline functions remove the need for separate ETL tools
  • Supports custom API calls via HTTP module, enabling integrations not in the app library
  • Detailed execution logs and per-module error handling simplify debugging complex flows

❌ Cons

  • Pricing scales by operations, which can be costly for high-volume workflows
  • Learning curve for complex scenario design and advanced data transformations

Make Pricing Plans

Current tiers and what you get at each price point. Verified against the vendor's pricing page.

Plan Price What you get Best for
Free Free 1,000 operations/month; 15‑minute scheduling; 2 active scenarios; single user; basic support Trialing simple webhooks and light automations
Core $10.59/month (annual) 10,000 operations/month; 1‑minute scheduling; single user; unlimited scenarios; webhooks; standard support Solo builders needing dependable daily automations
Pro $18.82/month (annual) 40,000 operations/month; 1‑minute scheduling; advanced tools; single user; higher limits Power users running complex, higher‑volume scenarios
Teams $34.12/month (annual) 150,000 operations/month; 1‑minute scheduling; multiple users; roles; shared connections; collaboration Small teams collaborating on shared automations
Enterprise Custom Custom operations; SSO, SCIM, audit logs; SLA; dedicated support; security reviews Enterprises needing governance, scale, and SLAs
💰 ROI snapshot

Scenario: Automate 300 ecommerce order post-processing tasks/month (create CRM deals, send receipts, notify Slack)
Make: $0/mo (Free tier) · Manual equivalent: $300/mo (10 hours at $30/hr US VA) · You save: $300/mo

Caveat: If volume or steps increase, you may exceed free-tier operations and need a paid plan; external API rate limits still apply.

Make Technical Specs

The numbers that matter — context limits, quotas, and what the tool actually supports.

App integrations 1,000+ prebuilt app modules; custom connectors via Developer Platform and universal HTTP module
Triggers & scheduling Instant webhooks, app event triggers, and time-based schedules as frequent as every 1 minute
HTTP/API module Full HTTP client for REST/GraphQL/SOAP with OAuth2, Basic, API key; handles JSON/XML/multipart
API availability Public REST API (v2) to manage scenarios, webhooks and connections; OAuth2; API docs published
Platforms Web-based visual scenario builder (modern browsers); no desktop client; webhook endpoints for inbound events
File format support JSON, XML, CSV, multipart/form-data; built-in parsers, iterators/aggregators and data mapping functions
Collaboration Workspaces with multi-user collaboration, roles/permissions, and scenario sharing across teams

Best Use Cases

  • Marketing Operations Manager using it to route and enrich 3,000 leads/month
  • Ecommerce Operations Lead using it to sync 5,000 orders/day to ERP systems
  • Product Manager using it to push webhook events to analytics for daily reports

Integrations

Salesforce Google Sheets Stripe

How to Use Make

  1. 1
    Create a Make workspace
    Sign in at make.com and click 'Create a new scenario' in the dashboard; choose a workspace and give the scenario a name. Success looks like an empty canvas with a Start module ready to be added.
  2. 2
    Add a trigger module
    Click the big plus on the canvas, search for an app (e.g., 'Webhook' or 'Google Sheets'), and select a trigger module. Configure the trigger (webhook URL or sheet ID) and press 'Run once' to confirm successful incoming data.
  3. 3
    Map data and add actions
    Add subsequent modules (e.g., HTTP, Salesforce, Filter) and use the map wheel to drag fields between modules; apply inline functions as needed. A successful mapping shows sample data flowing through modules in the preview.
  4. 4
    Schedule and activate the scenario
    Set the scenario schedule using the clock icon (choose interval or webhook), toggle the scenario to 'ON', and monitor runs in the Execution history tab. Success is indicated by executed operations and no red error badges.

Sample output from Make

What you actually get — a representative prompt and response.

Prompt
On new Shopify paid order, create a HubSpot deal and DM the account owner.
Output
Run completed: Shopify order #10427 detected; HubSpot deal “Order #10427 – $249.00” created in Online Sales, stage Closed Won; Slack DM sent to @amanda with order link and line items; 3 modules executed; duration 4.2s; errors 0.

Ready-to-Use Prompts for Make

Copy these into Make as-is. Each targets a different high-value workflow.

Route Incoming Leads to CRM
Route webhook leads and tag by source
Role: You are an automation engineer building a Make scenario to route incoming lead webhooks into a CRM. Constraints: use a Webhook trigger, at most 4 modules, no iterators/aggregators, preserve original payload as metadata. Output format: provide a numbered list of modules (module name, exact settings, field mappings) and a single example mapping block. Example mapping: {"email": "Contact Email", "first_name": "First Name", "lead_source": "Lifecycle Source"}. Also include one conditional filter example for facebook vs. organic leads and the exact filter expression to use in Make.
Expected output: A numbered list of 3–4 modules with exact settings and a JSON mapping example.
Pro tip: Include the original webhook payload as a JSON metadata field in the CRM contact to aid debugging and future enrichment.
Daily Orders CSV to SFTP
Export daily orders as CSV to SFTP
Role: You are a Make scenario designer creating a scheduled daily export of new ecommerce orders to an SFTP server. Constraints: run once daily, include only orders created in the last 24 hours, output must be a UTF-8 CSV with headers, use at most 5 modules. Output format: produce a step-by-step module sequence (trigger schedule, query module or HTTP, CSV builder settings, SFTP upload settings) and include the exact CSV header row and an example CSV line. Example header: order_id,created_at,customer_email,total,currency. Provide the date filter expression to select last-24-hour orders.
Expected output: A step-by-step module sequence with CSV headers and a sample CSV row.
Pro tip: Use ISO 8601 timestamps and the platform's built-in date functions to avoid timezone drift when selecting last-24-hour orders.
Enrich Leads with Clearbit API
Enrich leads then deduplicate before CRM
Role: You are an integration specialist building a Make scenario that enriches incoming leads via the Clearbit Enrichment HTTP API, then deduplicates and upserts into CRM. Constraints: respect Clearbit rate limit (max_concurrent_requests = 5), include exponential backoff retries (3 attempts), and ensure a single dedupe key (email). Output format: return a JSON array of modules with fields: {"module":"name","config":{...}}, include HTTP module settings (endpoint, headers, query), backoff policy, and a sample HTTP request/response pair. Also include the dedupe logic pseudocode (input array → unique by email → upsert mapping).
Expected output: A JSON array of modules including HTTP settings, retry/backoff policy, and dedupe pseudocode.
Pro tip: Throttle HTTP module calls using a queue or iterator with a concurrency limiter to enforce rate limits reliably across scenario runs.
Batch Orders Sync to ERP
Batch sync orders to ERP with retries
Role: You are a product operations lead designing a Make scenario to sync ecommerce orders to an ERP in 100-order batches. Constraints: batch size = 100, implement idempotency via order_id hash, include per-batch retry policy (5 retries, linear 30s interval), and mark failed batches in a Google Sheet. Output format: provide an ordered list of modules with aggregator settings (size=100), idempotency key formula, HTTP/ERP payload template, and exact Make expressions for retry and failure logging. Include a one-line example of the ERP batch JSON payload for two orders.
Expected output: An ordered module list with aggregator config, idempotency key formula, retry policy, and sample ERP batch JSON.
Pro tip: Calculate the idempotency key as sha256(shop_id + order_id + updated_at) to safely handle order updates without duplicate creates.
Aggregate Webhooks for Analytics
Aggregate event webhooks and push to analytics
Role: You are a Senior Integration Architect building a Make scenario that aggregates high-frequency webhook events into periodic analytics payloads. Requirements and constraints: accept webhooks continuously, buffer and aggregate by event_type over a 5-minute sliding window, produce a compressed JSON summary (counts, uniques by user_id), retry failed analytics HTTP calls with exponential backoff up to 6 attempts, and include monitoring alerts on >10% dropoff. Output format: deliver a scenario blueprint listing modules, aggregator configuration (window type=sliding, length=5m), iterator usage, HTTP module body template, pseudocode for aggregation, and two small examples: raw webhook events (3 items) and resulting aggregated JSON. Also include the exact Make expressions for windowing and timestamp alignment.
Expected output: A detailed scenario blueprint with aggregator config, HTTP body template, aggregation pseudocode, and two example payloads.
Pro tip: Use a deduplication token per webhook (incoming_id + webhook_source) and store recent tokens in a short TTL cache to prevent reprocessing retries as unique events.
Robust Inventory Sync with Upserts
Idempotent inventory sync with conflict resolution
Role: You are an integration architect creating a Make workflow to sync inventory updates from webhooks into an external database/API with transactional upsert semantics. Constraints: ensure idempotency, support conflict resolution (last-write-wins or delta merge), include conditional branching for negative stock/errors, and provide SQL-like upsert logic. Output format: give a full module sequence, conditional flow logic, example SQL upsert statement or HTTP PATCH body, error handling and rollback approach, plus a few-shot example: (1) webhook event, (2) current DB row, (3) resulting upserted row. Also include the idempotency key formula and how to store it.
Expected output: A full module sequence with conditional flow, SQL/HTTP upsert example, error handling, and a three-item few-shot example.
Pro tip: Store an immutable change_id from the source in your DB and reject older change_ids to make conflict resolution simple and reliable across retries.

Make vs Alternatives

Bottom line

Choose Make over Zapier if you need granular field-level data mapping, routers/iterators, and native HTTP calls for complex, branch-heavy workflows rather than linear zaps priced per task.

Head-to-head comparisons between Make and top alternatives:

Compare
Make vs VTube Studio
Read comparison →

Common Issues & Workarounds

Real pain points users report — and how to work around each.

⚠ Complaint
Operations consumption spikes when iterating large arrays, unexpectedly exhausting the monthly quota.
✓ Workaround
Batch items with Aggregator, add Filters to drop irrelevant records, and use Limit/Sleep/Error handler to control throughput.
⚠ Complaint
OAuth connections can expire, causing silent run failures until someone checks execution logs.
✓ Workaround
Enable per-scenario error notifications, add automatic retries, and schedule a lightweight heartbeat run that alerts Slack on auth errors.
⚠ Complaint
Nested JSON mapping produces cryptic errors that are hard to debug mid-scenario.
✓ Workaround
Insert JSON Parse and Tools > Set variable checkpoints, and return interim payloads via Webhook response or Mail modules to validate schemas early.

Frequently Asked Questions

How much does Make cost?+
Make offers a Free plan plus paid tiers; costs scale by monthly operations and features. The Free plan typically includes ~1,000 operations/month and limited transfer. Paid plans start at low monthly fees (e.g., Core/Creator levels) and increase for Team, Business, and Enterprise with higher operation quotas, shorter intervals, shared workspaces, SSO, and dedicated support.
Is there a free version of Make?+
Yes — Make provides a Free tier with limited monthly operations and data transfer. The free account usually includes around 1,000 operations/month, limited active scenarios, and a minimum scheduling interval (about 15 minutes). It’s intended for testing and lightweight automations before upgrading to paid plans for higher throughput and team features.
How does Make compare to Zapier?+
Make focuses on deeper data transformation and custom API control versus Zapier’s one-to-one ease. Make provides field-level mapping, iterators/aggregators, HTTP modules for REST calls, and per-module logs; Zapier prioritizes simpler triggers/actions and a broader audience. Choose Make for complex, multi-step integrations and Zapier for quicker single-step automations.
What is Make best used for?+
Make is best for building multi-step automations that require field-level transforms, batch processing, or custom API calls. Common uses include syncing CRM and billing data, automated lead enrichment, order processing for e-commerce, and ETL-style transfers to analytics or warehouses where array handling and HTTP requests are necessary.
How do I get started with Make?+
Start by creating a new scenario from the Make dashboard and adding a trigger (Webhook or app module). Configure your trigger, add action modules (HTTP, Google Sheets, Salesforce), map fields with the map wheel, run a test with 'Run once', then schedule and activate your scenario for regular execution.

More Automation & Workflow Tools

Browse all Automation & Workflow tools →
⚙️
Microsoft Power Automate
Automate workflows and tasks across apps and systems
Updated Apr 21, 2026
⚙️
UiPath
Automate enterprise workflows with scalable automation and orchestration
Updated Apr 21, 2026
⚙️
Automation Anywhere
Enterprise automation platform for scalable workflow automation
Updated Apr 22, 2026