Book a Discovery Call
Make.com automation to improve workflows

5 Features In Make.com To Turbocharge Automation

No-code automation tools are changing the way we work. They make it easy for anyone to create automated workflows without writing code. One of the best tools out there is Make.com (formerly known as Integromat). More and more businesses and individuals are using it to save time and boost productivity.

Make.com is a powerful tool, but many people don’t know about some of its best features. These exceptional features can significantly enhance your workflows, taking them to the next level.

In this blog, we’ll uncover five features in Make.com that can turbocharge your automation. These features include:

  • The HTTP Module
  • Iterators and Array Aggregators
  • Error Handling with Routers
  • Custom Functions
  • Webhooks

By the end of this blog, you’ll know how to use these features to take your automation to the next level.

#1: The HTTP Module

Explanation of the HTTP Module

The HTTP module in Make.com is a powerful tool that allows you to send and receive data over the web. It lets you make HTTP requests to any API, which means you can connect Make.com to almost any web service. You can use it to get, post, put, or delete data, making it extremely versatile.

Many users might overlook the HTTP module because it requires a bit more technical knowledge than the standard modules. Since it involves understanding how APIs work and what HTTP requests are, beginners might find it intimidating. However, once you get the hang of it, it opens up a world of possibilities.

Benefits and Use Cases of the HTTP Module

The HTTP module can connect Make.com to any API, even those that are not directly supported. Here are some examples of how you can use it:

  • Integrating with Lesser-Known APIs: If you want to integrate with a new or niche service that doesn’t have a dedicated module in Make.com, the HTTP module is your go-to solution.
  • Custom Applications: Suppose you have a custom-built application with its own API. You can use the HTTP module to send data from Make.com to your application or retrieve data from it.
  • Enhanced Flexibility: With the HTTP module, you can perform advanced operations like handling authentication, managing headers, and parsing responses. This makes it ideal for complex integrations.

Step-by-Step Guide – Using HTTP Module

Here’s a simple tutorial on setting up an HTTP module in Make.com:

  1. Create a New Scenario: Log in to your Make.com account and create a new scenario.
  2. Add the HTTP Module: Click on the “+” button to add a module. Search for “HTTP” and select the HTTP module from the list.
  3. Configure the Request: Choose the type of request you want to make (GET, POST, PUT, DELETE). For this example, we’ll use a GET request.
    • URL: Enter the URL of the API endpoint you want to access. For example, https://api.example.com/data.
    • Headers: If the API requires headers, click on “Add headers” and input the necessary key-value pairs.
    • Query Parameters: If the API needs query parameters, click on “Add parameters” and input them.
  4. Test the Request: Click on the “Run once” button to test your HTTP request. Make.com will show you the response from the API.
  5. Parse the Response: If the response is in JSON format, you can use Make.com’s built-in JSON parsing to extract the data you need. Click on the response and choose “Parse JSON”.
  6. Use the Data: Now you can use the data from the API response in your scenario. For example, you can send it to another module, store it in a database, or trigger another action.

By following these steps, you can leverage the HTTP module to connect to virtually any web service, expanding the capabilities of your Make.com automation.

#2: Iterator and Array Aggregator

Explanation of Iterators and Aggregators

Iterators and array aggregators are powerful features in Make.com that allow you to handle multiple items efficiently within your workflows. An iterator breaks down a collection (like a list or array) into individual items and processes them one at a time. An array aggregator does the opposite—it collects individual items into a single array, making it easier to handle large sets of data.

These features are often overlooked because they can seem complex, especially to new users. They require a deeper understanding of data structures and workflow design. Advanced users, however, frequently use them to create more sophisticated and efficient automation processes.

Benefits and Use Cases of Iterator and Array Aggregator

Iterators and array aggregators are invaluable for processing lists of items or handling batch operations. Here are some examples:

  • Processing Large Data Sets: If you have a large set of data that needs to be processed item by item, an iterator can break it down and process each element individually. This is useful for tasks like data entry, updating records, or applying changes to multiple items.
  • Managing Bulk Email Sending: When sending bulk emails, an iterator can process each email address individually, while the array aggregator can collect responses or results into a single array for further processing.
  • Batch Operations: For scenarios that involve repetitive tasks over a set of items, iterators ensure each task is performed separately, while aggregators help consolidate results.

