What You Will Learn

• How Make.com functions are organized and when to use each category
• Text and binary techniques for cleaning and formatting data
• Date and time functions for scheduling and deadline automation
• Array and math functions for data aggregation and transformations
• Using general, custom, and system variables for logic, debugging, and monitoring

Study Guide

Introduction

Welcome to the comprehensive video course, "Make.com Functions: How Each One Works & Which You Should Use." In this course, you'll gain an in-depth understanding of the various functions offered by Make.com, a powerful platform for creating automations that streamline workflows and enhance business operations. Whether you're a beginner or an experienced user, this course will equip you with the knowledge to leverage these functions effectively, helping you build automations that save time, reduce errors, and increase revenue. Let's dive into the world of Make.com functions and discover how they can transform your business processes.

Comprehensive Overview of Make.com Functions

The core purpose of Make.com functions is to provide users with a set of tools for manipulating and transforming data within automation scenarios. These functions enable a wide range of operations, from simple tasks like changing text case or performing calculations, to more complex actions such as parsing dates, working with arrays, and encoding URLs. Understanding and utilizing these functions effectively is crucial for creating powerful, efficient, and tailored automations that can streamline workflows and improve productivity.

Text and Binary Functions

Text and Binary functions are among the most commonly used and revenue-driving categories in Make.com. They are essential for tasks such as formatting data from APIs, ensuring consistency in communications, extracting specific parts of text, and cleaning data. Let's explore some key functions in this category:

Length: This function returns the number of characters in a string or items in an array. It's useful for string operations, URL validation, and controlling text length for a better user experience.
Example 1: Checking the character count of a generated proposal to ensure it meets specific length requirements.
Example 2: Validating the length of a URL before processing it in an API call.

Lower/Upper/Capitalise/Start Case: These functions change the case of strings, which is important for API consistency, URL formatting, and improving the perceived quality of formal communications.
Example 1: Standardizing email addresses to lowercase to avoid case-sensitivity issues.
Example 2: Converting names to uppercase for consistency in reports.

Asky: Used for handling characters with accents or non-standard characters, particularly with older APIs. It can remove accents or replace accented characters with standard ASCII equivalents.
Example 1: Removing accents from names for uniformity in a database.
Example 2: Cleaning up non-standard characters in text data before processing.

Replace: A versatile function for finding and replacing substrings within a string. It's useful for isolating parts of domain names, manipulating URL parameters, and addressing issues like new lines being stripped in proposal platforms.
Example 1: Replacing new lines with \n for API compatibility.
Example 2: Standardizing formatting by replacing specific characters in text data.

Trim: This function removes whitespace from the beginning and end of a string, which is useful for cleaning up inconsistent formatting, especially when scraping data.
Example 1: Removing leading and trailing spaces from user input fields.
Example 2: Cleaning up spaces in scraped data before further processing.

Substring: Allows extracting a portion of a string based on character indices. It can be used for isolating domain names or query parameters, often in conjunction with length.
Example 1: Extracting a domain name from a full URL.
Example 2: Retrieving a segment of a text based on character position.

Index Of: Returns the position of the first occurrence of a substring within a string. It can be used with substring to dynamically extract parts of a string based on a delimiter.
Example 1: Determining the position of a query parameter in a URL.
Example 2: Finding the location of a specific word in a text string.

Split: Divides a string into an array of substrings based on a specified delimiter. It's useful for parsing data and iterating over individual components.
Example 1: Splitting a CSV line into an array of values.
Example 2: Separating a sentence into individual words for analysis.

Encode URL/Decode URL: Functions for converting text into URL-safe formats (encoding) and back (decoding). They handle characters not allowed in URLs by replacing them with percent-encoded equivalents.
Example 1: Encoding text for safe inclusion in a URL query string.
Example 2: Decoding a URL parameter to retrieve the original text value.

Escape HTML/Escape Markdown/Strip HTML: Functions for handling HTML and Markdown content. Escape HTML replaces HTML special characters with their entity equivalents. Escape Markdown handles Markdown syntax. Strip HTML removes all HTML tags, leaving only the plain text content.
Example 1: Stripping HTML tags from a web page to extract plain text.
Example 2: Escaping HTML characters in user-generated content to prevent injection attacks.

