Albato

https://wiki.albato.com/en
Admin
Albato is a no-code iPaaS platform that helps users connect over 800 apps and automate routine tasks...
Tokens:20,927
Snippets:88
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Example cURL Request for Get Own Credential Metadata

Source: https://wiki.albato.com/en/articles/9264449-method-for-getting-metadata-of-a-connection-to-your-own-system

This cURL command demonstrates how to make a POST request to the `get-own-credential-metadata` endpoint, including necessary headers for content type, accept, and basic authorization. Replace the Authorization token with your actual credentials.

```bash
curl --header "Content-type: application/json" --header "Accept: application/json" --header "Authorization: Basic cEFJjGffUSkV6WFFyWUhBM1RzS2hRHg7iKgReghUiijBfrdTY6" --request POST "https://api.albato.com/wl/partner-name/get-own-credential-metadata"
```

--------------------------------

### Example JSON Response for Add User Method

Source: https://wiki.albato.com/en/articles/9263916-method-for-adding-a-user

An example of the successful JSON response returned by the Albato user creation API, showing the structure and typical data returned upon successful user registration, including user ID, email, and API tokens.

```json
{
    "success": true,
    "data": {
        "id": 1357,
        "email": "test@example.com",
        "permanentToken": "IhIHggKkgBP-qtiDXLAMxKsSOO6A4Mu_L",
        "sessionToken": "eyJ0eXAiOiJKV.eyJpZGVudGl0eSI6OTczMzAsInRydWVJZGVudGl0eS..._GT8jc8Xby-3sidRPk",
        "sessionTokenValidUntil": 1654744263
    }
}
```

--------------------------------

### Bitrix24 App Installation and Configuration for Albato

Source: https://wiki.albato.com/en/articles/9579758-bitrix24

This section details the steps and required parameters for manually installing and configuring the Albato application within Bitrix24, especially when the standard app is not available. It specifies the application name, API usage, required permissions, and the gateway URL.

```APIDOC
Bitrix24 Custom Application Setup:
  1. Go to the "Add Application" tab.
  2. In the "For personal use" block, click "Add".
  3. On the new page, configure the following:
     - Application name: [Your desired name]
     - Check option: "The application uses only API"
     - Permissions block (check boxes):
       - Tasks
       - CRM
       - Live Feed
       - Workgroups
       - Users
     - Specify URL field: https://albato.ru/settings/bitrix24/gateway
  4. Click "Save".
  5. Note the generated "Application code" and "Application key" for Albato connection.
```

--------------------------------

### Example Curl Request for Adding a User

Source: https://wiki.albato.com/en/articles/9263916-method-for-adding-a-user

A command-line example demonstrating how to make a POST request to the Albato user creation API endpoint using curl, including necessary headers for content type, acceptance, and authorization, along with a JSON data payload.

```curl
curl --header "Content-type: application/json" --header "Accept: application/json" --header "Authorization: Basic cEFJjGffUSkV6WFFyWUhBM1RzS2hRHg7iKgReghUiijBfrdTY6" --request POST --data '{"id":"test", "timezoneOffset": -180}' "https://api.albato.com/wl/partner-name/add-user"
```

--------------------------------

### Example JSON Response for Get Own Credential Metadata

Source: https://wiki.albato.com/en/articles/9264449-method-for-getting-metadata-of-a-connection-to-your-own-system

This JSON object illustrates a successful response from the `get-own-credential-metadata` endpoint. It shows the `success` status and the `data` object containing an array of `fields` with their `id`, `type`, `label`, and optionally `allowedValues` for defining connection parameters.

```json
{
    "success": true,
    "data": {
        "fields": [
            {
                "id": "userId",
                "type": 0,
                "label": "User ID"
            },
            {
                "id": "secretKey",
                "type": 3,
                "label": "Secret key"
            },
            {
                "id": "domain",
                "type": 10,
                "label": "Domain",
                "allowedValues": {
                    "zone1.partner.com": "East-1",
                    "zone2.partner.com": "West-1"
                }
            }
        ]
    }
}
```

--------------------------------

### Facebook Integration with Albato: Connection and Setup Requirements

Source: https://wiki.albato.com/en/articles/9573608-facebook

This section outlines the necessary steps and prerequisites for successfully connecting Facebook to Albato, focusing on account types, administrative rights, and Business Manager configurations. It also addresses common issues related to new lead form visibility.

```APIDOC
Connecting Facebook to Albato:
  - Requires a personal Facebook account.
  - Requires admin rights to the Facebook page containing lead forms.
  - These rights are essential regardless of the number of ad campaigns.

Access Rights for Facebook Integration:
  - Admin rights are mandatory for the page where the lead form is created.
  - The Facebook page must be linked within Facebook Business Manager (BM) with appropriate rights.

Troubleshooting New Facebook Lead Form Visibility:
  - Issue: New Facebook lead form does not appear in Albato.
  - Resolution Steps:
    1. Check Facebook business integration settings.
    2. Ensure all necessary pages are marked for integration.
    3. Refresh the data within Albato.
    4. If the issue persists, contact Albato support via online chat.

Related Setup Information:
  - For more details on setting up Facebook permissions, refer to: https://www.facebook.com/settings?tab=business_tools
```

--------------------------------

### Example JSON Response as Root Array

