RTILA

https://rtila.com/docs/
Admin
RTILA is a web business automation platform that automates keyboard and mouse actions on web pages...
Tokens:58,974
Snippets:633
Trust Score:8
Update:8 months ago
Show doc for...
Tokens:
Raw
### Example Pagination: Page 3, 50 Items per Page (curl)

Source: https://rtila.com/docs/v8-api-results-endpoint

Illustrates how to use the `perPage` and `page` query parameters to implement pagination. This example requests the third page of results, with 50 items displayed per page.

```curl
curl -X GET "http://127.0.0.1:8880/api/results?filter=(sessionId='ilh2f81bq46wedu')&perPage=50&page=3" \
  -H "Authorization: Bearer YOUR_SYSTEM_AUTH_TOKEN"
```

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

### Example Sorting: Newest Records First (curl)

Source: https://rtila.com/docs/v8-api-results-endpoint

Shows how to use the `sort` query parameter to order results. This example sorts the results in descending order based on the 'created' field, effectively retrieving the newest records first.

```curl
curl -X GET "http://127.0.0.1:8880/api/results?filter=(sessionId='ilh2f81bq46wedu')&sort=-created" \
  -H "Authorization: Bearer YOUR_SYSTEM_AUTH_TOKEN"
```

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

### Retrieve Results with Filter, Pagination, and Sorting (curl)

Source: https://rtila.com/docs/v8-api-results-endpoint

Example demonstrating how to combine filter, pagination, and sorting parameters in a single GET request to the V8 API Results endpoint. This example filters by sessionId and dataset, sorts by price in descending order, and limits the results to 10 items per page.

```curl
curl -X GET "https://YOUR_PUBLIC_RTILA_HOST/api/results?filter=(sessionId='ilh2f81bq46wedu' && dataset='BookData' && Price > '50.00')&sort=-Price&perPage=10&page=1" \
  -H "Authorization: Bearer YOUR_SYSTEM_AUTH_TOKEN"
```

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

### Install and Use NodeJS 'clipboardy' Package in RTILA

Source: https://rtila.com/docs/custom-commands

This code snippet shows how to install the 'clipboardy' NodeJS package using RTILA's manager, then require and use its functions for copying, pasting, or clearing the system clipboard. It handles different modes ('copy', 'paste', 'reset') based on command input.

```javascript
await manager.install("clipboardy", "^2.3.0");
const clipboardy = manager.require("clipboardy");

commandValues = command.inputValue;

switch (command.selectMode) {
  case 'copy':
    commandValues = command.inputValue;
    clipboardy.writeSync(commandValues);
    break;
  case 'paste':
    commandValues = clipboardy.readSync();
    break;
  case 'reset':
    clipboardy.writeSync("");
    break;
}
```

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

### Advanced: Click Shadow DOM Element and Get New Tab URL in JavaScript

Source: https://rtila.com/docs/dynamic-variables-javascript-code

An advanced example demonstrating how to interact with elements within a Shadow DOM, click a button that opens a new tab, and then retrieve the URL of that new tab. It includes error handling and manages the `window.open` behavior.

```javascript
const delay = ms => new Promise(res => setTimeout(res, ms));
const host = document.querySelector('li:nth-of-type(1) svelte-component[type="ProfileCard"]');
if (!host) throw new Error("ProfileCard host not found.");
const shadowRoot = host.shadowRoot;
if (!shadowRoot) throw new Error("Shadow root not accessible.");
const linkedinButton = shadowRoot.querySelector('button[data-testid="social-button"] i.fa-linkedin-in');
if (!linkedinButton) throw new Error("LinkedIn button not found.");
const button = linkedinButton.closest('button');
if (!button) throw new Error("Button wrapper not found.");
let newTab = null;
const originalOpen = window.open;
window.open = function (...args) {
  newTab = originalOpen.apply(this, args);
  return newTab;
};
button.click();
await delay(5000);
window.open = originalOpen;
let finalUrl = 'cross-origin-or-unknown';
try {
  if (newTab && newTab.location && newTab.location.href) {
    finalUrl = newTab.location.href;
  }
} catch (e) {
  finalUrl = 'cross-origin-or-unknown';
}
newTab.close();
VALUE = finalUrl;
console.log("VALUE:", VALUE);
```

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

### Advanced Rtila API Usage Example with cURL

Source: https://rtila.com/docs/v8-api-remote-execution

This example demonstrates how to make a POST request to the Rtila remote API for advanced scraping tasks. It includes settings for headless browsing, concurrent workers, proxy configuration, resource blocking, and user agent spoofing.

```bash
curl -X POST "https://YOUR_PUBLIC_RTILA_HOST/api/remote" \
  -H "Authorization: Bearer YOUR_SYSTEM_AUTH_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "YOUR_PROJECT_API_KEY",
    "settings": {
      "urls": [
        "https://books.toscrape.com/catalogue/sapiens-a-brief-history-of-humankind_996/index.html"
      ],
      "headless": true,
      "max_concurrent_workers": 3,
      "proxy": {
        "enabled": true,
        "addresses": [
          "http://your_proxy_user:your_proxy_pass@proxy.server.com:8080"
        ]
      },
      "block_resources": {
        "enabled": true,
        "types": ["image", "font"]
      },
      "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36"
    },
    "variables": {
      "source_system": "external_api_call"
    }
  }'
```

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

### Example Response for Extracted Results (JSON)

Source: https://rtila.com/docs/rtila-cloud-api-documentation