Contains: Checks if an array includes a specific element, returning a Boolean (true/false). It's useful for conditional logic in workflows.
Example 1: Checking if a list of tags contains a specific keyword.
Example 2: Verifying the presence of an item in a shopping cart array.

MD5/SHA1/SHA256/SHA512/Base64: These are encryption and encoding functions. While they serve a purpose in data encryption and encoding, their use cases are considered fringe for most common business automations involving data manipulation between applications.
Example 1: Generating an MD5 hash for a password before storing it in a database.
Example 2: Encoding binary data into Base64 for safe transmission in an email.

To Binary/To String: Data type conversion functions. To Binary converts a string to its binary representation (ASCII values). To String converts other data types (like numbers or Booleans) into strings.
Example 1: Converting a number to a string for use in a proposal template.
Example 2: Changing a Boolean value to a string for API compatibility.

Math Functions

Math functions in Make.com are essential for performing calculations and handling numerical data. They can be used for a variety of purposes, from simple arithmetic to more complex mathematical operations.

Pi: The mathematical constant π. While it has its place in specific mathematical libraries, it's unlikely to be used in most practical Make.com scenarios.
Example 1: Calculating the circumference of a circle in a geometry-related automation.
Example 2: Using π in a formula to calculate the area of a circle.

Random/Round: Random generates a random number between 0 and 1 (inclusive). Round rounds a number to the nearest integer. Combining these is very useful for generating random integers within a specified range.
Example 1: Randomly assigning tasks to team members.
Example 2: Creating variations in content by randomly selecting from a list of options.

Average/Sum/Max/Min: Basic mathematical aggregation functions for arrays or individual numbers. These functions are useful for summarizing numerical data.
Example 1: Calculating the average sales figures for a week.
Example 2: Finding the maximum value in a dataset of customer ratings.

Ceil/Floor: Ceil returns the smallest integer greater than or equal to a number. Floor returns the largest integer less than or equal to a number.
Example 1: Rounding up the total price of an order to the nearest whole number.
Example 2: Using floor to round down a discount percentage in a pricing model.

Parse Number/Format Number: Crucial functions for working with numerical data, especially financial information. Parse Number converts a string containing a number into a numerical value. Format Number formats a number into a string with specified decimal points, thousand separators, and currency symbols.
Example 1: Formatting a sales figure with a thousand separator for better readability.
Example 2: Parsing a currency-formatted string into a number for calculations.

Date and Time Functions

Date and Time functions are crucial for managing schedules, setting deadlines, and handling time-sensitive data in various applications. They are vital for automating business processes and ensuring timely actions.

Now: Returns the current date and time in a human-readable format.
Example 1: Logging the start time of a task for tracking purposes.
Example 2: Using the current time to timestamp a transaction.

Timestamp: Returns the number of seconds since January 1, 1970 (Unix epoch). Some APIs may require this format.
Example 1: Sending a timestamp to an API that requires Unix time for scheduling.
Example 2: Comparing timestamps to calculate the duration of an event.

Add Seconds/Minutes/Hours/Days/Months/Years: Functions for adding specified time units to a date. These are very useful for setting due dates or future events in workflows.
Example 1: Adding seven days to the current date to set a project deadline.
Example 2: Scheduling a follow-up email to be sent one month after a customer purchase.

Set Date/Month/Year: Functions for setting a specific part of a date while keeping other components the same.
Example 1: Setting the 15th of the current month for a recurring billing cycle.
Example 2: Adjusting the year component of a date for a future event.

Format Date/Parse Date: Format Date converts a date object into a string according to a specified format. Parse Date converts a date string in a given format into a date object.
Example 1: Formatting a date to MM/DD/YYYY for a customer invoice.
Example 2: Parsing a date string from an email into a date object for processing.

Calendar Picker: Allows manually selecting a specific date and time. While it's rarely used in practice, it can be helpful for specific user-driven scenarios.
Example 1: Allowing users to select a date for a meeting in a scheduling app.
Example 2: Using a calendar picker to set a reminder date for an event.

Array Functions

In Make.com, an array is an ordered list of items, which can be of any data type. Array functions allow for manipulation of these lists, enabling users to manage collections of data effectively.