Source: https://wiki.albato.com/en/articles/9887836-response-section

This JSON snippet demonstrates a response where the primary data is directly an array at the root level. When parsing this format, the 'Return data array' option can be checked without specifying a path.

```JSON
[ {"name":"John", "phone":"+19681112233"}, {"name":"Peter", "phone":"+19681112244"} ]
```

--------------------------------

### Albato Partner API - Own System Credential Management

Source: https://wiki.albato.com/en/articles/9264461-method-for-getting-a-connection-to-your-own-system

This section details the API methods for managing connections (credentials) to a partner's own system within the Albato platform. It includes endpoints for retrieving existing connection details and for creating or updating connections.

```APIDOC
Method: GET OWN CREDENTIAL
  Endpoint: POST https://api.albato.com/wl/partner-name/get-own-credential
  Description: Allows requesting a connection to your system, validating connection credentials, or receiving a webhook.
  Authorization: Requires a user token (Bearer token).
  Request Parameters: None explicitly listed in the body for this method, but the response parameters indicate the structure of the connection data.
  Response Parameters:
    - success (boolean): Indicates if the request was successful. Values: true or false.
    - data (object): Parameters of the created/updated connection in a key-value format. Keys depend on the specific connection. Sensitive data (e.g., passwords, access tokens) are partially masked for security.

Method: UPSERT OWN CREDENTIAL (Implied from curl example)
  Endpoint: POST https://api.albato.com/wl/partner-name/upsert-own-credential
  Description: Used to create or update a connection to your own system. (Details on request body parameters are not explicitly provided in the text, but inferred from the context of 'upsert').
  Authorization: Requires a user token (Bearer token).
  Response Parameters: Expected to be similar to 'get-own-credential' with 'success' and 'data' fields.

Example Request (curl for upsert-own-credential):
  curl --header "Content-type: application/json" \
       --header "Accept: application/json" \
       --header "Authorization: Bearer eyJ0eXAiOiJKV.eyJpZGVudGl0eSI6OTczMzAsInRydWVJZGVudGl0eS..._GT8jc8Xby-3sidRPk" \
       "https://api.albato.com/wl/partner-name/upsert-own-credential"

Example Response (for successful operation):
  {
      "success": true,
      "data": {
          "title": "Default credential",
          "accessToken": "••570f",
          "userId": 87123,
          "webhookUrl": "https://h.albato.com/wh/17600/1lfrdco/POoHj252FUkB7c8K252FeofTqNzAaoK34ClaUUnrz6vx1Q5pJE/"
      }
  }
```

--------------------------------

### Example: Successful API Response for Adding Transactions

Source: https://wiki.albato.com/en/articles/9264188-method-for-adding-extra-transactions-to-a-user-billing-plan

Illustrates the expected JSON response from the Albato API after successfully adding transactions to a user's billing plan.

```json
{
    "success": true,
    "data": []
}
```

--------------------------------

### Set User Billing Plan via cURL

Source: https://wiki.albato.com/en/articles/9264181-method-for-setting-a-user-billing-plan

Example cURL command to set a user's billing plan using the Albato Partner API. This demonstrates how to include necessary headers for content type, accept, authorization, and the request body containing the user ID and plan ID.

```curl
curl --header "Content-type: application/json" --header "Accept: application/json" --header "Authorization: Basic cEFJjGffUSkV6WFFyWUhBM1RzS2hRHg7iKgReghUiijBfrdTY6" --data '{"id":"test", "planId": 23}' "https://api.albato.com/wl/partner-name/set-user-plan"
```

--------------------------------

### Example HTTP Header for Request Configuration

Source: https://wiki.albato.com/en/articles/9887836-response-section

This snippet shows a typical HTTP header format used to pass custom data, such as a `dateTimeEvent`. In Albato, this key (`dateTimeEvent`) would be specified on the left, and a target field on the right to store its value.

```HTTP Header
-H "dateTimeEvent: 2021-08-09 19:00:00"
```

--------------------------------

### Albato Partner API: Get Own Credential Metadata

Source: https://wiki.albato.com/en/articles/9264449-method-for-getting-metadata-of-a-connection-to-your-own-system

This API method allows partners to retrieve metadata about a connection to their own system. This metadata is crucial for configuring user authentication on the partner's platform. It requires either a user token or a master account token for authorization.

```APIDOC
Request: GET|POST https://api.albato.com/wl/partner-name/get-own-credential-metadata
Authorization: This method should be called either with the user token or the master account token.

Response Parameters:
- success (boolean): Request success indicator. Available values: true or false.
- data (object): Connection metadata, structured similarly to the Credentials section of the response for the "Method for getting metadata of available integrations".
  - data.fields (array of objects): List of credential fields.
    - id (string): Identifier for the field (e.g., "userId", "secretKey", "domain").
    - type (integer): Type of the field (e.g., 0, 3, 10).
    - label (string): Human-readable label for the field (e.g., "User ID", "Secret key", "Domain").
    - allowedValues (object, optional): For fields with predefined values, a map of value to label (e.g., {"zone1.partner.com": "East-1", "zone2.partner.com": "West-1"}).
```

--------------------------------

### Retrieve Available Billing Plans API

Source: https://wiki.albato.com/en/articles/9264154-method-for-getting-the-list-of-available-billing-plans