This is an example JSON response received when querying for extracted results from a completed RTILA Cloud API run. It includes the completion timestamp and a list of datasets, each containing its name and the extracted data.

```json
{
 "completedAt": "Fri Aug 11 2023 09:20:10 GMT+0000 (Coordinated Universal Time)",
 "datasets": [
 {
 "name": "Dataset-#1_1691671374161_1691745608512_output.json",
 "data": [
 {
 "My Variable": "Hello world",
 "projectId": 533,
 "datasetId": 1691745608512
 }
 ]
 }
 ]
 }
 
```

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

### Response Structure Example (JSON)

Source: https://rtila.com/docs/v8-api-results-endpoint

An example of the JSON response structure returned by the V8 API Results endpoint. It includes an 'items' array containing the result records, along with pagination metadata like 'page', 'perPage', 'totalItems', and 'totalPages'.

```json
{
  "items": [
    {
      "Title": "Tipping the Velvet",
      "Price": "£53.74",
      "Image_url": "https://books.toscrape.com/media/cache/26/0c/260c6ae16bce31c8f8c95daddd9f4a1c.jpg",
      "id": "record-id",
      "collectionId": "collection-id"
      /* additional metadata fields may be present */
    }
  ],
  "page": 1,
  "perPage": 30,
  "totalItems": 1,
  "totalPages": 1
}
```

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

### Chat Completions Response Format Example

Source: https://rtila.com/docs/chatgpt-api-full-control

This JSON object demonstrates the structure of the complete response received from OpenAI's Chat Completions API. It includes details about choices, creation timestamp, ID, model used, object type, and token usage.

```json
{
  "choices": [
    {
      "finish_reason": "stop",
      "index": 0,
      "message": {
        "content": "The history of the internet dates back to the 1960s when the US Department of Defense developed the ARPANET",
        "role": "assistant"
      },
      "logprobs": null
    }
  ],
  "created": 1677664795,
  "id": "chatcmpl-7QyqpwdfhqwajicIEznoc6Q47XAyW",
  "model": "gpt-3.5-turbo-0613",
  "object": "chat.completion",
  "usage": {
    "completion_tokens": 17,
    "prompt_tokens": 57,
    "total_tokens": 74
  }
}
```

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

### Action Command JavaScript Example

Source: https://rtila.com/docs/custom-commands

This JavaScript code demonstrates how to fetch data from an external API and display it as an alert within the RTILA page. It utilizes the 'page' and 'command' global variables provided by the RTILA environment. Ensure the API endpoint is accessible and returns valid JSON.

```javascript
// Available global varibales:
// page
// command

const response=await fetch('https://jsonplaceholder.typicode.com/todos/1');
const json=await response.json();

await page.evaluate(function (json) {
  return alert(JSON.stringify(json));
}, json);
```

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

### Launch Bots with Arguments using Bot Launcher

Source: https://rtila.com/docs/trigger-standalone-bots-via-command-lines

This command-line interface allows you to launch standalone RTILA bots. You can specify the configuration or bot file and pass custom variables to the bot's execution. Ensure the Bot Launcher is installed and the specified bot file exists.

```bash
Bot-Launcher.exe --config-file=automation1.bot --myvar=testdata
or
Bot-Launcher.exe --bot-file=automation1.bot --myvar=testdata
```

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

### Action Command Configuration JSON Example

Source: https://rtila.com/docs/custom-commands

This JSON file defines the configuration for an 'action' type Custom Command in RTILA. It specifies the command's role, type, label, description, default values, and the input fields users can configure. The 'fields' array describes the UI elements for user input.

```json
{
  "role": "action", 
  "type": "test-action-addon",
  "label": "Action Addon",
  "description": "Test Action Addon Description",
  "defaultValues": {
    "testText": "My default message",
  },
  "fields": [
    {
      "type": "text",
      "name": "testText",
      "label": "Test Text",
      "description": "Test Text Description."
    }
  ]
}
```

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

### Upload Project & Get Project UUID

Source: https://rtila.com/docs/rtila-cloud-api-documentation-updated

Upload your Automation project to the secure Cloud and obtain the associated Project unique ID. This is the first step before running a project.

```APIDOC
## Upload Project & get Project uuid #

The first step is to upload your Automation project to the our secure Cloud and obtain the associated Project unique ID
For your concerned project click on the Hamburger menu for “more options”
Then click on get UUID
The wait for few seconds for the Project to upload to the Cloud and the resulting Project uuid will be displayed like this:

```

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

### Example Filter by Session and Title (curl)

Source: https://rtila.com/docs/v8-api-results-endpoint

Demonstrates how to use the `filter` query parameter to retrieve results for a specific session ID and title. This is a common use case for narrowing down results to a particular execution run and dataset.

```curl
curl -X GET "http://127.0.0.1:8880/api/results?filter=(sessionId='ilh2f81bq46wedu' && Title='A Light in the Attic')" \
  -H "Authorization: Bearer YOUR_SYSTEM_AUTH_TOKEN"
```

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

### POST /api/remote - Trigger Project Execution

Source: https://rtila.com/docs/v8-api-overview

Starts a new remote execution of a project configured for remote execution. Requires an API key to identify the project and can optionally accept runtime variables and advanced settings.