Guide on How To Setup Iterator and Array Aggregator

Here’s how to set up an iterator and array aggregator in a Make.com scenario:

  1. Create a New Scenario: Log in to your Make.com account and create a new scenario.
  2. Add a Module to Generate the Array: Start with a module that generates an array of items. This could be a data retrieval module, such as Google Sheets or an API call that returns a list.
  3. Add the Iterator Module:
    • Click on the “+” button to add a module.
    • Search for “Iterator” and select it.
    • In the iterator module, select the array of items you want to process. The iterator will break this array into individual elements.
  4. Configure Actions for Each Item:
    • Add the modules that should process each item. These modules will receive one item at a time from the iterator.
    • For example, if you’re sending emails, add an email module that uses the current item from the iterator as the recipient.
  5. Add the Array Aggregator Module:
    • After all individual items are processed, add the array aggregator module.
    • Select the items you want to collect into an array. This could be the results or responses from the previous steps.
  6. Use the Aggregated Data:
    • Once the array is aggregated, you can use it in subsequent modules. For instance, you could store the results in a database or send a summary email.
  7. Run and Test the Scenario:
    • Click on the “Run once” button to test the scenario. Make.com will iterate through each item, process it, and then aggregate the results.

Example Scenario: Sending Personalized Emails

  1. Retrieve Email List: Use a Google Sheets module to get a list of email addresses.
  2. Iterate Through List: Use the iterator to process each email address one by one.
  3. Send Email: Add an email-sending module to send a personalized email to each address.
  4. Aggregate Results: Use the array aggregator to collect responses (e.g., delivery status).
  5. Final Action: Store the aggregated results in a Google Sheet or send a summary email.

By following these steps, you can efficiently manage large sets of data and perform batch operations using the iterator and array aggregator modules in Make.com. This will streamline your workflows and enhance your automation capabilities.

#3: Error Handling with Routers

Explanation of Error Handling in Make.com

Error handling is crucial in any automated workflow to ensure that your processes run smoothly even when something goes wrong. In Make.com, routers can be used for advanced error handling by directing the flow of actions based on whether an error occurs. This way, you can create robust workflows that can handle errors gracefully without manual intervention.

Many users might not explore advanced error handling because it seems complex and is not immediately necessary for simple workflows. Beginners often focus on getting their basic automation running and might not consider what happens when something fails. However, understanding and implementing error handling can prevent small issues from becoming significant problems.

Benefits and Use Cases Of Error Handling

Using routers for error handling has several benefits:

  • Reliability: Ensures that workflows continue to run smoothly even when errors occur.
  • Efficiency: Reduces the need for manual intervention, saving time and resources.
  • Flexibility: Allows for customized responses to different types of errors.

Here are some examples of how to use error handling with routers:

  • Retry Mechanisms: If an action fails, you can set up a retry mechanism to attempt the action again after a short delay.
  • Alternative Actions on Failure: If an API call fails, you can set up an alternative action, such as sending an alert or trying a different API.

Guide On How to set up error handling

Here’s how to set up error handling using routers in Make.com:

  1. Create a New Scenario: Log in to your Make.com account and create a new scenario.
  2. Add Your Initial Module: Start with a module that performs an action where errors might occur. For example, an HTTP module making an API call.
  3. Add a Router:
    • Click on the “+” button to add a module and search for “Router.”
    • Add the router to your scenario after the initial module.
  4. Set Up the Main Route:
    • Connect the router to the next module you want to execute if there is no error.
    • This could be a module that processes the data returned by the initial action.
  5. Set Up the Error Route:
    • Click on the router and add a new route for errors.
    • Connect this route to a module that handles the error. This could be an email module that sends an alert, or a delay module followed by a retry of the initial action.
  6. Configure the Error Route:
    • In the settings of the router, define the conditions that will trigger the error route. You can specify which types of errors (e.g., HTTP errors, timeouts) should activate the error route.
    • For retry mechanisms, add a delay module before retrying the initial action. Set the delay time according to your needs.
  7. Test Your Scenario:
    • Click on the “Run once” button to test your scenario. Deliberately cause an error to ensure that the error handling route is triggered.
    • Check that the correct modules are executed in response to the error.