This API endpoint allows partners to retrieve a list of all available billing plans, each defining a monthly transaction limit. Authorization requires the partner's master account token.

```APIDOC
GET | POST https://api.albato.com/wl/partner-name/list-plans
  - Description: Retrieves a list of available billing plans, which define monthly transaction limits.
  - Authorization: Requires the partner's master account token.
  - Response Parameters:
    - success (boolean): Indicates if the request was successful (true) or not (false).
    - data (array of objects): An array containing details of available billing plans.
      - id (integer): The unique identifier of the billing plan.
      - monthlyTrx (integer): The monthly transaction limit associated with the billing plan.
```

```bash
curl --header "Content-type: application/json" --header "Accept: application/json" --header "Authorization: Basic cEFJjGffUSkV6WFFyWUhBM1RzS2hRHg7iKgReghUiijBfrdTY6" "https://api.albato.com/wl/partner-name/list-plans"
```

```json
{
    "success": true,
    "data": [
        {
            "id": 23,
            "monthlyTrx": 100000
        }
    ]
}
```

--------------------------------

### Telegram BotFather Commands for Bot Management and API Key Retrieval

Source: https://wiki.albato.com/en/articles/10079277-connecting-telegram-to-albato-integration-options

This section details the essential commands used with Telegram's @BotFather to manage existing bots, retrieve their API keys, or create new bots, which is a prerequisite for integrating Telegram bots with platforms like Albato. These commands facilitate the setup and authentication process.

```APIDOC
@BotFather Commands:

/start
  - Description: Initiates a conversation with BotFather.
  - Usage: Send this command in a chat with @BotFather to begin interaction.

/mybots
  - Description: Displays a list of all bots owned by the user and provides options to manage them, including retrieving their API keys.
  - Usage: Send this command to @BotFather. Select the desired bot from the list to access its settings and obtain the API key.

/newbot
  - Description: Guides the user through the process of creating a brand new Telegram bot.
  - Parameters:
    - Bot Name (public): A user-friendly name for your bot that will be publicly displayed.
    - Username (unique, ends with "bot"): A unique identifier for the bot, which must end with "bot" (e.g., yourNamebot or yourName_bot).
  - Usage: Send this command to @BotFather and follow the prompts to define the bot's public name and unique username. Upon successful creation, BotFather will provide the new bot's API key.
  - Returns: The API key (token) for the newly created bot, essential for connecting it to external services.
```

--------------------------------

### Example JSON Response for Parameter Mapping

Source: https://wiki.albato.com/en/articles/9887836-response-section

This JSON structure illustrates a common response format with a root `id` and a `data` array containing multiple objects. It's used to demonstrate how Albato's parameter mapping handles data within arrays, allowing individual fields like `name` and `phone` to be extracted from each array element while the `id` remains constant.

```JSON
{ "id": 12345, "data":[  {   "name":"John",   "phone":"+19681112233"  }  {   "name":"Jhon",   "phone":"+19681112244"  } ]}
```

--------------------------------

### Example: Add User Plan Transactions via cURL

Source: https://wiki.albato.com/en/articles/9264188-method-for-adding-extra-transactions-to-a-user-billing-plan

Demonstrates how to make a POST request to the Albato API endpoint to add transactions to a user's billing plan using cURL, including necessary headers and JSON payload.

```bash
curl --header "Content-type: application/json" --header "Accept: application/json" --header "Authorization: Basic cEFJjGffUSkV6WFFyWUhBM1RzS2hRHg7iKgReghUiijBfrdTY6" --data '{"id":"test", "count": 2000}' "https://api.albato.com/wl/partner-name/add-user-plan-transactions"
```

--------------------------------

### JSON Object Structures for Parameter Mapping

Source: https://wiki.albato.com/en/articles/9887834-request-section

These examples illustrate various JSON object structures used to explain how to map request body parameters in Albato. They cover simple key-value pairs, nested objects, arrays of objects, and arrays of strings, demonstrating the dot notation and array indexing for field mapping.

```JSON
{ "name":"John"}
```

```JSON
{ "contact":{  "name":"John"  }}
```

```JSON
{ "contacts":[  {   "name":"John"  },  {   "name":"Smith"  } ]}
```

```JSON
{ "tags":[  "tag",  "tag2",  "tag3" ]}
```

--------------------------------

### Example JSON Response with Nested Data Array

Source: https://wiki.albato.com/en/articles/9887836-response-section

This JSON snippet illustrates a common response structure where an array of objects is nested under a specific key, such as 'data'. This format requires specifying the path to the array for proper parsing.

```JSON
{ "data":[ {"name":"John", "phone":"+19681112233"}, {"name":"Peter", "phone":"+19681112244"} ]}
```

--------------------------------

### Albato API: Get User Profile

Source: https://wiki.albato.com/en/articles/9264133-method-for-getting-a-user-profile

This API method allows partners to retrieve the profile details of an existing user within the Albato platform. It requires authorization using the partner's master account token and provides details such as email, language, timezone, and billing plan information.