```APIDOC
## POST /api/remote

### Description
Starts a new remote execution (run) of a project configured for remote execution. You provide the `api_key` to identify the project, and optionally `variables` and `settings` for runtime customization.

### Method
POST

### Endpoint
/api/remote

### Parameters
#### Query Parameters
- **api_key** (string) - Required - The project-specific secret token used when triggering this project via the API.
- **variables** (object) - Optional - Runtime variables to pass to the project.
- **settings** (object) - Optional - Advanced overrides for the execution (e.g., headless, proxy, user agent).

### Request Example
```json
{
  "api_key": "fad41960-7831-4f36-b9e2-d5ff87ff8ef8",
  "variables": {
    "search_term": "example product"
  },
  "settings": {
    "headless": true
  }
}
```

### Response
#### Success Response (200)
- **queueId** (string) - The unique identifier for the execution queue.

#### Response Example
```json
{
  "queueId": "a1b2c3d4-e5f6-7890-1234-567890abcdef"
}
```
```

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

### Upload Project & Get Project UUID

Source: https://rtila.com/docs/rtila-cloud-api-documentation

Upload your Automation project to the RTILA Cloud to obtain its unique Project ID (UUID). This is the first step before running the project.

```APIDOC
## Upload Project & Get Project UUID

### Description
Upload your Automation project to the RTILA Cloud to obtain its unique Project ID (UUID). This is the first step before running the project.

### Method
POST (Implied, as it's an upload action)

### Endpoint
`/websites/rtila` (This seems to be a project path, not an API endpoint for upload. The actual upload mechanism is not detailed as an API endpoint in the provided text.)

### Parameters
No specific API endpoint or parameters are detailed for the upload process itself. It's described as a manual action within the RTILA platform.

### Request Example
N/A (Manual process described)

### Response
- **Project UUID** (string) - The unique identifier for the uploaded project.
```

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

### RTILA Remote Execution with CAPTCHA Resolver Configuration

Source: https://rtila.com/docs/v8-api-remote-execution

This JSON example demonstrates how to enable and configure a CAPTCHA resolver for a remote RTILA execution. You can either enable the default resolver or provide a specific API key for an alternative service.

```json
{
  "api_key": "YOUR_PROJECT_API_KEY",
  "settings": {
    "captcha_resolver": {
      "enable": true,
      "api_key": "DIFFERENT_2CAPTCHA_KEY"
    }
  },
  "variables": {
    "query": "web scraping"
  }
}
```

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

### GET /api/results - Retrieve Execution Results

Source: https://rtila.com/docs/v8-api-overview

Retrieves records produced by previous project executions. Allows filtering by session ID, dataset, and custom fields, with options for pagination and sorting.

```APIDOC
## GET /api/results

### Description
Retrieves records produced by previous executions. You can filter by `sessionId` (the `queueId` returned by the remote execution call), optionally by `dataset` and custom fields. Pagination (`page`, `perPage`) and sorting (`sort`) are also supported.

### Method
GET

### Endpoint
/api/results

### Parameters
#### Query Parameters
- **sessionId** (string) - Required - Filters results by the execution session ID (queueId).
- **dataset** (string) - Optional - Filters results by a specific dataset name.
- **page** (integer) - Optional - The page number for pagination (default is 1).
- **perPage** (integer) - Optional - The number of results per page (default is 50).
- **sort** (string) - Optional - The field and direction to sort results by (e.g., `fieldName:asc`).
- **[custom_field]** (string) - Optional - Filters results by custom fields defined in the project.

### Request Example
```
GET /api/results?sessionId=a1b2c3d4-e5f6-7890-1234-567890abcdef&dataset=products&sort=price:desc&page=1&perPage=10
```

### Response
#### Success Response (200)
- **data** (array) - An array of result records.
  - Each record is an object containing the scraped data.
- **total** (integer) - The total number of records matching the query.
- **page** (integer) - The current page number.
- **perPage** (integer) - The number of results per page.

#### Response Example
```json
{
  "data": [
    {
      "product_name": "Example Product A",
      "price": 19.99,
      "url": "http://example.com/productA"
    },
    {
      "product_name": "Example Product B",
      "price": 25.50,
      "url": "http://example.com/productB"
    }
  ],
  "total": 2,
  "page": 1,
  "perPage": 10
}
```
```

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

### RTILA V8 API: Retrieve Results (GET /api/results)

Source: https://rtila.com/docs/v8-api-overview

Demonstrates how to retrieve results from previous project executions using the `/api/results` endpoint. It supports filtering by `sessionId`, `dataset`, custom fields, pagination, and sorting.

```http
GET /api/results?filter=sessionId='your_session_id'&dataset=products&sort=-timestamp&page=1&perPage=50
```

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

### RTILA Remote Execution with User-Agent Override

Source: https://rtila.com/docs/v8-api-remote-execution

This JSON example illustrates how to override the default browser User-Agent for a remote RTILA execution. This can be useful for mimicking specific browser environments.

```json
{
  "api_key": "YOUR_PROJECT_API_KEY",
  "settings": {
    "user_agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36"
  },
  "variables": {
    "query": "web scraping"
  }
}
```

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

### Get Public IP Address using JavaScript Fetch API

Source: https://rtila.com/docs/dynamic-variables-javascript-code

Fetches the user's public IP address from the ipify.org API. It uses the Fetch API to make the request and handles potential errors.

```javascript
VALUE= fetch('https://api.ipify.org?format=json').then(response => response.json()).then(data => FIELD_VALUE = data.ip).catch(error => console.error('Error fetching public IP address:', error));
console.log("VALUE:", VALUE);
```

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