Join: Converts an array into a string by concatenating its elements with a specified delimiter.
Example 1: Joining a list of email addresses into a single string for a bulk email send.
Example 2: Creating a comma-separated list of product names for a report.

Length: Returns the number of items in an array.
Example 1: Counting the number of items in a shopping cart array.
Example 2: Determining the size of a list of attendees for an event.

Keys: Extracts the keys from an object (collection) and returns them as an array.
Example 1: Retrieving the field names from a database record.
Example 2: Listing the attributes of an object for analysis.

Slice: Extracts a portion of an array based on start and end indices.
Example 1: Selecting a subset of products from a larger inventory list.
Example 2: Extracting a range of items from a list of sales transactions.

Merge: Combines two or more arrays into a single array.
Example 1: Merging customer lists from different sources into a unified database.
Example 2: Combining multiple datasets into a comprehensive report.

Contains: Checks if an array includes a specific element.
Example 1: Verifying if a user is part of a group in a membership list.
Example 2: Checking if a particular product is in stock in an inventory array.

Remove: Removes a specific element from an array.
Example 1: Deleting an item from a to-do list.
Example 2: Removing an outdated entry from a contact list.

Add: Adds an element to the end of an array.
Example 1: Appending a new task to a project task list.
Example 2: Adding a new product to an inventory array.

Map: A powerful function for iterating over an array and applying a transformation or filtering logic to each element.
Example 1: Extracting 'hair color' from an array of 'profiles' objects.
Example 2: Filtering 'names' based on 'hair color' being 'Brown'.

Sort/Shuffle/Reverse: Functions for reordering array elements. Sort sorts based on alphabetical order or date/time. Shuffle randomizes the order. Reverse flips the order of elements.
Example 1: Sorting a list of events by date.
Example 2: Randomizing the order of questions in a quiz.

First/Last: Quickly retrieves the first or last element of an array.
Example 1: Accessing the first item in a list of recent transactions.
Example 2: Retrieving the last message in a chat history.

Flatten: Converts a multi-dimensional array into a single-dimensional array.
Example 1: Flattening a list of lists into a single list for processing.
Example 2: Simplifying a nested data structure for easier manipulation.

Distinct/Dedup: Removes duplicate elements from an array.
Example 1: Ensuring a list of email addresses contains only unique entries.
Example 2: Cleaning up a dataset by removing duplicate records.

To Collection/To Array: Functions for converting between arrays and collections (objects).
Example 1: Transforming an array into a collection for structured data access.
Example 2: Converting a collection into an array for iteration.

General Functions

General functions in Make.com provide essential tools for building dynamic and robust automation scenarios. They allow for conditional logic, data manipulation, and scenario management.

Execution ID: Returns a unique identifier for the current scenario execution.
Example 1: Logging execution IDs for tracking and debugging purposes.
Example 2: Using the execution ID to link related processes in a workflow.

Brackets (): Used for grouping expressions, especially in mathematical operations, to control the order of evaluation.
Example 1: Ensuring correct order of operations in a complex formula.
Example 2: Grouping conditions in a logical expression for clarity.

Get: Selects a specific element from an array based on its index.
Example 1: Accessing a particular item in a list of products.
Example 2: Retrieving the nth element from a dataset.

If: A conditional function that evaluates a Boolean expression and returns one of two specified values based on whether the expression is true or false.
Example 1: Displaying a different message based on user status.
Example 2: Applying a discount if a purchase amount exceeds a certain threshold.

If Empty: Checks if a value is empty and returns one of two specified values accordingly.
Example 1: Providing a default value when data might be missing from an API.
Example 2: Handling empty fields in a form submission gracefully.

Switch: A powerful function that acts as a multi-way conditional, evaluating an input against a series of defined values and returning a corresponding result for the first match.
Example 1: Determining an output based on a 'service name' input.
Example 2: Routing tasks to different departments based on a category code.

Omit/Pick: Functions for manipulating objects (collections). Pick creates a new object containing only the specified keys from the original object. Omit creates a new object excluding the specified keys.
Example 1: Extracting specific fields from a customer record for a report.
Example 2: Removing sensitive information from a data object before sharing.