```APIDOC
Method: GET User Profile
Endpoint: POST https://api.albato.com/wl/partner-name/get-user-profile
Authorization: Partner's master account token (Basic authentication)

Request Parameters:
- id (string, required): An alphanumeric user ID that the partner passes when creating a new user.

Response Parameters:
- success (boolean): Request success indicator. Available values: true or false.
- data.id (integer): An existing user's ID (in Albato).
- data.email (string): An existing user's email.
- data.language (string): An existing user's interface language.
- data.timezoneOffset (integer): An existing user's time zone offset in minutes.
- data.planId (string, optional): An existing user's plan ID; it only returns a value if there are user billing plans set by the partner.
- data.trxLimit (integer, optional): User transaction limit left; it only returns a value if there are user billing plans set by the partner.

Response Example:
{
    "success": true,
    "data": {
        "id": 1357,
        "email": "test@example.com",
        "language": "pt",
        "timezoneOffset": -180
    }
}
```

```bash
curl --header "Content-type: application/json" --header "Accept: application/json" --header "Authorization: Basic cEFJjGffUSkV6WFFyWUhBM1RzS2hRHg7iKgReghUiijBfrdTY6" --request POST --data '{"id":"test"}' "https://api.albato.com/wl/partner-name/get-user-profile"
```

--------------------------------

### Albato Rows Union Tool Functionality and Usage

Source: https://wiki.albato.com/en/articles/9024335-rows-union

Describes the purpose, functionality, and step-by-step usage of the 'Rows union' tool within the Albato automation platform, including an integration example.

```APIDOC
Albato Rows Union Tool:
  Purpose:
    - Allows combining arrays of objects (rows) from one automation step with values from another step.
    - Expands possibilities for working with data when rows exist in multiple stages and need to be joined in a subsequent stage.
  Functionality:
    - Associates data from a source trigger (e.g., AliExpress order items) with data from a subsequent action (e.g., MoySklad product search results).
    - Enables transferring combined data, such as product quantity from the source and product UUID from the target, to a final step (e.g., creating an order).
  Usage:
    - Step 1: Add the tool after the steps that contain the 'rows' you need to match.
    - Step 2: Click on the '+' icon in your automation flow.
    - Step 3: Select 'Tool' from the options.
    - Step 4: Choose 'Rows union' from the list of available tools.
  Example Scenario (AliExpress – MoySklad Integration):
    - Problem: AliExpress provides product ID/SKU, MoySklad requires internal UUID for order items.
    - Solution: Use 'Rows union' to combine AliExpress order item data (quantity) with MoySklad product data (UUID) obtained from a product search action (e.g., finding products by SKU).
    - Outcome: Create a MoySklad 'Buyer's Order' document with correct product quantities from AliExpress and corresponding MoySklad product UUIDs.
```

--------------------------------

### cURL Example: Refresh Albato User Session Token

Source: https://wiki.albato.com/en/articles/9264147-method-for-refreshing-a-user-token

Illustrates how to make a POST request to the Albato API's `get-user-session-token` endpoint using cURL. This example includes setting content type and accept headers, providing basic authorization, and sending a JSON payload with the user's email.

```bash
curl --header "Content-type: application/json" --header "Accept: application/json" --header "Authorization: Basic cEFJjGffUSkV6WFFyWUhBM1RzS2hRHg7iKgReghUiijBfrdTY6" --request POST --data '{"email":"test@example.com"}' "https://api.albato.com/wl/partner-name/get-user-session-token"
```

--------------------------------

### Albato Partner API: Block User Plan

Source: https://wiki.albato.com/en/articles/9264197-method-for-blocking-a-user

Documents the API endpoint for blocking an existing user's billing plan within the Albato platform. This action pauses all user integrations and prevents new ones from being started. Requires partner's master account token for authorization.

```APIDOC
Method: POST https://api.albato.com/wl/partner-name/block-user-plan

Authorization: This method should be called with the partner's master account token (Basic Authentication).

Request Parameters:
- id (string, required): An alphanumeric user ID that the partner passes when creating a new user.

Response Parameters:
- success (boolean): Request success indicator. Available values: true or false.
- data (array): An empty array in case of success.
```

```bash
curl --header "Content-type: application/json" --header "Accept: application/json" --header "Authorization: Basic cEFJjGffUSkV6WFFyWUhBM1RzS2hRHg7iKgReghUiijBfrdTY6" --data '{"id":"test"}' "https://api.albato.com/wl/partner-name/block-user-plan"
```

```json
{
    "success": true,
    "data": []
}
```

--------------------------------

### Albato Authorization Templates Overview

Source: https://wiki.albato.com/en/articles/9887964-introduction-to-the-authorization-section

This documentation outlines the five distinct authorization templates available in Albato, detailing their characteristics, field creation, request handling, and specific header formats for integration.

```APIDOC
Authorization Templates:

1. oAuth 2.0
   - Description: A distinct authorization type with its own additional settings on step 1.
   - Fields Created: Access token, Refresh token.
   - Requests: Created for receiving and updating tokens.

2. Basic Authorization
   - Description: Standard basic authorization.
   - Fields Created: Login, Password.
   - Requests: No requests created.
   - Header Format: Authorization: Basic {{base64string}}
   - Encoding Rule: The base64string is derived from encoding 'login:password'.

3. API Token Authorization
   - Description: Authorization using a static API token.
   - Fields Created: One API key field.
   - Requests: No requests created.
   - Header Format: Authorization: Bearer {{apiKey}}

4. Session Authentication
   - Description: Similar to API token, but includes an additional uneditable 'access_token' field and a request to exchange initial data (e.g., Login/password or static API key) for a final API access token.
   - Workflow: Make a request with editable fields, receive and save authorization parameters to non-editable fields, then use these in the request sending template on step 4.

5. Custom Template
   - Description: An empty template that creates nothing. It is used when the required set of fields is highly custom, making it easier to build the authorization from scratch.
```