Example Scenario: API Call with Retry Mechanism

  1. Initial API Call: Use an HTTP module to make an API call.
  2. Router: Add a router to direct the flow based on the success or failure of the API call.
    • Main Route: If the API call is successful, process the data.
    • Error Route: If the API call fails, add a delay module to wait for a few seconds before retrying the API call.
  3. Retry Mechanism: After the delay, connect another HTTP module to retry the API call.
  4. Alert on Multiple Failures: If the retry also fails, add a module to send an alert (e.g., an email module) to notify you of the repeated failure.

By following these steps, you can create robust workflows in Make.com that handle errors effectively. This will improve the reliability and efficiency of your automations, ensuring they run smoothly even when issues arise.

#4: Custom Functions

Explanation of Custom Functions

Custom functions in Make.com allow you to write your own JavaScript code to perform complex operations within your automation workflows. These functions can manipulate data, perform calculations, and implement conditional logic that would be difficult or impossible with the built-in modules alone. Custom functions add a layer of flexibility and power to your scenarios, enabling you to create more sophisticated and tailored automations.

Custom functions are often seen as an advanced feature because they require some knowledge of JavaScript. Many users might hesitate to use them because they seem complex and intimidating, especially if they don’t have a background in coding. However, learning to use custom functions can significantly enhance what you can achieve with Make.com.

Benefits and Use Cases of Custom Functions

Custom functions can be incredibly beneficial for various tasks:

  • Complex Calculations: Perform calculations that are too complex for standard modules.
  • Data Transformations: Convert or manipulate data into the exact format you need.
  • Conditional Logic: Implement if-else conditions and loops to control the flow of your scenario.

Here are some specific examples:

  • Advanced Data Formatting: Reformat dates, numbers, or text strings to match specific requirements.
  • API Responses: Parse and restructure complex JSON responses from APIs.
  • Dynamic Values: Calculate dynamic values based on multiple inputs, such as discount calculations or dynamic pricing models.

Guide to create and implement a custom function

Here’s how to create and implement a custom function in a Make.com scenario:

  1. Create a New Scenario: Log in to your Make.com account and create a new scenario.
  2. Add a Custom Function Module:
    • Click on the “+” button to add a module.
    • Search for “Code” and select the “JavaScript” module. This module allows you to write and execute custom JavaScript code.
  3. Write Your Custom Function:
    • In the JavaScript module, you will see a code editor. Here, you can write your JavaScript code.
    • The input data from previous modules will be available as input. For example, if you receive JSON data, you can access it as input[0].json.
  4. Example Custom Function:
    • Suppose you want to reformat a date string from YYYY-MM-DD to DD/MM/YYYY.
    var dateStr = input[0].date; // Assume input[0].date is '2023-06-17' var parts = dateStr.split('-'); var formattedDate = parts[2] + '/' + parts[1] + '/' + parts[0]; output = { "formattedDate": formattedDate };
  5. Configure Inputs and Outputs:
    • Define the input data that your custom function will use. You can add fields to specify which data from previous modules should be passed to the function.
    • Define the output structure. In the example above, the output is a JSON object with a single field formattedDate.
  6. Connect the Custom Function Module:
    • Connect the custom function module to the previous module that provides the input data.
    • Add subsequent modules that will use the output of your custom function. For example, you might connect it to a Google Sheets module to save the formatted date.
  7. Test and Validate:
    • Click on the “Run once” button to test your scenario. Ensure that the custom function executes correctly and the output is as expected.
    • Debug any issues by checking the logs and refining your code as needed.

Example Scenario: Advanced Discount Calculation

  1. Retrieve Order Data: Use a module to get order details from an e-commerce platform.
  2. Custom Function for Discount Calculation: Add a JavaScript module to calculate a discount based on the order value and customer type.
    var orderValue = input[0].orderValue; // Assume input[0].orderValue is 150 var customerType = input[0].customerType; // Assume input[0].customerType is 'VIP' var discount = 0; if (customerType === 'VIP') { discount = orderValue * 0.2; // 20% discount for VIPs } else { discount = orderValue * 0.1; // 10% discount for regular customers } output = { "discount": discount };
  3. Use the Calculated Discount: Connect the output of the custom function to another module, such as updating the order details with the discount in your database.