### Get Extracted Results by Results UUID

Source: https://rtila.com/docs/rtila-cloud-api-documentation-updated

Retrieve the extracted results of a completed project run using the Results_uuid obtained from the queue endpoint. Authentication with your license key is required.

```URL
https://cloud.rtila.net/results/Results_uuid?key=YOUR_LICENSE_KEY
```

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

### Transform Text to Uppercase in JavaScript

Source: https://rtila.com/docs/custom-commands

This JavaScript snippet demonstrates how to transform the 'testText' property of the 'command' object to uppercase. It assigns the result to 'commandValues'. An alternative commented-out example shows how to store the uppercase string as an array element.

```javascript
// Available global varibales:
// page
// command
// commandValues

commandValues=command.testText.toUpperCase();

// Or as an array
// commandValues=[commandValues.toUpperCase()];
```

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

### RTILA Remote Execution with Advanced Settings Overrides

Source: https://rtila.com/docs/v8-api-remote-execution

This JSON payload demonstrates how to override project settings during a remote execution request. It includes examples for controlling execution behavior like `headless` mode, `max_concurrent_workers`, and `navigation_timeout`.

```json
{
  "api_key": "YOUR_PROJECT_API_KEY",
  "settings": {
    "headless": true,
    "max_concurrent_workers": 5,
    "navigation_timeout": 60000
  },
  "variables": {
    "query": "web scraping"
  }
}
```

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

### Launch Executable Bot from Command Line

Source: https://rtila.com/docs/standalone-executable-bots

This snippet demonstrates the basic command-line syntax for launching an executable bot. It shows how to specify the path to the bot executable and the '--config-file' argument. The './' prefix can be used to prevent potential error warnings.

```bash
Path-to-folder Bot_XXXXXXX.exe --config-file
or 
Path-to-folder .\Bot_XXXXXXX.exe --config-file
```

```bash
Path-to-folder Bot_XXXXXXX.exe --config-file --myvar=testdata
```

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

### Launch Standalone Bot with Specific Config File (Windows)

Source: https://rtila.com/docs/config-binaries-files-for-standalone

This command demonstrates how to launch a Standalone Bot executable on Windows, specifying a particular configuration file to load. This allows the same binary to run different automation sequences by referencing distinct .bot files.

```bash
WINDOWS-Executable.exe --config-file=automation1.config
```

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

### Run Project by Project UUID

Source: https://rtila.com/docs/rtila-cloud-api-documentation-updated

This endpoint queues a project for execution on the RTILA Cloud. You need to provide the Project_uuid obtained after uploading your project and your RTILA license key for authentication.

```URL
https://cloud.rtila.net/queue/Project_uuid?key=YOUR_LICENSE_KEY
```

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

### GET /results/Results_uuid

Source: https://rtila.com/docs/rtila-cloud-api-documentation

Retrieve the extracted results for a completed project run using its Result UUID.

```APIDOC
## GET /results/Results_uuid

### Description
Retrieve the extracted results for a completed project run using its Result UUID.

### Method
GET

### Endpoint
`https://cloud.rtila.net/results/{Results_uuid}`

### Parameters
#### Path Parameters
- **Results_uuid** (string) - Required - The Results UUID received in the response when queuing the project.

#### Query Parameters
- **key** (string) - Required - Your RTILA license key.

### Request Example
`https://cloud.rtila.net/results/RESxxxUID45YY99ZZ&key=26deeXXXXXXXd65af082XXXXcf53f42`

### Response
#### Success Response (200)
- **completedAt** (string) - The timestamp indicating when the automation finished running.
- **datasets** (array) - An array of dataset objects containing the extracted data.
  - **name** (string) - The name of the dataset file.
  - **data** (array) - An array of objects, where each object represents a row of extracted data.
    - **field1** (type) - Description of the extracted data field.

#### Response Example
```json
{
  "completedAt": "Fri Aug 11 2023 09:20:10 GMT+0000 (Coordinated Universal Time)",
  "datasets": [
    {
      "name": "Dataset-#1_1691671374161_1691745608512_output.json",
      "data": [
        {
          "My Variable": "Hello world",
          "projectId": 533,
          "datasetId": 1691671374161
        }
      ]
    }
  ]
}
```
```

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

### GET /api/results

Source: https://rtila.com/docs/v8-api-results-endpoint

Retrieve data produced by RTILA project executions. Supports filtering, pagination, and sorting.

```APIDOC
## GET /api/results

### Description
Retrieve data produced by RTILA project executions. Supports filtering, pagination, and sorting.

### Method
GET

### Endpoint
`/api/results`

### Parameters
#### Query Parameters
- **filter** (string) - Required - SQL-like filter expression to select records (e.g. by `sessionId`, `dataset`, or custom fields).
- **page** (number) - Optional - Page number for pagination. Default is `1`.
- **perPage** (number) - Optional - Items per page. Default is `30`.
- **sort** (string) - Optional - Field to sort by. Prefix with `-` for descending (e.g. `-created`, `-Price`).

#### Request Body
This endpoint does not accept a request body.

### Request Example
```bash
curl -X GET "http://127.0.0.1:8880/api/results?filter=(sessionId='ilh2f81bq46wedu' && Title='A Light in the Attic')" \
  -H "Authorization: Bearer YOUR_SYSTEM_AUTH_TOKEN"
```

### Response
#### Success Response (200)
- **items** (array) - Array of result records.
- **page** (number) - Current page number.
- **perPage** (number) - Number of items returned per page.
- **totalItems** (number) - Total number of items that match the filter.
- **totalPages** (number) - Total pages available.

