Tutorial Make.com Paso a Paso | Curso Completo Automatizaciones Con Make (Integromat)

How to Use Make.com from Scratch

Introduction to Make.com

• The video introduces Make.com as a powerful tool for automating processes, aimed at helping users progress from basic to advanced levels of understanding.

• The speaker, Nico, shares his experience of generating over $20,000 monthly through automation services without prior programming knowledge.

• The tutorial is structured into three levels: basic, intermediate, and advanced, covering essential concepts like webhooks and APIs.

Getting Started with Make.com

• Users can access Make by creating an account on make.com; the dashboard provides vital information about their automation tasks.

• There are free and paid plans available; the Core plan offers sufficient operations for most users (1,000 operations in the free plan vs. 10,000 in the paid plan).

Understanding Operations and Plans

• Operations are crucial as they determine how many automations can be executed monthly; more operations allow for more complex automations.

• The free plan is ideal for learning purposes but transitioning to a paid plan may be necessary for extensive use.

Dashboard Overview

• Users can track their operation usage through a dashboard that displays spent operations over time.

• Key sections of the dashboard include scenarios (where automations are created), team management (similar to organization settings), and templates provided by Make.

Creating Scenarios

• Scenarios are central to using Make effectively; users can create new scenarios or organize existing ones into folders.

• Users have options to activate or deactivate scenarios easily within their dashboard.

Advanced Features

• Connections are essential for automation; users must connect various tools before they can automate processes effectively.

Introduction to Make and Google Sheets

Overview of the Interface

• The video begins with an introduction to a blank interface, highlighting a prominent purple button with a plus symbol that invites user interaction.

• Users can connect various applications through this interface, with over 6,000 options available. For instance, connecting to Google Sheets is demonstrated.

Exploring Google Sheets Integration

• Within the Make platform, Google Sheets offers multiple categories for actions: "seats," "rows," and "calls." Each category contains specific actions users can perform.

• A typical action demonstrated is searching for rows in Google Sheets. New users must first connect their account by signing in with Google.

Setting Up Actions

• Users are guided to select search methods and fill out unique input fields tailored for each application. These fields differ across applications like Google Docs or CRMs.

• The intuitive nature of these input boxes is emphasized as users prepare to create a new spreadsheet titled "gastos prueba."

Creating and Using Spreadsheets

• A new Google Sheet is created from scratch, where example data (expenses and concepts) are entered for demonstration purposes.

• After creating the sheet, users need to refresh the form to access newly created sheets when searching for rows.

Executing Search Functions

• Users can set filters on their searches within the spreadsheet. The maximum number of rows returned can be adjusted based on user preference.

• Upon executing the search function, results are displayed along with metadata that provides additional context about the retrieved information.

Integrating Data into Other Applications

• The output from Google Sheets includes both essential data (expenses and concepts) and extra metadata useful for understanding API interactions.

• Users learn how to add another module (Google Docs), allowing them to create documents using data pulled directly from their spreadsheets.

Conclusion of Demonstration

How to Use Make for Automation

Introduction to Make and Document Creation

• The speaker demonstrates how to create a document in Google Docs using Make, highlighting that the metadata received from different applications may vary due to differences in application integration.

• The concept of "bubbles" is introduced, representing data points being sent between applications where various actions are executed.

Tools and Features in Make

• An overview of tools provided by Make, including routers, aggregators, and iterators, which facilitate various actions within the platform.

• Explanation of features like file import/export capabilities and an 'explain' function that visually represents the flow of automation processes.

Saving Work and Activating Scenarios

• Emphasis on the importance of saving work manually since Make lacks an auto-save feature; users should frequently use Control + S to avoid losing progress.

• Discussion on activating scenarios with two types of triggers: scheduled (clock icon) or immediate (lightning bolt), indicating when automations will start based on incoming data.

Scheduling Automations

• Users can configure scheduling options for automations, such as running every 15 minutes or at specific times/days. This flexibility allows tailored automation setups depending on user needs.

• Some applications support immediate triggers while others require scheduled ones; understanding this distinction helps users choose appropriate configurations for their tasks.