By following these steps, you can leverage custom functions to perform complex operations within your Make.com scenarios, greatly expanding the capabilities and efficiency of your automations.

#5: Webhooks

Explanation of Webhooks

Webhooks are a method for web applications to communicate with each other in real-time. They allow one application to send automated messages or data to another application whenever a specific event occurs. Within Make.com, webhooks can be used to trigger scenarios automatically based on these external events, making your workflows more dynamic and responsive.

Webhooks might be underused or misunderstood by new users because they require some initial setup and a basic understanding of how different web services can interact. Unlike standard modules, webhooks involve configuring external systems to send data to Make.com, which can seem daunting to beginners.

Benefits and Use Cases of Webhooks

Using webhooks can significantly enhance the responsiveness and interactivity of your automations. Here are some benefits and use cases:

  • Real-Time Updates: Webhooks can trigger workflows instantly when an event occurs, such as a new form submission, a payment, or a change in a database. This real-time capability makes your automation more efficient and timely.
  • Alerts and Notifications: You can set up webhooks to send alerts or notifications whenever specific conditions are met, such as receiving an important email or when stock levels drop below a certain threshold.
  • Integration with Non-Supported Apps: For applications that don’t have direct integration with Make.com, webhooks can serve as a bridge, allowing these apps to send data to Make.com for further processing.

Guide On how to set up and use webhooks effectively

Here’s how to set up and use webhooks effectively in Make.com:

  1. Create a New Scenario: Log in to your Make.com account and create a new scenario.
  2. Add a Webhook Module:
    • Click on the “+” button to add a module.
    • Search for “Webhook” and select the “Custom Webhook” module.
  3. Configure the Webhook:
    • Make.com will generate a unique URL for your webhook. This URL is where the external application will send data.
    • Copy this URL and paste it into the configuration settings of the external application you want to connect. This setup will vary depending on the application but usually involves finding the webhook or API integration settings.
  4. Set Up the External Application:
    • In the external application, configure the event that will trigger the webhook. For example, in a form application like Google Forms or Typeform, you can set the webhook URL to receive data when a form is submitted.
    • Specify what data should be sent to the webhook. This might include form responses, user information, or any other relevant data.
  5. Process Incoming Data in Make.com:
    • Once the webhook is set up, return to your Make.com scenario. You can now add modules to process the incoming data.
    • For example, if the webhook is triggered by a form submission, you can add modules to save the data to a Google Sheet, send a confirmation email, or notify your team in Slack.
  6. Test the Webhook:
    • Trigger the event in the external application to ensure that the webhook is working correctly. Check the Make.com scenario to see if the data was received and processed as expected.
    • Debug any issues by reviewing the webhook logs and adjusting the setup as needed.

Example Scenario: Real-Time Lead Capture

  1. Webhook Trigger: Set up a webhook in Make.com and configure your lead capture form (e.g., Typeform) to send data to this webhook URL when a new lead is submitted.
  2. Save Lead Data: Add a Google Sheets module to save the lead information to a spreadsheet.
  3. Send Notification: Add a Slack module to send a notification to your sales team about the new lead.
  4. Follow-Up Email: Add an email module to send a thank-you email to the new lead, confirming that their information has been received.

By following these steps, you can effectively use webhooks to create highly responsive and interactive workflows in Make.com. This will enable real-time automation and integration with a wide range of applications, enhancing the overall efficiency and capabilities of your processes.

Conclusion: Transforming Workflow Automation with Make.com Advanced Features

Recap of the Hidden Features

Throughout this blog, we’ve uncovered five hidden features in Make.com that can significantly enhance your automation workflows:

  1. The HTTP Module: Enables connections to any API, allowing for seamless integration with virtually any web service.
  2. Iterators and Array Aggregators: Facilitate efficient processing of multiple items and batch operations.
  3. Error Handling with Routers: Ensures robust workflows by directing the flow based on success or failure, implementing retry mechanisms, and alternative actions.
  4. Custom Functions: Allows for complex calculations and data transformations using JavaScript, adding flexibility and power to your scenarios.
  5. Webhooks: Provides real-time triggers from external applications, enabling immediate and dynamic automation responses.

These features can transform how you automate tasks, making your processes more efficient, reliable, and sophisticated.