Logical Operators (= != > < and or): Standard logical operators for building conditional expressions.
Example 1: Comparing values to determine if a condition is met.
Example 2: Combining multiple conditions using and or or for complex logic.

Custom and System Variables

Custom variables are user-defined variables that can store and reuse data within a Make.com scenario. System variables are pre-defined variables that provide information about the current scenario execution and the Make.com environment.

Execution URL/Logs: Provides dynamic URLs to the current scenario execution details and logs.
Example 1: Adding links in notifications for easy access to execution logs.
Example 2: Using execution URLs for quick debugging of failed scenarios.

Custom System Variables (e.g., Data Consumed, Execution Started At/Stopped At, Is Incomplete Execution, Team Variables, Organization Variables): Meta-information about the scenario execution, team, or organization.
Example 1: Monitoring the amount of data consumed during a scenario run.
Example 2: Tracking the start and stop times of a scenario for performance analysis.

Operations Consumed/Operations Left: Shows the number of operations used and remaining in the current account.
Example 1: Setting up alerts when the operation count is low to avoid interruptions.
Example 2: Monitoring operations to manage resource consumption effectively.

Conclusion

Congratulations! You've now completed the comprehensive course on "Make.com Functions: How Each One Works & Which You Should Use." By understanding and applying these functions, you're equipped to create powerful automations that can transform your business processes, increase efficiency, and drive revenue. Remember, the thoughtful application of these skills is crucial for maximizing the potential of Make.com. As you continue to explore and experiment with these functions, you'll discover even more ways to optimize your workflows and achieve your business goals. Keep pushing the boundaries of what's possible with Make.com, and enjoy the journey of creating seamless and effective automations.

Podcast

There'll soon be a podcast available for this course.

Frequently Asked Questions

Introduction

Welcome to the comprehensive FAQ section for the 'Video Course: Make.com Functions: How Each One Works & Which You Should Use.' This resource is designed to answer your questions about Make.com functions, from basic concepts to advanced applications. Whether you're new to automation or an experienced user, this FAQ will provide insights and practical guidance to help you harness the power of Make.com functions effectively.

What is the core purpose of Make.com functions, and why are they essential for building automations?

Make.com functions are built-in tools that allow users to manipulate and transform data within their automation scenarios. They enable a wide range of operations, from simple tasks like changing text case or performing calculations, to more complex actions such as parsing dates, working with arrays, and encoding URLs. These functions are essential because they provide the necessary building blocks to process data dynamically as it moves through an automation flow, ensuring that it is in the correct format and structure required by different modules and applications. Understanding and utilizing these functions effectively is crucial for creating powerful, efficient, and tailored automations that can streamline workflows and improve productivity.

Which categories of Make.com functions are considered the most useful for generating revenue and simplifying workflows, according to the source?

According to the source, the most commonly used and revenue-driving function categories are Text and Binary functions and Date and Time functions. Text and Binary functions are highlighted for their ability to manipulate strings, which is essential for tasks like formatting data from APIs, ensuring consistency in communications (e.g., capitalization), extracting specific parts of text (e.g., URLs), and cleaning data (e.g., removing whitespace or accents). Date and Time functions are crucial for managing schedules, setting deadlines, and handling time-sensitive data in various applications, making them vital for automating business processes and ensuring timely actions.

Can you provide examples of how Text and Binary functions like length, lower, upper, replace, and substring can be used in practical automation scenarios?

• length: Used to check the character count of a generated proposal or URL before proceeding, ensuring it meets specific length requirements for optimal display or API limitations.
• lower: Useful for standardizing email addresses or URL slugs to lowercase, avoiding case-sensitivity issues with APIs or improving aesthetics.
• upper: Employed to convert names or identifiers to uppercase for consistency in reports or when interacting with systems that require a specific case.
• replace: Highly versatile for tasks such as removing unwanted parts of a string (e.g., isolating a query parameter from a URL), standardizing formatting (e.g., replacing new lines with a specific character for API compatibility), or substituting placeholders in templates.
• substring: Used to extract a specific portion of a string, such as isolating a domain name from a full URL or retrieving a segment of a text based on character position.

How do Date and Time functions like now, addDays, setDate, formatDate, and parseDate facilitate automation of time-related tasks?