--------------------------------

### Bitrix24 Application Access and Connection Configuration

Source: https://wiki.albato.com/en/articles/10079197-connecting-bitrix24-to-albato-via-the-app

This section outlines the methods to access the Albato application within Bitrix24 and the required parameters for setting up the connection in Albato. It covers direct URL access and the fields necessary for successful integration.

```APIDOC
Bitrix24 Application Access:
  Path: /marketplace/detail/albato.connector/
    Description: Direct URL path to access the Albato application details within the Bitrix24 marketplace.

Albato Connection Fields for Bitrix24:
  Name:
    Description: A user-defined name for the connection, for personal identification within Albato.
    Type: String
    Constraints: User-defined
  Domain:
    Description: The domain of your Bitrix24 instance, copied directly from the browser's address bar when on a Bitrix24 page.
    Type: String
    Constraints: Valid Bitrix24 domain URL
  Phone format:
    Description: Specifies the desired phone number format for data transfer to Bitrix24.
    Type: Enum (e.g., International, Local)
    Constraints: Selectable options within Albato
  Application ID:
    Description: (Optional) Required only for alternative connection methods where you add your Albato app in Bitrix24 manually. Skip if using the standard Albato app installation.
    Type: String
    Constraints: Alphanumeric
  Application key:
    Description: (Optional) Required only for alternative connection methods where you add your Albato app in Bitrix24 manually. Skip if using the standard Albato app installation.
    Type: String
    Constraints: Alphanumeric
```

--------------------------------

### Albato Requests Widget Configuration and Functionality

Source: https://wiki.albato.com/en/articles/9887826-introduction-to-the-requests-widget

This documentation outlines the configuration and functionality of the Albato Requests Widget, a core module for customizing HTTP requests within entities. It covers the Request, Response, and Errors tabs, detailing how each tab contributes to defining the behavior of an HTTP request, from sending data to processing responses and handling potential errors.

```APIDOC
Albato Requests Widget:
  Description: A core builder module for customizing HTTP requests within entities. It allows for an unlimited number of widgets per entity, enabling complex sequences of requests.

  Components:
    1. Request Tab:
      Purpose: Configures outgoing HTTP requests.
      Parameters:
        - URL: The endpoint where the request is sent.
        - Request Method: HTTP method (e.g., GET, POST, PUT, DELETE).
        - Content Type: Specifies the format of the request body (e.g., application/json, application/x-www-form-urlencoded).
        - Authorization: Links to defined authorization settings.
        - Headers: Custom HTTP headers to be included in the request.
        - Parameters (Request Body): Data sent in the request body.
      Usage: Used to define how Albato sends data to an external system.

    2. Response Tab:
      Purpose: Sets up the parser for the HTTP response received from the request.
      Functionality:
        - Data Extraction: Used to extract specific data points from the response, such as an entity ID after creation or fields from a search result.
        - Primary Role in Triggers: This is the main tab for configuring how triggers process incoming data.
      Usage: Essential for processing and utilizing data returned by external APIs.

    3. Errors Tab:
      Purpose: Configures error handling for the HTTP request.
      Functionality:
        - Error Matching: Defines conditions (filters) based on response data that indicate an erroneous transaction in Albato.
        - Error Message Mapping: Allows mapping a variable to display an error text from the API system's response in the bundle log if an error occurs.
      Usage: Ensures robust error management and provides clear feedback in case of failed transactions.

  Dynamic Values:
    - The widget supports both static values and dynamic variables (e.g., from Trigger, Action, or Authorization data).
    - Dynamic variables are populated at runtime based on user-filled fields.
    - Field selection is done via a 'Smart field' block, displaying fields created within the entity.
```

--------------------------------

### HTTP Request Connection and Automation Configuration

Source: https://wiki.albato.com/en/articles/9024290-how-to-work-with-http-requests

This section details the parameters required for setting up an HTTP Request connection within the Albato platform, covering both the initial connection creation and subsequent automation configurations. It outlines essential fields such as URLs, request methods, headers, and body parameters for flexible data transfer.

```APIDOC
HTTP Request Connection Fields (App-level Configuration):
  - Name: string
    Description: A user-defined name for the connection.
  - URL: string
    Description: The domain of the target CRM or receiving system.
  - HTTP request parameters (request body): object
    Description: Parameters that vary depending on the specific action to be performed (e.g., add a car, find by VIN, create a contact). The structure and required fields should match the object expected by the receiving function. A complete list of actions and fields can be obtained from the receiving system's documentation.
  - Headers: object
    Description: HTTP headers to be sent with the request.
    - Authorization: string
      Description: Specify the Authorization parameter.
  - Content-Type: string
    Description: The content type of the request body. Recommended value: 'JSON'.

HTTP Request Automation Fields (Automation-level Configuration):
  - URL: string
    Description: Leave this field empty. The URL specified in the App-level connection will be used.
  - Request method: string
    Description: The HTTP method for the request. Recommended value: 'POST'.
  - User-Agent header: string
    Description: The User-Agent string to identify the client. Recommended value: 'Mozilla/5.0 (compatible; Albato/1.0)'.
  - Authorization (header): string
    Description: The Authorization header value. For Basic authentication, it is the result of encoding the string 'login:password' with the MIME base64 algorithm.
    Example: For login 'admin' and password 'password', the value would be 'YWRtaW46cGFzc3dvcmQ='.
  - Parameters: object
    Description: Specific parameters to transfer via the HTTP Request, which will form the request body or query parameters. These typically include fields like 'last_name', 'first_name', 'phone', 'email', 'dealer_code', 'request_type_id', 'source_id', etc. Fill in the parameters relevant to your data transfer needs.
```