#### Response Example
```json
{
  "items": [
    {
      "Title": "Tipping the Velvet",
      "Price": "£53.74",
      "Image_url": "https://books.toscrape.com/media/cache/26/0c/260c6ae16bce31c8f8c95daddd9f4a1c.jpg",
      "id": "record-id",
      "collectionId": "collection-id"
    }
  ],
  "page": 1,
  "perPage": 30,
  "totalItems": 1,
  "totalPages": 1
}
```
```

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

### Configure All Available Fields in JSON

Source: https://rtila.com/docs/custom-commands

This JSON defines an 'action' type addon named 'blank-all-available-fields'. It showcases various field types including text, checkbox, textarea, number, and select, demonstrating how to configure different input controls with labels, descriptions, default values, and attributes.

```json
{
  "role": "action",
  "type": "blank-all-available-fields",
  "label": "All Available Fields",
  "description": "Blank All Available Fields Description",
  "defaultValues": {
    "testText": "Default text",
    "testCheckbox": true,
    "testTextarea": "Hello\nworld",
    "testNumber":  10,
    "testSelect": "value2",
  },
  "fields": [
    {
      "type": "text",
      "name": "testText",
      "label": "Test Text",
      "description": "Test Text Description."
    },
    {
      "type": "checkbox",
      "name": "testCheckbox",
      "label": "Test Checkbox",
      "description": "Test Checkbox Description."
    },
    {
      "type": "textarea",
      "name": "testTextarea",
      "label": "Test Textarea",
      "attributes": { "wrap": "off", "rows": "6" },
      "style": "resize: none",
      "description": "Test Textarea Description."
    },
    {
      "type": "number",
      "name": "testNumber",
      "label": "Test Number",
      "attributes": { "min": "1" },
      "description": "Test Number Description."
    },
    {
      "name": "testSelect",
      "type": "select",
      "label": "Test Select",
      "options": [
        { "name": "value1", "value": "Value 1" },
        { "name": "value2", "value": "Value 2" },
        { "name": "value3", "value": "Value 3" }
      ],
      "description": "Test Select Description."
    }
  ]
}
```

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

### GET /results/Results_uuid

Source: https://rtila.com/docs/rtila-cloud-api-documentation-updated

Retrieves the extracted results for a specific project run using the Results_uuid obtained after queuing a project.

```APIDOC
## Get Extracted Results #

Endpoint: `https://cloud.rtila.net/results/Results_uuid`
  * `Results_uuid`: The Results UUID received in the response when queuing the project.
  * Query Parameter:
    * `key`: Your RTILA license key.


**Example of query for specific results via Webhook:**  
https://cloud.rtila.net/results/RESxxxUID45YY99ZZ&key=26deeXXXXXXXd65af082XXXXcf53f42  
Replace RESxxxUID45YY99ZZ with the Results uuid you obtained when queuing this project, and replace 26deeXXXXXXXd65af082XXXXcf53f42 with your license key.
**Example Response:**
`{  
 "completedAt": "Fri Aug 11 2023 09:20:10 GMT+0000 (Coordinated Universal Time)",  
 "datasets": [  
 {  
 "name": "Dataset-#1_1691671374161_1691745608512_output.json",  
 "data": [  
 {  
 "My Variable": "Hello world",  
 "projectId": 533,  
 "datasetId": 1691745608512  
 }  
 ]  
 }  
 ]  
 }  
 `
Save to grepper
The “completedAt” field indicates the time when the automation has finished running.
```

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

### Queue Project with Variables (JSON)

Source: https://rtila.com/docs/rtila-cloud-api-documentation

This snippet demonstrates how to queue a project for execution on the RTILA Cloud API and pass variables to the bot. The 'variables' field in the JSON request body allows for custom data input, which must be declared in the RTILA Project using 'Command-line arguments'.

```json
{
    "variables": {
          "variable1": "Hello world",
          "variable2": "This is the value of variable2"
        }
}

```

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

### Get Timestamp in Seconds using JavaScript

Source: https://rtila.com/docs/dynamic-variables-javascript-code

Generates a Unix timestamp in milliseconds representing the current time. This is commonly used for tracking events or creating unique identifiers.

```javascript
VALUE = Date.now();
console.log("VALUE:", VALUE);
```

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

### Get Current Date and Time in JavaScript

Source: https://rtila.com/docs/dynamic-variables-javascript-code

Retrieves the current date and time, formatting it into a 'YYYY-MM-DD HH:MM:SS' string. This is useful for logging or displaying time-sensitive information.

```javascript
let currentDate = new Date();
let year = currentDate.getFullYear();
let month = ('0' + (currentDate.getMonth() + 1)).slice(-2);
let day = ('0' + currentDate.getDate()).slice(-2);
let hours = ('0' + currentDate.getHours()).slice(-2);
let minutes = ('0' + currentDate.getMinutes()).slice(-2);
let seconds = ('0' + currentDate.getSeconds()).slice(-2);
VALUE=  'Date / '+ year + '-' + month + '-' + day + ' Time /' + hours + ':' + minutes + ':' + seconds;
console.log("VALUE:", VALUE);
```

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

### Get LocalStorage Variable Value in JavaScript

Source: https://rtila.com/docs/dynamic-variables-javascript-code

Retrieves the value of a specified local storage item. Replace the placeholder with the actual key of the local storage variable you want to access.

```javascript
VALUE=window.localStorage.getItem('Replace this with your local storage variable');
console.log("VALUE:", VALUE);
```

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

### RTILA V8 API: Trigger Project Execution (POST /api/remote)

Source: https://rtila.com/docs/v8-api-overview

Illustrates the parameters for triggering a remote project execution via the `/api/remote` endpoint. Requires an `api_key` and optionally accepts `variables` and `settings`.

```http
POST /api/remote
Content-Type: application/json

