Make (formerly Integromat)

Overview

Make, previously known as Integromat, is an integration platform as a service (iPaaS) that enables users to design, build, and automate workflows across a range of applications and services. The platform is structured around a visual builder, allowing users to create complex sequences of operations without writing code. This approach positions Make as a tool for both technical and non-technical users seeking to automate repetitive tasks, synchronize data across platforms, and integrate disparate cloud applications.

The core functionality of Make revolves around 'scenarios,' which are automated workflows composed of modules that represent specific actions or triggers within connected applications. Users can define triggers that initiate a scenario (e.g., a new email, a database entry) and then chain together subsequent actions (e.g., create a task, send a notification, update a record). This visual paradigm is intended to simplify the process of connecting APIs and automating business processes, from simple data transfers to multi-step conditional logic. Make supports a large library of pre-built connectors for popular software-as-a-service (SaaS) applications, database systems, and communication tools. For applications without a native connector, the platform provides tools for making custom HTTP requests, allowing integration with any API that exposes a public interface.

Make is particularly suited for scenarios requiring flexible data manipulation, conditional routing, and error handling within automated workflows. Its appeal extends to small businesses looking to streamline operations, marketing teams automating lead nurturing, IT departments integrating internal systems, and developers creating custom integrations without extensive backend coding. The platform's emphasis on visual design and detailed control over data flow distinguishes it within the iPaaS market, as noted in discussions of low-code and no-code development platforms by industry analysts like ThoughtWorks. The ability to inspect each step of a scenario and re-run failed operations contributes to its utility in managing complex automation tasks.

Owned by Celonis, a process mining company, Make benefits from a strategic alignment towards optimizing business operations through automation and process intelligence. This ownership context suggests a focus on robust, scalable solutions for enterprise-level process automation, while retaining accessibility for individual and small team use cases. The platform's commitment to security and compliance, including certifications like SOC 2 Type II and GDPR, further supports its suitability for handling sensitive data and critical business processes.

Key features

• Visual Workflow Builder: A drag-and-drop interface for designing and implementing automation scenarios, enabling users to connect applications and define data flows without coding.
• Extensive App Library: Access to hundreds of pre-built connectors for popular business applications, databases, and services, simplifying the integration process.
• Custom HTTP Requests: Functionality to connect to any API using standard HTTP methods, allowing for integrations with applications not natively supported by a connector.
• Data Transformation Tools: Capabilities to manipulate, filter, aggregate, and format data at various stages within a workflow, ensuring compatibility between different systems.
• Conditional Logic and Routing: Support for advanced logic, including filters, routers, and error handlers, to create dynamic workflows that adapt to different data inputs and outcomes.
• Scheduling and Real-time Triggers: Options to run scenarios on a predefined schedule or in real-time based on events occurring in connected applications.
• Team Collaboration: Features for sharing scenarios, managing permissions, and collaborating on automation projects within a team environment.
• Monitoring and Logging: Tools for tracking scenario execution, viewing operation history, and debugging issues to ensure reliable automation.

Pricing

Make offers a free tier and various paid plans, primarily differentiating by the number of operations, data transfer limits, and advanced features. The pricing structure scales with usage and team size, with discounts available for annual billing. As of 2026-05-07, the following tiers are available, with detailed information on the Make pricing page.

Common integrations

Make provides a broad ecosystem of integrations, allowing connectivity with hundreds of popular applications across various categories. The platform's modular design facilitates linking these services to automate complex workflows. Examples include:

• CRM Systems: Salesforce, HubSpot, Zoho CRM. For detailed integration guides, refer to the Salesforce Make integration documentation.
• Marketing Automation: Mailchimp, ActiveCampaign, SendGrid.
• Project Management: Trello, Asana, Jira.
• Communication: Slack, Microsoft Teams, Gmail.
• Cloud Storage: Google Drive, Dropbox, OneDrive.
• Databases: MySQL, PostgreSQL, MongoDB.
• E-commerce: Shopify, WooCommerce, Stripe. For integrating payment gateways, users can consult the Stripe API documentation for specific endpoints.
• Forms and Surveys: Google Forms, Typeform, Jotform.
• Analytics: Google Analytics, Mixpanel.

Alternatives

The iPaaS market includes several platforms offering similar workflow automation and integration capabilities:

• Zapier: A widely used automation platform known for its ease of use and extensive app integrations, often preferred for simpler, event-driven workflows.
• Workato: An enterprise-grade iPaaS offering advanced features for complex business process automation, API management, and robotic process automation (RPA).
• Microsoft Power Automate: Part of the Microsoft Power Platform, providing workflow automation and RPA capabilities, deeply integrated with Microsoft 365 and Azure services.

Getting started

Getting started with Make typically involves signing up for an account, creating a new scenario, and connecting your desired applications. While Make is primarily a no-code platform, understanding basic API concepts can be beneficial for custom integrations. The following example illustrates how to create a basic scenario that retrieves data from a public API using a custom HTTP request and then processes it. This example assumes you want to fetch data from a hypothetical public API and then output a specific field. For a visual guide, the Make help center provides step-by-step tutorials.

// This is a conceptual representation of a Make scenario's logic.
// In Make's visual builder, you would drag and drop modules.

// Step 1: Trigger (e.g., Schedule to run every 15 minutes)
{
  "trigger": {
    "type": "Schedule",
    "interval": "15 minutes"
  }
},

// Step 2: HTTP Request - Get data from a public API
{
  "module": "HTTP",
  "action": "Make a request",
  "configuration": {
    "method": "GET",
    "url": "https://api.example.com/data",
    "headers": {
      "Content-Type": "application/json",
      "Authorization": "Bearer YOUR_API_KEY" // Replace with actual API key if required
    },
    "responseType": "JSON"
  },
  "output": "api_response" // Variable to store the response
},

// Step 3: Parse JSON (if the API response is a string that needs parsing)
{
  "module": "JSON",
  "action": "Parse JSON",
  "configuration": {
    "jsonString": "{{api_response.data}}" // Assuming 'api_response.data' holds the JSON string
  },
  "output": "parsed_data"
},

// Step 4: Set variable / Process data (e.g., extract a specific field)
{
  "module": "Tools",
  "action": "Set multiple variables",
  "configuration": [
    {
      "name": "extracted_value",
      "value": "{{parsed_data.items[].name}}" // Example: extract 'name' from an array of 'items'
    }
  ]
},

// Step 5: Output/Action (e.g., send extracted_value to another service)
{
  "module": "Logger",
  "action": "Log a message",
  "configuration": {
    "message": "Extracted Value: {{extracted_value}}"
  }
}

In the Make visual editor, each step above corresponds to a module that you would configure. The {{...}} syntax represents variables and data elements passed between modules. For instance, after the HTTP request, the response data becomes available for subsequent modules to process. The platform abstracts much of the underlying API interaction, allowing users to focus on the logic of their workflow.