Intermediate Features: Filters and Data Management

• Transitioning into intermediate functionalities like filters that allow users to refine information processed through automations.

• Filters can be applied both within Make and externally in connected applications; they help ensure only relevant data passes through based on specified criteria.

Practical Application of Filters

• Demonstration of setting up a filter that only processes expenses if they exist; this showcases how filters enhance data relevance during automation execution.

• Various filtering options are available (e.g., contains, does not contain), allowing users to customize their data processing according to specific needs.

Leveraging Automation for Business Efficiency

Creating Your Own Business with Artificial Intelligence

Introduction to the Free Class

• A free class is offered for those interested in starting their own artificial intelligence business or learning tools like Mic to sell these services.

• To enroll, participants need to click on a link provided in the description.

Understanding Filters and Their Application

• Filters are essential for determining when information should be processed; they help ensure that only relevant data is passed through.

• An example of using filters includes sending emails only if an email address exists in a list of potential leads.

The Role of Routers

• Routers work alongside filters by branching paths based on conditions set within the workflow.

• A router executes tasks sequentially along different paths, which can be useful when combined with filters to direct data flow effectively.

Practical Use of Routers with Conditions

• The effectiveness of routers increases when used with specific conditions; for instance, routing based on whether a concept equals "food."

• By setting conditions such as "not equal to food," users can control which data passes through each route, enhancing workflow precision.

Introduction to Iterators and Aggregators

• After discussing filters and routers, iterators and aggregators are introduced as important components in managing data operations.

• Understanding how arrays function is crucial since they play a significant role in both iterators and aggregators.

Working with Arrays

• Arrays serve as lists that can contain various elements, including variables or other arrays; this structure is fundamental for organizing data efficiently.

Understanding Arrays and Bundles in Automation

Key Differences Between Arrays and Bundles

• The speaker explains that arrays execute only once, unlike bundles which can execute multiple times during automation. This distinction is crucial for understanding how data structures operate within the system.

• An example illustrates how to access specific items in an array by index, highlighting that changing the index retrieves different data (e.g., "Nicolas ct" vs. "Amelia Ortiz").

• It is emphasized that while bundles run sequentially during automation, arrays require explicit selection of the desired information, making them a more static form of data storage.

Introduction to Iterators

• Iterators are introduced as tools that convert arrays into bundles, facilitating easier processing of data.

• A practical example demonstrates sending emails using an iterator; it shows how to set up email content dynamically based on array values.

• The challenge of sending emails to multiple recipients from an array is discussed, underscoring the need for iterators to handle such tasks effectively.

Utilizing Iterators for Email Automation

• The process of implementing an iterator is explained step-by-step, including selecting the appropriate array and executing it.

• Upon execution, the initial array transforms into bundles allowing sequential email dispatch—demonstrating the power of iterators in automating repetitive tasks.

• The successful outcome is illustrated with examples of sent emails personalized with names and ages derived from the original array.

Exploring Aggregators: Transforming Bundles Back to Arrays

Understanding Aggregator Functionality

• Aggregators are defined as tools that convert bundles back into arrays, reversing the function performed by iterators.

• A demonstration shows how to aggregate expenses from various sources into a single output array for further analysis or reporting purposes.

Practical Applications of Aggregation

• The input-output relationship between bundles and arrays is clarified through a visual representation showing how aggregated data can be manipulated post-conversion.

• While iterators are often preferred for their utility in handling dynamic datasets, aggregators also have significant applications depending on user needs.

Types of Aggregation Techniques

Understanding Data Aggregation and Iteration

Introduction to Basic Calculations

• The speaker demonstrates a calculation resulting in 17, derived from the average of three numbers: 13, 15, and 23. This highlights the utility of averaging data from various sources.

Text Aggregator Functionality

• The text aggregator is introduced as a tool that combines multiple text bundles into an array format. It allows for flexible arrangements based on user-defined row separators.

Practical Application of Iterators and Aggregators