{
  "api_key": "your_project_api_key",
  "variables": {
    "search_term": "example"
  },
  "settings": {
    "headless": true
  }
}
```

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

### Authentication

Source: https://rtila.com/docs/rtila-cloud-api-documentation-updated

Provides instructions on how to obtain and use your RTILA license key for API authentication.

```APIDOC
## Authentication #

### Get your License Key #

To use the RTILA Cloud API, you need to provide your RTILA license key with every request made. You can find your RTILA license key by logging into your RTILA account at https://rtila.com/my-account/ Once logged in click on the “View Licenses” link for your RTILA Studio purchase/order

Then click on the little key icon to display your License key, and copy it to use it in your API calls.

### Authenticate with license key for queries & webhooks #

To authenticate you just send your license key as a value for a query parameter called: key  
For example: key: 26deeXXXXXXXd65af082XXXXcf53f42

Or you can just include your license key in your URL when using our API end points as webhooks  
For example: https://cloud.rtila.net/queue/XXUUID45YY99ZZ&key=26deeXXXXXXXd65af082XXXXcf53f42
```

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

### Get Current Date in JavaScript

Source: https://rtila.com/docs/dynamic-variables-javascript-code

This JavaScript code generates a formatted string representing the current date (YYYY-MM-DD) and assigns it to the 'VALUE' dynamic variable. The formatted date is then logged to the console.

```javascript
let currentDate = new Date();
let year = currentDate.getFullYear();
let month = currentDate.getMonth() + 1; // add 1 to get the actual month (0-based index)
let day = currentDate.getDate();
VALUE = `Today's date is ${year}-${month}-${day}`
console.log("VALUE:", VALUE);
```

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

### Get Current URL in JavaScript

Source: https://rtila.com/docs/dynamic-variables-javascript-code

This JavaScript code retrieves the current page's URL using `window.location.href` and assigns it to the 'VALUE' dynamic variable. It also includes a console log for debugging.

```javascript
VALUE=window.location.href
console.log("VALUE:", VALUE);
```

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

### Define Test Event Addon in JSON

Source: https://rtila.com/docs/custom-commands

This JSON file configures a 'test-event-addon'. It defines the role, type, label, and description for an event. This specific addon has no default values or fields, indicating it might be a simple trigger or a base for more complex events.

```json
{
  "role": "event", 
  "type": "test-event-addon",
  "label": "Event Addon",
  "description": "Test Event Addon Description",
  "defaultValues": {
  },
  "fields": []
}
```

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

### RTILA Project Configuration for Remote Execution

Source: https://rtila.com/docs/v8-api-overview

Shows the JSON structure for enabling remote execution of a project within RTILA Studio. It includes enabling the feature and setting a project-specific API key.

```json
{
  "name": "Remote Retrieve Queued Results",
  "remote": {
    "enabled": true,
    "api_key": "fad41960-7831-4f36-b9e2-d5ff87ff8ef8"
  }
}
```

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

### Extract Page Title using JavaScript in RTILA

Source: https://rtila.com/docs/dynamic-variables-javascript-code

A basic example showing how to extract the current page's title and assign it to the `VALUE` variable for use in RTILA. This is a simple data extraction task.

```javascript
VALUE = document.title;
```

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

### POST /queue/Project_uuid

Source: https://rtila.com/docs/rtila-cloud-api-documentation

Queue a project for execution on the RTILA Cloud. This endpoint initiates the project run and returns a Result UUID for tracking.

```APIDOC
## POST /queue/Project_uuid

### Description
Queue a project for execution on the RTILA Cloud. This endpoint initiates the project run and returns a Result UUID for tracking.

### Method
POST

### Endpoint
`https://cloud.rtila.net/queue/{Project_uuid}`

### Parameters
#### Path Parameters
- **Project_uuid** (string) - Required - The project UUID obtained from RTILA.

#### Query Parameters
- **key** (string) - Required - Your RTILA license key.

#### Request Body
- **variables** (object) - Optional - Key-value pairs for variables to be used during project execution. Variables must be declared in the RTILA Project using "Command-line arguments".
  - **field1** (string) - Description of the variable.

### Request Example
```json
{
    "variables": {
          "variable1": "Hello world",
          "variable2": "This is the value of variable2"
        }
}
```

### Response
#### Success Response (200)
- **Result_uuid** (string) - The unique identifier for this specific run result, used to retrieve extracted data.

