How to Use Albato Webhook

In this article

Webhooks allow you to connect Albato with applications that don’t have a native integration. This method lets external services send data to Albato automatically when a specific event occurs.

In this guide, you’ll learn how to create a webhook connection and use it to receive data from other apps in your automations.

You can apply the same method described below to any application that does not have a native connection or the desired triggers in Albato and that accepts the use of webhooks. If you’re unsure whether an app supports this method, you can check directly with the external app’s support team.

How to create the Webhook connection

1. Go to Albato’s main screen and, in the top menu, click on Apps and then click on Add a Connection.

2. Select the Webhook service and click Add a Connection again at the bottom of the window.

3. Add a unique name in the corresponding field to help you identify this connection in the future. In Albato, it’s possible to create multiple webhook connections for different apps, so a custom name will be very useful here.

We recommend adding a dash and the app name, as shown in the image below, and then clicking Next.

In most cases, the Webhook Parameters and Headers fields are left blank, please follow the instructions provided by the source platform.

4. Now that your credential has been created, you need to copy the unique URL that was generated. This is how the external app will be able to send data. After copying the webhook (URL), click the Got It button.

5. Then, click the Catch a Webhook button.

5. Notice that now, Alabto is waiting to receive data.

6. At this stage, you should go to the external app you want to connect with Albato and add the webhook you just generated and copied from Albato, in the location recommended by the external app.

This setup varies from app to app. If you have any doubts, we recommend checking directly with their support team to confirm where the webhook should be added.

7. In our example we will use the Postman tool. On request we have an order with 3 items.

8. If the request is successful, then the webhook will receive the data.

This is just one example. This setup may vary for each app. In all cases, once the webhook is configured, simply trigger the action associated with it in a real environment.

Field does not appear in the webhook list

If you did not receive one of the expected fields, meaning the field name did not appear in the webhook list, there are a few possible reasons:

1. The external app does not send this information due to security reasons or limitations.
2. The external app does not send this information by default, but we can force the request.
3. The field was not filled in the test example.

In these cases, the first step is to rule out the third option.

• Check whether, in the example you sent, the field you expected to see in Albato was actually filled in and contained valid values in the external app.

• If it wasn’t, simply run a new test and make sure this field is filled in correctly.

If you’ve already confirmed that the field was filled in, then we’ll rule out the first option by forcing the field request.

• To do this in the Webhook Parameters section, enter the names of the fields you want to receive, one per line, exactly as they appear in the external app.

Example

It’s very important to pay attention to the field format in the external app, as this will help ensure the correct configuration of the step.

Usually, the app itself informs the field type. In most cases, they will be:

• string
• integer
• number

These are simple fields. In this case, just adding the field name, as shown in the example above, will be enough.

These are simple fields. In this case, just adding the field name, as shown in the example above, will be enough.

Fields in array format

Now, if we are dealing with fields in array format (string array or object array), the situation changes a bit.

These fields represent grouped sets of information.

Suppose the external app has a field called address.

Inside it, there are subfields such as:

• street;
• city;
• number;
• ZIP code.

The payload would look like this:

{
  address: {
    street: "7 avenue",
    number: "1001",
    city: "Boston",
    zip: "01310-100"
  }
}
  

If you add only the field name address, you won’t have direct access to the internal data of this group.

In this case, you need to define the full field path, as follows:

• address.city
• address.street

This syntax is correct for simple objects or arrays.

Important: this approach works only for simple arrays/objects.

In Albato, fields must be configured exactly this way, respecting the main field name and the internal attribute name, separated by a dot (.).

How to configure webhook fields to request array data

In some webhook scenarios, the request does not send a single object, but instead sends multiple objects grouped inside an array.

To correctly request this data in Albato, you must define the field paths using indexes. Let’s look at an example where, in our external app, you have an array field called datawith multiple elements:

• data[0]
• data[1]

Albato does not automatically expand arrays and each array position must be explicitly defined using indexes (0, 1, 2, etc.)

If you expect more elements, you may need to:

• Add more indexed fields, or
• Adjust the request structure depending on your data source

Also, if each element has its own fields, such as client_idwhen adding fields to the webhook configuration, you should define them like this:

• data.0.client_id
• data.1.client_id

Example:

This tells Albato:

• data: main array
• 0, 1: position inside the array
• client_id: field you want to extract

Each index represents one object inside the array.

Important: If you only configure data.client_id, Albato will not be able to correctly map the array elements.

How to request nested arrays (array inside another array)

In more advanced cases, the webhook sends an array inside another array (nested structure).

From the example shown, the structure looks like this:

• data: main array
• full_name: array inside each data element

Each full_name array contains objects like:

• first_name
• last_name

To request this data correctly, you must define both array levels using indexes.

Example field paths to configure:

This configuration tells Albato that data.0 is first object in the main array, full_name.0 the first object inside the nested array and first_name / last_name the actual values.

Each numeric index explicitly defines which element of each array level Albato should request.

Webhooks with arrays or the need to use filters

If any of the parameters are sent as an array, and you need to use them in most apps that don’t accept this format, you’ll need to use a tool called Iterator.

Learn more details about how to use the Iterator in this article.

Additionally, you can also use filters in your automation. You can learn step by step how to do that here.

Finally, you can also use tools with Parse JSON to separate the fields and extract the final values you need, in case the data arrives grouped.

Final checks after webhook setup

1. Save the automation.
2. Click Wait for Webhook again.
3. Run the test once more by triggering the action again in the external app.

If the desired fields now appear, it means the configuration worked correctly.

If they still don’t appear:

• Check that the field names are exactly the same as in the external app.
• Also confirm the correct format, especially in the case of arrays.

If you’re not sure about the field name or its format, the external app’s support team can also help with this.

If, even after all these tests, the data still does not appear in Albato, it’s very likely that the external app truly blocks the sending of this information, either due to technical limitations or security reasons.

Additionally, it’s important to note that nested arrays (arrays inside other arrays) are not supported by Albato. This type of field cannot be processed and, unfortunately, it’s not possible to access this data.

How to create your automation

Once the credential is configured, you can now create an automation using the webhook we just created. Keep in mind that the same logic applies to other external apps, once the webhook is configured, its usage in Albato will be similar.

To get started, create a new automation.

Click to add a Trigger.

Select Webhook as the trigger, choose the event Incoming webhook, and select the webhook credential we just created.

Next, select the app where you want to send the data.

From this point on, you can use any app you like, and when mapping the fields in that app’s action, you’ll see the webhook parameters normally, just like with any other trigger.