• An example is provided where iterators and aggregators are used together in a newsletter automation process. This illustrates how these tools can streamline content creation by organizing key points effectively.

Generating Content with AI

• The process involves using an iterator to handle individual bundles (key points), which are then developed into full sections through AI assistance. This showcases the integration of technology in content generation.

Importance of Understanding Iterators and Aggregators

• The speaker emphasizes the significance of grasping how iterators convert arrays into bundles, while aggregators do the reverse. Mastery of these concepts is crucial for effective automation workflows.

Functions for Data Transformation

Overview of Functions

• Functions are described as essential tools for modifying and transforming data. Various types exist, each serving different purposes in data manipulation.

Commonly Used Text Functions

• Several text functions are highlighted:

• Length: Counts words in a string.

• Lowercase: Converts all characters to lowercase.

• Capitalize: Capitalizes the first letter.

Advanced Text Manipulation Techniques

• Replace: Substitutes one word for another within a string.

• Contains: Checks if a specific word exists within text, returning true or false.

Splitting Strings for Data Organization

• The split function is demonstrated using "Nicolás Pérez," showing how it divides strings based on specified delimiters (e.g., spaces). This function aids in organizing names into separate components.

Time Functions Overview

Understanding Date and Time Functions in Programming

Introduction to Time Variables

• The concept of time as a variable is introduced, explaining that it represents the current moment but in a unique format: seconds since January 1, 1970.

• This format can be complex for beginners; however, some applications utilize it because it's straightforward to convert into days and weeks.

Working with Date Functions

• The Now function provides a more user-friendly representation of the current date and time. It allows users to easily manipulate dates by adding or subtracting days.

• Users can add positive or negative days using simple arithmetic operations on the date variables.

Setting Specific Dates

• The set function allows users to change specific components of a date (e.g., year), although its usage is less common compared to other functions.

Formatting Dates

• The parDate function converts strings into date formats, while the formatDate function modifies existing date formats according to user specifications.

• An example demonstrates nesting functions where parDate is used before applying formatDate, showcasing how functions can work together effectively.

Mathematical Functions Overview

• Two key mathematical variables are discussed: Pi (π), which is rarely used, and Random, which generates numbers between 0 and 1 for probability calculations.

• Common mathematical functions such as mean, median, maximum, and minimum are highlighted alongside practical examples involving rounding random numbers.

Probability Manipulation with Random Numbers

• A demonstration shows how multiplying a random number by four creates probabilities for outcomes when rounded down.

Conditional Functions in Programming

• Important conditional functions like getIfEmpty are explained; they help manage errors by providing alternative paths if certain conditions aren't met.

Understanding Webhooks and APIs

Introduction to Data Handling

• The discussion begins with the concept of arrays, where a selected item can be retrieved from an array. This is useful for sending specific data, such as just a name in an email instead of a full greeting.

String Manipulation Techniques

• The speaker explains how to capitalize names using the capitalize function, which transforms both first and last names into uppercase letters before splitting them based on spaces.

Importance of Webhooks

• An introduction to webhooks is provided, described as triggers that activate actions when data arrives. They are essential for real-time data processing.

Practical Application of Webhooks

• The example of Tali is introduced, showcasing how it allows users to fill out forms instantly. The term "Instant" indicates immediate action upon form submission.

Demonstration with Tali Forms

• A demonstration follows where a web form is filled out with monthly income details. Upon submission, the webhook activates automatically, illustrating instant data handling.

Automation Capabilities

• The speaker emphasizes the benefits of webhooks in automating processes like database updates or email notifications immediately after receiving new data.

Custom Webhooks and Integration Challenges

Custom Webhook Setup

• Transitioning to custom webhooks, the speaker notes that these require additional setup steps compared to standard ones. Users must create links for information transmission.

Integrating with Air Table

• Air Table integration is discussed; unlike other applications, it lacks instant capabilities but can still be configured for manual connections through custom webhooks.

Creating New Tables in Air Table

• A step-by-step guide on creating a new table in Air Table is provided. Columns are customized for specific needs like tracking expenses rather than default settings.

Button Functionality in Air Table