#### Response Example
`Result_uuid: "some_result_uuid_string"`
```

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

### Define Test Loop Addon in JSON

Source: https://rtila.com/docs/custom-commands

This JSON defines a 'test-loop-addon' with a 'loop' role. It includes a label, description, and default values. The 'fields' array is empty, suggesting that loop parameters are handled internally or passed externally.

```json
{
  "role": "loop", 
  "type": "test-loop-addon",
  "label": "Loop Addon",
  "description": "Test Loop Addon Description",
  "defaultValues": {value1,value2},
  "fields": []
}
```

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

### Authenticate with License Key for API Queries and Webhooks

Source: https://rtila.com/docs/rtila-cloud-api-documentation-updated

To authenticate API requests and webhooks, include your RTILA license key as a query parameter named 'key'. This key is essential for all interactions with the RTILA Cloud API.

```URL
https://cloud.rtila.net/queue/XXUUID45YY99ZZ&key=26deeXXXXXXXd65af082XXXXcf53f42
```

```URL
https://cloud.rtila.net/results/RESxxxUID45YY99ZZ&key=26deeXXXXXXXd65af082XXXXcf53f42
```

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

### Define Test Condition Addon in JSON

Source: https://rtila.com/docs/custom-commands

This JSON file defines the configuration for a 'test-condition-addon'. It specifies the role, type, label, description, default values, and the input fields for the condition. The 'testText' field is a text input for user-defined text.

```json
{
  "role": "condition", 
  "type": "test-condition-addon",
  "label": "Condition Addon",
  "description": "Test Condition Addon Description",
  "defaultValues": {
    "testText": "",
  },
  "fields": [
    {
      "type": "text",
      "name": "testText",
      "label": "Test Text",
      "description": "Enter the secret number."
    }
  ]
}
```

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

### Define Test Variable Addon in JSON

Source: https://rtila.com/docs/custom-commands

This JSON defines a 'test-variable-addon' with the role 'variable'. It includes a label, description, default values, and a 'testText' field for user input. This configuration is used to create and manage variables within the system.

```json
{
  "role": "variable", 
  "type": "test-variable-addon",
  "label": "Variable Addon",
  "description": "Test Variable Addon Description",
  "defaultValues": {
    "testText": "my variable",
  },
  "fields": [
    {
      "type": "text",
      "name": "testText",
      "label": "Test Text",
      "description": "Enter a variable"
    }
  ]
}
```

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

### POST /queue/Project_uuid

Source: https://rtila.com/docs/rtila-cloud-api-documentation-updated

Queues a project for execution on the RTILA Cloud. Returns a Result_uuid to track the execution status and retrieve results later.

```APIDOC
## Run/Queue Project #

Endpoint: `https://cloud.rtila.net/queue/Project_uuid`
  * `Project_uuid`: The project UUID obtained from RTILA by clicking the “More options” button (Hamburger Icon) next to the project and selecting “Get UUID.”
  * Query Parameter:
    * `key`: Your RTILA license key.


When using webhooks you can use this format: https://cloud.rtila.net/queue/XXUUID45YY99ZZ&key=26deeXXXXXXXd65af082XXXXcf53f42  
Replace XXUUID45YY99ZZ with your own Project ID, and replace 26deeXXXXXXXd65af082XXXXcf53f42 with your license key.
Once you make this query, you shall receive as a response a Result_uuid, you need to save this value to later on query for the results of this specific run result.
```

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

### JavaScript for TTFB and FLT Measurement

Source: https://rtila.com/docs/website-load-testing-automation

This JavaScript code is executed before opening each URL to initiate response time measurements. It captures the Time To First Byte (TTFB) and Fully Loaded Time (FLT) and stores them in local storage for later retrieval.

```javascript
var timerStart = Date.now();
window.addEventListener('load', () => {
  const FLT_VALUE = Date.now()-timerStart; // Time after everything has been loaded
  window.localStorage.setItem('flt-value', FLT_VALUE); // save FLT value into a local storage variable named flt-value
  console.log(`FLT: ${FLT_VALUE } ms`);
});

fetch(window.location.href)
  .then(response => {
    const url = response.url;
    const resourceTiming = performance.getEntriesByName(url)[0];
    const responseStart = resourceTiming.responseStart;
    const roundedResponseStart = Math.ceil(responseStart);
    window.localStorage.setItem('ttfb-value', roundedResponseStart);
    console.log(`Response start time: ${roundedResponseStart} ms`);
  })
  .catch(error => {
    console.error(error);
  });

```

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

### Display Alert with Dynamic Text in JavaScript

Source: https://rtila.com/docs/custom-commands

This JavaScript code uses `page.evaluate` to display a browser alert. The message for the alert is taken from the `command.testText` property, allowing for dynamic alert messages based on user input or previous command outputs.

```javascript
// -Available global varibales for all roles:
// page
// command
// -Only for events:
// element
// commandCssSelector
// -Only for variables:
// commandValues
// -Only for conditions:
// conditionMet

await page.evaluate(function (alertMessage) {
  return alert(alertMessage);
}, command.testText);
```

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

### Authentication

Source: https://rtila.com/docs/rtila-cloud-api-documentation

Authenticate API requests using your RTILA license key. The license key can be passed as a query parameter or included in webhook URLs.

```APIDOC
## Authentication

### Description
Authenticate API requests using your RTILA license key. The license key can be passed as a query parameter or included in webhook URLs.

### Method
GET/POST (for API calls)

### Endpoint
N/A (Authentication is done via parameters)

### Parameters
#### Query Parameters
- **key** (string) - Required - Your RTILA license key.

### Request Example
`key: 26deeXXXXXXXd65af082XXXXcf53f42`
`https://cloud.rtila.net/queue/XXUUID45YY99ZZ&key=26deeXXXXXXXd65af082XXXXcf53f42`

