Commands Overview

Commands are the building blocks of every automation in RTILA X. Each command performs one specific action: navigating to a URL, clicking a button, filling a form field, extracting data, or controlling the flow of execution. By combining commands in sequence, you create powerful automations that can handle even the most complex web interactions.

Think of commands as instructions in a recipe. Each command tells RTILA exactly what to do, and RTILA executes them one by one, in order, until the automation is complete.

---

Command Categories

RTILA X provides over 60 commands organized into 8 categories:

1. Navigation Commands

These commands control which page the browser is on.

Command	Description
goto	Navigate to a specific URL
go_back	Navigate to the previous page in browser history
go_forward	Navigate to the next page in browser history
reload	Reload the current page
switch_to_tab	Switch focus to a specific browser tab by index

2. Interaction Commands

These commands interact with elements on the page — clicking, typing, selecting, and more.

Command	Description
click	Click an element (supports left/right/middle button, double-click, modifiers)
fill	Fill an input field with text
type	Type text character by character (simulates real keystrokes)
press	Press a keyboard key on an element
keyboard	Simulate a keyboard action with optional delay
check	Check a checkbox or radio button
uncheck	Uncheck a checkbox
select_option	Select an option in a dropdown (<select>) element
hover	Hover the mouse over an element
focus	Focus an element (gives it keyboard focus)
scroll	Scroll the page or a specific element
scroll_into_view	Scroll until a specific element is visible
drag_to	Drag an element from source to target
select_text	Select the text content of an element
set_input_files	Set files for a file input element
dispatch_event	Trigger a custom DOM event on an element

3. Data Extraction Commands

These commands read data from the page.

Command	Description
extract_data	Extract data using a defined dataset configuration
get_text	Get the text content of an element
get_attribute	Get an HTML attribute of an element
get_property	Get a JavaScript property of an element
is_visible	Check if an element is visible

4. Control Flow Commands

These commands control the order and repetition of execution.

Command	Description
if	Conditionally execute commands based on a true/false condition
while	Loop while a condition remains true
for_each	Iterate over items from a dataset or list variable
repeat	Repeat commands a fixed number of times
try_catch	Try commands; if they fail, execute the catch block
break	Exit the current loop
continue	Skip to the next iteration of the current loop
infinite_scroll	Scroll until the bottom is reached or a max count is hit

5. Variables and Data Commands

These commands manipulate data stored in variables.

Command	Description
set_variable	Create or update a runtime variable
math_operation	Perform arithmetic (+, -, *, /, %)
string_operation	Perform string manipulation (concat, split, replace, etc.)
list_operation	Perform operations on list variables (create, push, pop, split)

6. Waiting Commands

These commands pause execution until a condition is met or a time has passed.

Command	Description
wait	Pause for a specified number of milliseconds
wait_for_load_state	Wait for the page to reach a specific load state
wait_for_selector	Wait for an element to appear in the DOM
wait_for_state	Wait for an element to reach a specific state (visible, hidden, etc.)
wait_for_download	Click an element and wait for a file download to complete

7. Network Commands

These commands interact with web APIs and crawl websites.

Command	Description
http_request	Make an HTTP request (GET, POST, PUT, DELETE, PATCH)
crawl_links	Find and follow links on a page to crawl a website

8. Utility Commands

These commands perform miscellaneous tasks.

Command	Description
comment	Add a descriptive comment to the automation logs
save_as_pdf	Save the current page as a PDF file
screenshot	Take a screenshot of the page
set_viewport_size	Set the browser viewport dimensions
set_geolocation	Set the browser’s geographic location
context_set_offline	Simulate the browser being offline
clear_cookies	Clear all cookies for the current site
execute_script	Run JavaScript in the browser page context
run_script	Run a Deno script with full system access
process_image	Manipulate an image file (resize, crop, convert)
file_operation	Perform file system operations (move, copy, delete, zip)
audit_accessibility	Run an accessibility audit on the page
detect_tech_stack	Detect technologies used on the page
audit_links	Check all links on the page for broken URLs
handle_dialog	Handle JavaScript dialogs (alert, confirm, prompt)
get_storage_state	Save browser storage state to a file
set_cookie	Set a browser cookie

---

How Commands Execute

Sequential Execution

Commands execute sequentially from top to bottom. RTILA starts with the first command in the list, executes it completely, then moves to the next command, and so on until all commands have been executed.

