Realizar llamadas a API en flujos de trabajo

Sometimes, your no-code platform's built-in integrations aren't enough. That's where direct API calls come in!

• An API Call is like sending a specific request to another application's server.
• It allows you to fetch data, create records, update information, or trigger actions in apps that don't have a pre-built connector.
• This opens up a world of possibilities for advanced automation.

Why would you need to make a direct API call?

• Access Unique Features: Some app features might not be exposed through standard integrations.
• Connect Niche Apps: Integrate with less common or custom applications.
• Fine-grained Control: Have precise control over the data you send and receive.
• Workarounds: Bypass limitations of existing connectors.

When you make an API call, you're usually performing an HTTP Request. Two common types are:

• GET: Used to retrieve data from a server. Think of it like reading information. It doesn't change anything on the server.
• POST: Used to send data to a server to create a new resource or perform an action. Think of it like submitting a form.

Other methods exist (PUT, DELETE), but GET and POST are excellent starting points for no-code.

Every API call has key components:

• URL (Endpoint): The web address that specifies where to send your request.
• Method: (e.g., GET, POST) What kind of action you want to perform.
• Headers: Extra information about the request, like authentication tokens or content type.
• Body (Payload): The actual data you're sending (mostly with POST, PUT).

Most no-code automation platforms (like Zapier or Make) have a special module for making custom API calls.

• It's often called "Webhooks & HTTP," "HTTP Request," or similar.
• This module provides fields to configure the URL, method, headers, and body.
• You'll map data from previous steps into these fields to make dynamic requests.

Let's see a simple GET request. This example fetches a specific "todo" item from a public test API. Notice how the data is requested without a body.

Try running this example in a terminal:

In your no-code platform, setting up a GET request involves:

• Selecting the "HTTP Request" action.
• Choosing the GET method.
• Entering the URL (e.g., https://jsonplaceholder.typicode.com/todos/1).
• Optionally adding Query Parameters (e.g., ?userId=1) or Headers (e.g., for authentication).

The platform will then make the call and provide the response data for subsequent steps.

Now, a POST request to create a new "todo" item. Notice we include a Body with the data we want to send, and a Content-Type header.

Try running this example in a terminal:

For a POST request in your automation platform:

• Select the "HTTP Request" action.
• Choose the POST method.
• Enter the URL (e.g., https://jsonplaceholder.typicode.com/todos).
• Add Headers, especially Content-Type: application/json if sending JSON.
• Provide the Body data, often in JSON format, mapping dynamic values from previous steps.

After an API call, the server sends back a response. This response typically includes:

• Status Code: A number indicating the request's success or failure (e.g., 200 OK, 201 Created, 404 Not Found, 500 Server Error).
• Response Body: The data returned by the API, usually in JSON format.
• Response Headers: Additional information about the server's reply.

Your no-code platform will then let you use this response data in subsequent steps.

You want to retrieve a list of active users from an API endpoint /users without changing any data on the server. Which HTTP method should you use?

Today, we explored how to make direct API calls within your no-code workflows!

• We learned about GET (fetching data) and POST (sending data) methods.
• You now understand the key components: URL, Method, Headers, and Body.
• Making direct API calls unlocks endless possibilities for integrating almost any service with your automations.

Next, we'll dive into parsing the data you get back from these API calls!