### Response
Authentication is implicit upon successful request. No specific response for authentication itself.
```

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

### Passing Data to an RTILA Cloud Bot

Source: https://rtila.com/docs/rtila-cloud-api-documentation-updated

Allows passing variables to an RTILA Cloud bot during project queuing. Variables must be declared in the RTILA Project using the 'Command-line arguments' command.

```APIDOC
## Passing Data to an RTILA Cloud bot: #

When queuing a project using the RTILA Cloud API, you have the option to provide variables that will be used during the project’s execution. These variables are passed in the request body under the “variables” field. It’s essential to note that the variables you send must be prepared and declared in the RTILA Project you are queuing using the “Command-line arguments” command.

Add your Command-line arguments variables screenshots:

**Example Request Body to pass variables data:**
```
{
    "variables": {
          "variable1": "Hello world",
          "variable2": "This is the value of variable2"
        }
}


```
```

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

### Call ChatGPT API for SEO Descriptions (JavaScript)

Source: https://rtila.com/docs/woo-categories-chatgpt-api

This JavaScript code snippet demonstrates how to call the OpenAI ChatGPT API to generate SEO-friendly descriptions for WooCommerce product categories. It requires an OpenAI API key and uses RTILA variables to fetch category data. The response is stored in local storage and applied to the page.

```javascript
(async () => {
  const token='sk-dwdwdwd7777DDDDDmZavD9ajZwgvofJ';
  const response = await fetch('https://api.openai.com/v1/chat/completions', {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${token}`,
      'Content-Type': 'application/json'
    },
    body: JSON.stringify({
      model: "gpt-3.5-turbo",
      messages: [{"role": "user", "content": `Create a 30 words seo friendly description for this software product category: ${window.localStorage['RTILA_VAR_1677780406631']}.`}]
    })
  });
  const content = await response.json();
  console.log(content);
  window.localStorage.setItem('chatgpt-response',content.choices[0].message.content.replace(/\r?\n|\r/,"" ));

document.querySelector('body').setAttribute('chatgpt-response',content.choices[0].message.content);
})();
```

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

### Execute RTILA Project Remotely using cURL (Public)

Source: https://rtila.com/docs/v8-api-remote-execution

This cURL command shows how to trigger a RTILA project execution via the public remote API. Ensure you replace `YOUR_PUBLIC_RTILA_HOST` and `YOUR_PROJECT_API_KEY` with your actual host and project API key.

```bash
curl -X POST "https://YOUR_PUBLIC_RTILA_HOST/api/remote" \
  -H "Authorization: Bearer YOUR_SYSTEM_AUTH_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "YOUR_PROJECT_API_KEY",
    "variables": {
      "query": "web scraping"
    }
  }'
```

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

### Implement Loop Logic in JavaScript

Source: https://rtila.com/docs/custom-commands

This JavaScript code implements a main loop that continues indefinitely until a break condition is met. It checks for `Bot.prototype.breakLoopCommand` to exit the loop and also calls `Bot.prototype.loopFunction` to determine if the loop should continue. An alternative `for` loop structure is commented out.

```javascript
// Available global varibales:
// page
// command

while (1) { // this is the main loop
  if (Bot.prototype.breakLoopCommand) {
    Bot.prototype.breakLoopCommand = false;
    break;
  }

  if (!(await Bot.prototype.loopFunction(page, command))) break;
}

// Another example
// for (let index = 0;index <= 10;index += 1) {
//   if (Bot.prototype.breakLoopCommand) {
//     Bot.prototype.breakLoopCommand = false;
//     break;
//   }
//   if (!(await Bot.prototype.loopFunction(page, command))) break;
// }
```

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

### Apply Regex and JS Filters to Data

Source: https://rtila.com/docs/regex-js-filters

This command allows users to clean or complement data by applying a selection of Regex filters and Javascript rules. Input can be text or a variable, and the output is the filtered version of the input. Configuration involves specifying input, selecting filters, and setting RegEx modifiers.

```javascript
function applyFilters(inputData) {
  // Placeholder for actual filter application logic
  // This would involve parsing selected filters and RegEx modifiers
  // and applying them to inputData.
  console.log('Applying filters to:', inputData);
  let filteredData = inputData;
  // Example: Simple placeholder for a regex replace
  // filteredData = filteredData.replace(/\s+/g, '-'); 
  return filteredData;
}
```

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

### Initialize Counter with JavaScript

Source: https://rtila.com/docs/set-a-counter-with-js

Initializes the 'COUNTER' variable in localStorage to 0. This should be done at the beginning of your automation flow, before any incrementing commands.

```javascript
localStorage.setItem('COUNTER', 0);
```

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

### Execute RTILA Project Remotely using cURL (Local)

Source: https://rtila.com/docs/v8-api-remote-execution

This cURL command demonstrates how to execute a RTILA project using the remote API endpoint when running locally. It includes necessary headers for authentication and content type, along with the JSON payload for project execution.

```bash
curl -X POST "http://127.0.0.1:8880/api/remote" \
  -H "Authorization: Bearer YOUR_SYSTEM_AUTH_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "api_key": "fad41960-7831-4f36-b9e2-d5ff87ff8ef8",
    "variables": {
      "query": "web scraping"
    }
  }'
```

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

### Configure Resource Blocking for Performance

Source: https://rtila.com/docs/v8-api-remote-execution

This configuration snippet enables blocking of specific resource types like images, stylesheets, and fonts. It's used to speed up data-only scraping by reducing the amount of data fetched.

```json
{
  "block_resources": {
    "enabled": true,
    "types": ["image", "stylesheet", "font"]
  }
}
```
Tokens:
Raw