• The functionality of buttons within Air Table is explained; pressing a button triggers actions defined by formulas set up by the user.

Coding Requirements for Custom Connections

• It’s noted that connecting applications without direct integration often requires coding knowledge. Each application may have different complexities regarding webhook setups.

Understanding Webhooks and APIs in Make

Introduction to Webhooks

• The speaker discusses the importance of record IDs for tracking data rows in Make. After executing a command, the system confirms with an "accepted" message, indicating successful data transmission.

Custom Data Launching with Webhooks

• Webhooks allow users to send customized data directly to Make. This process is more advanced and varies by application, necessitating research on specific implementations.

Understanding APIs

• The concept of APIs is introduced as integral to interactions within applications like Google Sheets and Docs. These interactions involve sending requests and receiving responses from external services.

API Calls Explained

• API calls consist of sending information (requests) and receiving responses. However, not all applications have pre-existing connections in Make; users may need to create their own.

Creating Custom Connections

• Users can establish custom connections using the HTTP module in Make. This involves understanding how web requests function based on established protocols from early internet development.

Filling Out API Requests

• Key components of an API request include:

• Endpoint: The URL directing where the request is sent.

• Methods: Common methods are GET (to retrieve information) and POST (to send data that requires processing).

Differences Between GET and POST Methods

• GET Method: Used for retrieving information without requiring action from the server.

• POST Method: Involves sending inputs that require processing or generation of new outputs by the server.

Headers and Authentication

• Headers typically contain key-value pairs for authentication, such as secret keys necessary for establishing secure connections with APIs.

Structuring JSON Requests

• When making requests, JSON format is used universally. Users must structure their requests correctly to ensure proper communication with external services.

Practical Example of Sending Data

• An illustrative example describes sending a request for food items (e.g., hamburgers), demonstrating how structured data informs applications about user needs.

Conclusion on Request Methods

Connecting to Genus API

Overview of Genus Application

• The Genus application allows users to access daily news updates. Users need an API key for authentication, which acts as a password.

• To utilize the application, one must refer to the API documentation, specifically focusing on the Search endpoint for making HTTP requests.

Making HTTP Requests

• The method used for requests is GET, and parameters are included directly in the URL rather than in JSON format.

• The base URL is specified before any query parameters; mandatory parameters must be included after a question mark in the URL.

Example Request and Response Handling

• An example keyword (e.g., "AI") is used along with the API key to make a request. No body type is needed since it's a GET request.

• A successful response returns a status code of 200. It's recommended to parse responses for better readability of returned articles.

Adding Parameters to Requests

• Additional parameters can be added, such as country or maximum results. For instance, limiting results from ten to five by specifying max results.

• Emphasizes that using APIs isn't daunting; it requires adding some extra data compared to previous methods.

Exploring Weather API

Challenges with Weather API Documentation

• The Weather API has poor documentation, making it challenging for users. It’s crucial first to create an account and obtain an API key.

• Users should locate relevant documents within the provided resources like "API Explorer" or direct links to documentation.

Constructing Requests for Current Weather Data

• To retrieve current weather information, users need specific endpoints and methods outlined in the documentation.

• If examples are not provided in documentation, careful reading is essential to understand required parameters like 'key' and 'q'.

Finalizing Request Format

• Required parameters include both 'key' (the user's unique API key) and 'q' (the location query).

• After constructing the request with necessary parameters (e.g., querying weather in Paris), executing it yields location-specific weather data.

Understanding API Parameters in GET and POST Methods

Key Concepts of API Parameter Placement

• The discussion begins with the importance of correctly placing parameters when making API calls. It emphasizes that for the GET method, parameters should be placed at the top of the request.

• In contrast, when using the POST method, it is generally recommended to place parameters at the bottom of the request. This distinction is crucial for proper API functionality.

• The speaker notes that while both examples provided require parameters directly, there are instances where headers may need specific information such as authorization tokens.

Authorization in API Calls

• To ensure permission for making API calls, it's essential to include an authorization header. This typically involves specifying a token (e.g., "Bearer") along with your API key.