--------------------------------

### Valuecase Albato Connector API Reference

Source: https://wiki.albato.com/en/articles/10774536-how-to-connect-valuecase-to-albato

This section details the available triggers and actions for integrating Valuecase with Albato, enabling real-time data transfer and automation between the platforms.

```APIDOC
Triggers:
  - New Space:
    Description: Triggers an automation when a new space is created in Valuecase.
    Execution: Real-time; data is transferred the moment the event occurs.

Actions:
  - Create Space:
    Description: Creates a new space within Valuecase.
  - Add External ID to Space:
    Description: Assigns an external identifier to an existing Valuecase space.
  - Archive Space:
    Description: Archives a specified space in Valuecase.
  - Get Space by Slug:
    Description: Retrieves a Valuecase space using its slug identifier.
  - Return All Custom Properties of Space:
    Description: Fetches all custom properties associated with a Valuecase space.
  - Return Spaces by External ID:
    Description: Retrieves Valuecase spaces based on their external identifiers.
  - Custom API Request:
    Description: Allows execution of custom API requests against Valuecase.
  - Update Custom Space Field:
    Description: Updates a specific custom field for a Valuecase space.
```

--------------------------------

### Albato OpenAI Image Generation Action

Source: https://wiki.albato.com/en/articles/9652120-openai

This describes the specific action available within the Albato automation builder for generating images using OpenAI's capabilities. It's the initial step in creating an image.

```APIDOC
Albato Action: Image Generation for OpenAI
  Purpose: To generate images by leveraging OpenAI's API through the Albato platform.
  Usage: Select this action within the Albato automation builder to configure image creation parameters (e.g., prompt, size, number of images).
```

--------------------------------

### Albato API General Information and Authorization

Source: https://wiki.albato.com/en/articles/9263913-api-general-information-and-authorization

This section details the foundational aspects of interacting with the Albato API, including its endpoint, data format, necessary request headers, and the authentication mechanism. It also clarifies how error responses are structured and the handling of the 'partner-name' placeholder.

```APIDOC
Albato API Base URL:
  https://api.albato.com/

Data Exchange Format:
  JSON

Required HTTP Headers:
  Content-type: application/JSON
  Accept: application/JSON

Authorization Method:
  Type: Basic Authorization
  Username: Your master account's permanent token
  Password: (empty)

Error Response Structure:
  If an error occurs, the response will include:
    - A Boolean status indicator
    - A detailed error description

Partner Name Handling:
  The 'partner-name' placeholder in method requests will be automatically replaced with the actual partner name (your company/contract name).
```

--------------------------------

### Configure RD Station Marketing Webhook for Albato Integration

Source: https://wiki.albato.com/en/articles/10079223-how-to-connect-rd-station-marketing-to-albato

This API documentation describes the parameters required to set up a webhook in RD Station Marketing to send lead information to Albato. It covers naming the integration, providing the Albato webhook URL, and defining the trigger conditions for sending data, such as lead conversions or opportunity status changes.

```APIDOC
Webhook Configuration Parameters:

Name: string
  - Description: A descriptive name for your integration, ideally identifying the tool this information will be sent to (e.g., 'Albato').

URL: string (URL)
  - Description: The webhook URL generated on Albato, which will receive the data.

Trigger: enum (Conversion, Opportunity)
  - Description: Specifies the event that will activate the notification sending.
  - Options:
    - Conversion:
      - Description: Sends Leads that have performed a conversion in RD Station Marketing.
      - Parameters:
        - conversions_to_track: array of strings (optional)
          - Description: Select specific conversions to track. If left blank, any lead performing a conversion will be sent.
    - Opportunity:
      - Description: Sends Leads marked as Opportunity (starred).
      - Usage: For example, send the Lead from RD Station Marketing to the tool only when manually marked as an opportunity or by an automation flow.

Actions:
  - Save Webhook: Button to save the configuration.
  - Verify: Button to check if the integration with the webhook is working after saving.
```

--------------------------------

### JSON Structure for ObjectArray Type

Source: https://wiki.albato.com/en/articles/9887834-request-section

This JSON example illustrates the structure generated when using the ObjectArray variable type in a request. It shows an array named 'items' containing multiple objects, each with 'name' and 'quantity' fields. This structure is used for sending structured data, where the parent field's mapping key (e.g., 'items') holds the array.

```json
{ "items":[  {   "name":"Item 1",   "quantity":1  },  {   "name":"Item 2",   "quantity":3  } ]}
```

--------------------------------

### JSON Error Response Structure Example

Source: https://wiki.albato.com/en/articles/9887848-errors-section