• now: Retrieves the current date and time, serving as a starting point for many time-based automations, such as scheduling tasks or logging events.
• addDays: Allows for easy calculation of future dates, such as setting due dates a specific number of days after a trigger event, which is valuable for project management and scheduling.
• setDate: Enables the setting of a specific day of the month while retaining other date components (year, month, time), useful for scenarios like consistently setting invoice dates or recurring monthly tasks.
• formatDate: Converts a date and time object into a string with a specified format, essential for ensuring dates are correctly interpreted by different APIs or when presenting dates in a user-friendly manner.
• parseDate: Takes a date string in a specific format and converts it into a date and time object that Make.com can work with, crucial for processing dates from external sources that may not adhere to the standard Make.com format.

Explain the concept of arrays in Make.com and how Array functions like join, split, map, filter (implied in map), and get are used to manage collections of data.

In Make.com, an array is an ordered list of items, which can be of any data type (e.g., text, numbers, objects). Array functions allow for manipulation of these lists:

• join: Combines all items in an array into a single string, using a specified delimiter (separator).
• split: Divides a string into an array of substrings based on a specified delimiter.
• map: Iterates over each item in an array and applies a transformation, allowing for the extraction of specific attributes or filtering based on conditions, making it a powerful tool for data processing and reducing operational costs compared to using separate filter modules.
• get: Retrieves a specific item from an array based on its index (position), providing a direct way to access elements within a collection.

The source discusses "Switch" and "If Empty" as General functions. How do these functions contribute to creating more dynamic and robust automation scenarios?

• Switch: Acts as a multi-way conditional operator, allowing a single input value to be evaluated against multiple cases. Based on the matching case, a different output or action can be executed. This simplifies complex branching logic within a scenario, often replacing the need for multiple "Router" modules and improving maintainability by centralizing conditional paths.
• If Empty: Checks if a given value is empty (null, an empty string, or an empty array). If it is empty, it returns one specified value; otherwise, it returns another. This is useful for providing default values when data might be missing from an API or another module, ensuring the automation continues to function smoothly and handles potential data gaps gracefully.

What are Custom and System Variables in Make.com, and which system variables are highlighted as being particularly useful for monitoring and managing automation performance?

Custom variables are user-defined variables that can store and reuse data within a Make.com scenario. System variables are pre-defined variables that provide information about the current scenario execution and the Make.com environment. The system variables highlighted as particularly useful are Operations consumed and Operations left. These variables allow users to monitor the number of operations their scenario is using and the remaining operations in their current Make.com plan, enabling proactive management of resource consumption and helping to avoid interruptions due to reaching operation limits. The Execution ID and Scenario URL (along with /logs/:executionID) are also useful for quickly accessing specific execution logs for debugging and tracking purposes.

The source briefly mentions cryptographic functions like md5, sha1, sha256, sha512, and base64. What is the general advice given regarding their use in typical Make.com automation scenarios focused on revenue generation and workflow simplification?

The general advice given is that these cryptographic functions are rarely needed in typical Make.com automation scenarios focused on revenue generation and workflow simplification. While they serve a purpose in data encryption and encoding, their use cases are considered fringe for most common business automations involving data manipulation between applications. The source suggests that if users find themselves heavily relying on these functions for cryptographic purposes, they might not be using Make.com in the most appropriate way, as the platform is primarily designed for simpler data transformations involving strings, arrays, and dates to connect different services.

How does the trim function enhance data cleaning in Make.com?

The trim function removes whitespace (spaces, tabs, newlines) from the beginning and end of a string. This is particularly useful when processing data scraped from websites or received from users where inconsistent formatting might lead to errors or unwanted spaces. By using the trim function, you ensure that the data is clean and ready for further processing or storage, eliminating potential issues caused by extraneous whitespace.

What is the role of the format number function in numerical data manipulation?

The format number function in Make.com is used to convert numbers into a specific string format, allowing you to control the number of decimal places, thousand separators, and other formatting aspects. This is crucial for ensuring that numerical data is presented consistently across different applications and reports. For example, when generating financial reports, you might use the format number function to ensure all currency values have two decimal places and appropriate comma separators for thousands.