Command 1: goto (https://example.com)
Command 2: click (css=.login-button)
Command 3: fill (css=#username, "myuser")
Command 4: fill (css=#password, "mypass")
Command 5: click (css=.submit-button)
Command 6: extract_data (products)

Nesting

Commands can be nested inside other commands. This is how control flow works:

• An if command contains then and else blocks with nested commands.
• A while command contains a do block with nested commands.
• A for_each command contains a do block that runs once per item.
• A try_catch command contains try and catch blocks.
• Any command can have a then block that runs after it completes.

Maximum Nesting Depth

RTILA X enforces a maximum nesting depth of 50 levels. If your command structure exceeds this depth, RTILA will throw an error:

“Maximum command nesting depth exceeded.”

This limit prevents infinite recursion and protects system resources.

---

Adding Commands

In the Visual Builder

1. Open a project in the Visual Builder (click Builder in the ribbon).
2. Switch to the Web Automation tab.
3. Click Add at the bottom of the command list.
4. A command picker modal appears showing all available commands organized by category.
5. Search or browse for the command you need.
6. Click the command to add it.
7. Configure the command’s parameters in the panel that appears.

Via AI Assistant

Simply describe what you want to do in plain English:

“Click the ‘Add to Cart’ button, then wait for the success message to appear.”

The AI will generate the appropriate commands automatically.

Via Recording

Use the Record button to capture your browser actions as commands. Every click, fill, and navigation you perform is automatically converted into the corresponding command.

---

Command Properties

Every command in RTILA X has the following properties:

Property	Type	Description
Display Name	String	A human-readable label for the command. Auto-generated but editable. Shown in the command list.
Command Type	String	The underlying command type (e.g., click, goto, extract_data). Determines which parameters are available.
Parameters	Object	Command-specific configuration. Each command type has its own set of parameters.
Nested Commands	Array	Commands that run inside this command (for control flow) or after this command (via then blocks).

Editing Command Properties

1. Click a command in the command list to expand it.
2. Edit the Display Name to give it a meaningful label.
3. Configure the Parameters for the specific command type.
4. Use the action buttons to add nested commands, clone, or delete.

Command Action Buttons

Button	Icon	Description
Add Nested	+	Add a command inside this command
Clone	Copy icon	Duplicate this command
Toggle Visibility	Eye icon	Show/hide nested commands
Delete	Trash icon	Delete this command

---

Variable Substitution

Commands support variable substitution, allowing you to use dynamic values instead of hardcoded text.

Basic Syntax

Wrap the variable name in ${}:

${variable_name}

Examples:

url: https://example.com/search?q=${search_term}
selector: css=.product-${product_id}
value: ${user_input}

JavaScript Expressions

You can use full JavaScript expressions inside ${}:

${price * 1.2}
${name.toUpperCase()}
${url.split('/')[2]}
${item.split(';')[0].trim()}
${Math.random() * 100}

Type Preservation

If a parameter value is only a variable reference (e.g., "${my_number}"), the original type is preserved. If the variable is part of a larger string (e.g., "Price: ${price}"), the result is always a string.

Available Variables

Variables can come from three sources:

Source	Scope	Example
Project Variables	Current project only	Defined in Project Settings → Variables tab
Global Variables	All projects for the current profile	Defined in Preferences → Global Variables
Runtime Variables	Current run only	Created by set_variable, get_text, etc. during execution

---

Server-Side vs. Browser Commands

Some commands require the full desktop engine and cannot be executed in the browser extension’s preview mode. These are called server-side commands.

Command	Type	Preview Behavior
file_operation	Server-side	Skipped in preview
process_image	Server-side	Skipped in preview
save_as_pdf	Server-side	Skipped in preview
get_storage_state	Server-side	Skipped in preview
convert_data	Server-side	Skipped in preview
audit_accessibility	Server-side	Skipped in preview
audit_links	Server-side	Skipped in preview
detect_tech_stack	Server-side	Skipped in preview
screenshot	Server-side	Skipped in preview
set_geolocation	Server-side	Skipped in preview
set_viewport_size	Server-side	Skipped in preview
context_set_offline	Server-side	Skipped in preview
wait_for_download	Server-side	Skipped in preview
http_request	Server-side	Simulated in preview
run_script	Server-side	Attempted in browser context if possible
ai_completion	Server-side	Simulated in preview
handle_dialog	Server-side	Simulated in preview
assert_console_message	Server-side	Simulated in preview

All other commands (click, fill, goto, extract_data, etc.) can be previewed directly in the browser extension.

Tip: When running a Quick Preview in the extension, server-side commands are safely skipped so you can still test your UI interactions and data extraction logic.

---

Command Execution Details

Timeout Handling

Every command that interacts with the page has a configurable timeout. If the element is not found or the action cannot be completed within the timeout period, the command fails.

Default timeouts:

• Element interactions (click, fill, etc.): 5000ms (5 seconds)
• Navigation commands (goto, go_back, etc.): Uses the project’s navigation_timeout setting (default 30000ms)
• Wait commands: Configurable per command

Error Handling

When a command fails:

1. If the command is inside a try_catch block, the catch block executes.
2. If AI Self-Correction is enabled and the command is a run_script, the AI attempts to fix and retry the script (up to 3 times).
3. If no error handling is in place, the automation stops and the session is marked as “failed”.

Checkpoint Saving

RTILA automatically saves checkpoints during execution. If a run is interrupted (crash, network drop, manual stop), you can resume from where it left off. Checkpoints store:

• The next URL index to process
• All runtime variables
• Memory state
• List of failed URLs

---

Command Reference

For detailed documentation of every command with all parameters, examples, and edge cases, see the Commands Reference section:

• Navigation Commands
• Interaction Commands
• Data Extraction Commands
• Control Flow Commands
• Variables and Data Commands
• Waiting Commands
• Network Commands
• Utility Commands

---

Tips for Working with Commands

Tip	Description
Name your commands	Give each command a meaningful Display Name so you can understand your automation at a glance.
Use variables	Avoid hardcoding values. Use variables so you can change values without editing commands.
Add waits	If your automation fails because elements aren’t loaded yet, add wait_for_selector or wait commands.
Use try_catch	Wrap risky commands in try_catch blocks so your automation can recover from errors gracefully.
Test incrementally	Build your automation step by step, testing after each addition. Don’t build 50 commands and then try to run them all at once.
Use comments	Add comment commands to document complex logic for future reference.