Illustrates a typical JSON structure for an error response, containing a 'status' field indicating 'error' and a 'reason' field with a descriptive message. This structure is used in Albato for configuring error detection and message mapping, allowing the system to identify and process errors based on the response content.

```json
{ "status":"error", "reason":"Error occur..."}
```

--------------------------------

### Albato User Session Management API

Source: https://wiki.albato.com/en/articles/10300885-implementation-guide-for-albato-embedded

This API documentation describes the endpoints and expected behaviors for managing user sessions with Albato, including creating new users and refreshing session tokens for existing ones. It details the inputs, possible outcomes, and subsequent actions required for successful iFrame integration.

```APIDOC
Albato User Session Management API:

1. Create a User
   - Action: Call the Albato endpoint to add a new user.
   - Inputs:
     - `user_id` (string, required): Your internal customer ID. This can be any unique identifier (e.g., customer ID, organization ID, workspace ID) used to match your customers to integration users in Albato.
     - `time_zone` (string, optional): The user's time zone.
     - `language` (string, optional): The user's preferred language.
   - Responses:
     - `HTTP 200 OK`:
       - Description: The user did not exist and has been successfully created in Albato.
       - Returns: A JSON object containing a unique `session_token` (string) for the new user.
       - Post-action: Save the returned `session_token`. Use this token to pass the user's credential data to Albato using the SSO method (as described in Step 3 of the integration process).
     - `HTTP 400 Bad Request`:
       - Description: The user already exists in Albato.
       - Post-action: Do not proceed with SSO. Instead, call the "Refresh User Token" endpoint to obtain a new session token for the existing user.

2. Refresh User Token
   - Action: Call the Albato endpoint to get a new session token for an existing user.
   - Context: This endpoint is typically called when the "Create a User" endpoint returns an `HTTP 400` status, indicating the user already exists.
   - Inputs: (Specific parameters for this endpoint are not detailed in this document; refer to Albato's external documentation for full signature, likely involves a user identifier).
   - Returns: (Implicitly, a new `session_token` for the existing user, similar to the 200 OK response from "Create a User").
   - Post-action: Use the newly retrieved `session_token` to display the Albato iFrame.
```

--------------------------------

### Facebook Integration with Albato: Data Flow and Testing FAQs

Source: https://wiki.albato.com/en/articles/9573608-facebook

This section addresses frequently asked questions concerning data synchronization from Facebook to Albato, including reasons for missing data, discrepancies in test leads, and visibility of campaign-related information. It provides insights into Facebook's data retention policies and testing limitations.

```APIDOC
Why isn’t data coming from Facebook to Albato?
  - Common Reasons:
    1. Lack of admin rights to the page with lead forms.
    2. Incorrect Facebook account connected to Albato.
    3. The lead form has been archived on Facebook.
  - Note: Lead data is stored on Facebook for a maximum of 3 months.

Why do test leads come through but not real ones?
  - Possible Causes:
    1. Insufficient admin rights to the Facebook page.
    2. Incorrect settings within Facebook Business Manager.
  - Action: Verify that the page with lead forms is correctly linked to BM and all necessary rights are granted.

Why don’t test leads show up in Albato?
  - If automation is API-based, Albato requests data from Facebook every five minutes.
  - It's possible the polling interval has not elapsed since the test lead was sent.

Why are test lead data incorrect (e.g., <bkb-test-name>)?
  - This is normal behavior for test leads generated from Facebook.

Why don’t campaign names, ad group names, and ad names appear in the request?
  - These data points are configured within Facebook Business Manager.
  - Action: Check the settings in your advertising account.

How to test a Facebook lead form?
  - A detailed guide is available in Albato's article: https://albato.com/blog/publications/facebook-test-tool

Why don’t tests from the form preview come through?
  - Facebook imposes a limit of one test per form.

Why don’t campaign names, ad group names, and ad names appear in the request with a real lead?
  - Action: Check access rights and settings in Business Manager to ensure all necessary parameters are correctly set.
```

--------------------------------

### Hotmart Integration Triggers for Albato

Source: https://wiki.albato.com/en/articles/10516316-how-to-connect-hotmart-to-albato

This section lists the available triggers that can initiate automation workflows in Albato when an event occurs in Hotmart. These triggers allow for data transfer related to purchases, subscriptions, and cart abandonment without requiring coding.

```APIDOC
Hotmart Integration Triggers:

These triggers initiate automation workflows in Albato based on events occurring in Hotmart. When one of these actions takes place, associated data is sent to Albato, becoming available for use with other integrated applications.

- Expired purchase
- Canceled purchase
- Chargeback for the purchase
- Purchase refund request
- Refunded purchase
- Approved purchase
- Completed purchase
- Subscription cancellation
- Plan change event
- Cart abandonment
```

--------------------------------

### WooCommerce Integration Capabilities in Albato

Source: https://wiki.albato.com/en/articles/10779109-how-to-connect-woocommerce-to-albato

This section outlines the events (triggers) that can initiate automation and the operations (actions) that Albato can perform when integrated with WooCommerce. Triggers run in real-time, and actions facilitate data transfer between systems.