How can the random and round functions be used together in automation?

The random function generates a floating-point number between 0 (inclusive) and 1 (exclusive). When combined with the round function, which rounds a number to the nearest integer, you can generate random integers within a specified range. This combination is useful for tasks like randomly assigning a team member to a new task or selecting a random sample from a dataset for testing purposes. By multiplying the random output by a desired range and then rounding, you can achieve the desired random integer within that range.

What is the difference between a timestamp and a standard date/time format?

A timestamp represents a date and time as the number of seconds that have elapsed since the Unix epoch (January 1, 1970). A standard date/time format presents the date and time in a human-readable format (e.g., YYYY-MM-DD HH:MM:SS). Timestamps are often used in programming and APIs because they provide a precise and unambiguous way to represent time, while standard date/time formats are more user-friendly and easier to read.

How does the capitalize function differ from the lower function?

The capitalize function converts the first letter of a string to uppercase, often used for formatting names correctly in email communications or reports. In contrast, the lower function converts all characters in a string to lowercase, which is useful for standardizing inputs for case-sensitive systems or formatting URLs. Both functions serve distinct purposes in ensuring data is presented or processed in the desired format.

How can the split function be used to create an array?

The split function divides a string into an array of substrings based on a specified delimiter. For instance, the string "apple,banana,cherry" split by the delimiter "," would result in an array containing the elements "apple", "banana", and "cherry". This function is particularly useful for parsing CSV data or breaking down a list of items into manageable parts for further processing within an automation scenario.

How does the map function facilitate data transformation in Make.com?

The map function iterates over each item in an array and applies a specified function or operation to each item, returning a new array with the transformed results. This function is incredibly useful for filtering and transforming data sets. For example, given an array of objects with "name" and "hair color" keys, map can be used to filter and return a new array containing only the names where the "hair color" is "brown". This allows for efficient data processing and transformation without the need for additional filter modules.

What are some common challenges when using Make.com functions, and how can they be overcome?

Common challenges when using Make.com functions include understanding the correct syntax for each function, handling unexpected data formats, and ensuring compatibility between different modules. To overcome these challenges, users should familiarize themselves with the Make.com documentation, experiment with functions in a test environment, and use error handling techniques such as try-catch blocks to manage exceptions. Additionally, leveraging community forums and support resources can provide valuable insights and solutions to common issues.

How can the switch function streamline decision-making in automation scenarios?

The switch function provides a more concise and often more readable way to handle multiple conditional outcomes based on the value of a single expression. Instead of chaining multiple if statements or creating separate routes in a router, switch allows you to define different outputs for various input values within a single function, improving scenario clarity and maintainability. This makes it easier to manage complex decision-making processes and reduces the likelihood of errors in branching logic.

What is the significance of using array functions in data processing?

Array functions in Make.com are essential for efficiently managing and processing collections of data. Functions like join, split, map, and get allow users to manipulate arrays in powerful ways, enabling tasks such as data transformation, filtering, and aggregation. By using these functions, users can optimize scenario performance, reduce the need for additional modules, and improve the overall scalability of their automation workflows.

How do general, custom, and system variables enhance the flexibility of Make.com scenarios?

Variables in Make.com, including general, custom, and system variables, play a crucial role in enhancing the flexibility and functionality of automation scenarios. General variables allow for dynamic data manipulation and decision-making within scenarios. Custom variables enable users to store and reuse data across different modules, improving efficiency and reducing redundancy. System variables provide valuable insights into scenario execution and resource consumption, aiding in monitoring and optimization efforts. Together, these variables contribute to more adaptable, maintainable, and efficient automated workflows.

What are the best practices for debugging and optimizing Make.com scenarios?

To effectively debug and optimize Make.com scenarios, consider the following best practices: 1. Use logging: Implement detailed logging within your scenarios to track data flow and identify issues. 2. Test incrementally: Build and test scenarios in small increments to isolate problems quickly. 3. Monitor operations: Regularly check operation usage to ensure efficient resource management. 4. Optimize functions: Use the most appropriate functions for tasks and avoid unnecessary operations. 5. Leverage community resources: Engage with the Make.com community for insights and solutions. By following these practices, you can enhance the performance and reliability of your automation scenarios.