```APIDOC
WooCommerce Integration Capabilities:

Available Triggers (real-time events):
- New order
- The order is changed
- New coupon
- Coupon updated
- New customer
- Customer updated

Available Actions (operations Albato performs):
- Create product tag
- Update product tag
- Delete product tag
- Add a product category
- Update a product category
- Delete a product category
- Create a product
- Retrieve a product
- Search product tag
- Get product category
- Update product data
- Create a product attribute
- Retrieve a product attribute
- Update a product attribute
- Delete product attribute
```

--------------------------------

### Albato Partner API: Add User Method Definition

Source: https://wiki.albato.com/en/articles/9263916-method-for-adding-a-user

Defines the API endpoint, authorization requirements, request parameters, and response parameters for creating a new user in Albato via the partner's master account. This method allows partners to register users and manage their integration settings.

```APIDOC
Endpoint:
  POST https://api.albato.com/wl/partner-name/add-user

Authorization:
  This method should be called with the partner's master account token.

Request Parameters:
  - id (string, required): An alphanumeric user ID that the partner passes when creating a new user. The ID must be unique for each partner's user.
  - language (string, optional): User interface language. Available values: en, pt, es (English, Portuguese, and Spanish). Default: en (can be set in partner account).
  - timezoneOffset (integer, optional): The user's timezone defined in minutes relative to UTC. Default: (can be set in partner account).

Response Parameters:
  - success (boolean): Request success indicator. Values: true or false.
  - data.id (integer): The created user's ID (in Albato).
  - data.email (string): The created user's email.
  - data.language (string): The created user's interface language.
  - data.timezoneOffset (integer): The created user's time zone.
  - data.permanentToken (string, optional): A permanent API token for the created user; returns a value only if permanent tokens are enabled in partner account settings.
  - data.sessionToken (string, optional): A temporary API token for the created user; returns a value only if temporary tokens are enabled in partner account settings.
  - data.sessionTokenValidUntil (integer, optional): The API token expiration period (unix timestamp) for the created user; returns a value only if temporary tokens are enabled in partner account settings.
  - data.planId (integer, optional): The created user's plan ID; returns a value only if user billing plans are set by the partner.
  - data.trxLimit (integer, optional): The created user's transaction limit; returns a value only if user billing plans are set by the partner.
```

--------------------------------

### Dynamically Resize Albato iFrame with iframe-resizer.js

Source: https://wiki.albato.com/en/articles/9264467-embedding-albato-via-an-iframe

This JavaScript snippet integrates the 'iframe-resizer' library to dynamically adjust the height of the Albato iFrame. It first includes the library script from a CDN and then initializes it for the iFrame with the ID 'albato', enabling public methods and using 'lowestElement' for height calculation. This script should be placed before the closing </body> tag.

```JavaScript
<script src="https://cdnjs.cloudflare.com/ajax/libs/iframe-resizer/4.3.2/iframeResizer.min.js"></script>
<script>
    iFrameResize({enablePublicMethods: true, heightCalculationMethod: 'lowestElement'}, '#albato')
</script>
```

--------------------------------

### Blastable API Integration with Albato: Triggers and Actions

Source: https://wiki.albato.com/en/articles/11046498-how-to-connect-blastable-to-albato

This section details the comprehensive set of API capabilities available for integrating Blastable with Albato. It covers events that can initiate automations (triggers) and the operations that can be performed within Blastable via Albato (actions), enabling robust workflow automation for email marketing.

```APIDOC
Available Triggers:
  - New Subscriber:
      Description: Event that starts an automation when a new subscriber is added to Blastable.
  - Subscriber Status Change:
      Description: Event that starts an automation when a subscriber's status changes within Blastable.

Available Actions:
  - Create Subscriber:
      Description: Adds a new subscriber to Blastable.
  - Custom API Request:
      Description: Allows execution of custom API calls to Blastable for operations not explicitly listed.
  - Update Subscriber Profile:
      Description: Modifies the profile details of an existing subscriber in Blastable.
  - Unsubscribe by Email in All Lists:
      Description: Removes a specified subscriber from all mailing lists they are part of in Blastable.
  - Unsubscribe a Subscriber from a List:
      Description: Removes a specified subscriber from a particular mailing list in Blastable.
  - Search Subscriber:
      Description: Retrieves information about a subscriber based on specified criteria.
  - Create Group:
      Description: Creates a new subscriber group in Blastable.
  - Create Tag:
      Description: Creates a new tag in Blastable.
  - Update Tag:
      Description: Modifies an existing tag in Blastable.
  - Delete Tag:
      Description: Removes a tag from Blastable.
  - Add Tag to Subscribers:
      Description: Assigns an existing tag to one or more subscribers.
  - Move Subscriber to Another List:
      Description: Transfers a subscriber from their current list to a different specified list.
```

--------------------------------

### Albato Integration for Sending Files to Google Drive

Source: https://wiki.albato.com/en/articles/9652120-openai

This outlines the final step in the workflow, where the downloaded image is sent to a third-party application, specifically Google Drive, for storage or further processing. This demonstrates Albato's ability to connect various services.

```APIDOC
Albato Integration: Send to Google Drive
  Purpose: To upload a file (e.g., a downloaded image) to a specified folder within Google Drive.
  Input: The file content obtained from the 'HTTP request/outgoing webhook' action.
  Usage: After downloading the image, connect this action to send the image file to your desired Google Drive location. This requires prior connection of your Google Drive account to Albato.
```
Tokens:
Raw