Shorthand Scripting – Browser Bro

What is it?

The Browser Bro Shorthand Language is a simple, human-friendly scripting language designed to automate common tasks in a browser, such as clicking buttons, typing into fields or forms, scrolling, navigating, and more. Each instruction is on its own line, and the browser executes these lines in sequence. It is intended to create deterministic workflows on webpages. Its power is designed for automating tedious, laborious, exact, and predetermined tasks in the browser.

The Delimiter

Each command line is divided into parts (the command and its parameters) using the pipe character |. We chose | because it’s not commonly used in HTML attributes or content, making it easy to visually separate each piece of the command and keep things clear.

command|parameter1|parameter2|...

Browser Array Targeting

You can target specific browsers in the Browser Bro Array by prefixing your command with the number. If no number is specified, the command executes in the Scripting Output Browser.

// Execute in browser instance 1
1|Click|ID|submitButton

// Execute in browser instance 2  
2|Type|ID|username|John

// Execute in default instance
Click|ID|loginButton

Variables

Variables allow you to store and reuse information throughout your script. They are always referenced using a tilde (~) before the variable name. For example, ~myVar refers to a variable named myVar. You can set a variable to a fixed value, load its content from a file, or get it from the text editor. Once set, you can reference that variable in commands later in the script.

Example:

// Set a variable to a fixed string:
set|~myVar|Hello World

// Use that variable in a Type command:
Type|ID|usernameField|~myVar

// Set a variable from a file:
set|~myFileVar|file|path/to/file.txt

// Set a variable from text editor:
set|~editorContent|text editor

// Get a value from the page and store in variable:
get|ID|emailField|~userEmail

Referencing Elements in the DOM

In order to do something on a page, we need a way to reference the controls on it. The shorthand language supports four main ways of referencing elements:

ID: By element id
name: By name attribute
class: By CSS class name
aria: By aria-label attribute

NOTE: Using the Type command, you may need to add “.innerhtml” to the reference type to set HTML content instead of input values.

Comments

If you need to add notes or temporarily disable certain instructions, start a line with //.

// This line is a comment and won't be executed

Format

Each command line follows this pattern:

command|param1|param2|...

Remember to use Wait between actions to avoid performing tasks too rapidly and risking bans or blocks from websites.

Commands Reference

Below is a comprehensive list of all available commands in the Browser Bro Shorthand Language.

Important Note: Always ensure responsible use of the Wait command in your scripts. Frequent or rapid interactions without appropriate delays can lead to excessive load, unintended server strain, or even bans and blocks from websites. Use the Wait command thoughtfully and respectfully to avoid any potential abuse or misuse of systems.

set

Purpose: Assign a value to a variable, load content from a file into a variable, or set the variable to the content of the Browser Bro text editor

set|~variableName|value or set|~variableName|file|path/to/file.txt or set|~variableName|text editor

set|~greeting|Hello there!
set|~config|file|config.txt
set|~prompts|text editor

get

Purpose: Retrieve the value from a DOM element and store it in a variable

get|[reference_type]|[reference_value]|~variableName

get|ID|emailField|~userEmail
get|name|username|~userName
get|class|form-input|~inputValue
get|aria|Search Box|~searchTerm

ask

Purpose: Display a dialog box to prompt the user for input and store the response in a variable

ask|[prompt message]|~variableName

ask|Please enter your username|~username
ask|What is your age?|~userAge
ask|Enter search term|~searchQuery

Purpose: Execute raw JavaScript code.

js|[JavaScript code]

js|console.log('Hello world!');
js|document.title = 'New Title';
js|localStorage.setItem('key', 'value');

custom

Purpose: Execute a pre-defined custom JavaScript snippet with parameter substitution. Parameters replace placeholders like <<<BBSH_1>>>, <<<BBSH_2>>> etc.

custom|snippetName|param1|param2|...

custom|fillForm|John Doe|john@email.com|~password
custom|validateField|phoneNumber|~phoneVar

alert

Purpose: Display a browser alert dialog with static text or variable content.

alert|[Message] or alert|~variableName

alert|This is an alert message!
alert|Process completed successfully
alert|~myVariable
alert|~userMessage

Zoom

Purpose: Adjust the webpage zoom level for the entire page or zoom into a specific element. (1 = 100%, 0.5 = 50%, etc.)

Zoom|[zoomFactor] – Zoom entire page
Zoom|[reference_type]|[reference_value]|[zoomFactor] – Zoom specific element

Element targeting: Supports ID, name, class, and aria-label selectors. When zooming a specific element, it will also scroll into view for better visibility.

// Zoom entire page
Zoom|0.75
Zoom|1.5
Zoom|1

// Zoom specific elements
Zoom|ID|mainContent|1.2
Zoom|class|article-text|1.5
Zoom|name|productImage|2.0
Zoom|aria|Navigation Menu|0.8

Note: Element-specific zoom uses CSS transform scale, which maintains the element’s position in the document flow while making it appear larger or smaller. The element will automatically scroll into view for better visibility.

Purpose: Navigate through browser history, load a new URL with optional parameters, or navigate to the Browser Bro Array.

Go|Array – Navigate to the Browser Bro Array view
Go|Forward – Go forward in history
Go|Back – Go back in history
Go|[URL] – Navigate to URL
Go|[URL]|param|key1|value1|key2|value2 – URL with query parameters
Go|[URL]|path|segment1|segment2 – URL with path segments

Go|Array
Go|https://www.example.com
Go|Forward
Go|Back
Go|https://api.example.com|param|apiKey|~myKey|format|json
Go|https://example.com|path|users|~userId|profile

Reload

Purpose: Refresh the current webpage.

Reload

Reload

Wait

Purpose: Pause the script execution for a specified time. Use this to let pages load and avoid hitting servers too quickly.

Wait|[Number] – Wait for seconds (default)
Wait|[Number]|Seconds/Minutes/Hours
Wait|[min,max]|Seconds/Minutes/Hours – Random wait between min and max

Wait|5
Wait|5|Seconds
Wait|1|Minutes
Wait|3,6|Seconds  // Random wait between 3 and 6 seconds

Scroll

Purpose: Scroll the page up or down by pixels, or scroll to a specific element using CSS-style selectors.

Scroll|Down|[pixels] – Scroll down by pixels
Scroll|Up|[pixels] – Scroll up by pixels
Scroll|#elementId – Scroll to element by ID
Scroll|.elementClass – Scroll to element by class
Scroll|[pixels] – Default down scrolling

Scroll|Down|500
Scroll|Up|300
Scroll|#header-section
Scroll|.footer-content
Scroll|400  // Default down scrolling

Type

Purpose: Type text into an element identified by ID, name, class, aria-label. You can also reference variables (e.g., ~myVar).

On some pages you may need to add “.innerhtml” to the reference type to set HTML content instead of input values.

Selector Type	Syntax
By ID	`Type\|ID\|elementID\|textOr~var`
By name	`Type\|name\|elementName\|textOr~var`
By class	`Type\|class\|elementClass\|textOr~var`
By aria	`Type\|aria\|ariaLabel\|textOr~var`
Set innerHTML	`Type\|ID.innerhtml\|elementID\|htmlContent`

Type|ID|usernameField|TestUser
Type|name|passwordField|~myVar   // Using a variable
Type|aria|Search|Find this text
Type|ID.innerhtml|contentDiv|<h1>Hello World</h1>
Type|aria.innerhtml|Description Box|~htmlContent

Focus

Purpose: Set the focus on an element so it becomes active.

Focus|[reference_type]|[reference_value]

Focus|ID|usernameField
Focus|name|user_password
Focus|class|input-field
Focus|aria|Email Address

Click

Purpose: Simulate a mouse click on an element.

Click|[reference_type]|[reference_value]

Click|ID|submitButton
Click|class|btn-primary
Click|aria|Close
Click|name|loginBtn

Select

Purpose: Choose an option from a dropdown select element.

Select|[reference_type]|[reference_value]|optionValue

Select|ID|countryDropdown|US
Select|name|languageSelector|fr
Select|class|form-select|option2
Select|aria|Choose State|CA

Press

Purpose: Simulate keyboard key presses on a specific element. Supports special keys and single characters.

Press|[reference_type]|[reference_value]|[key]

Supported special keys: Enter, Escape, Space, Tab, ArrowUp, ArrowDown, ArrowLeft, ArrowRight, Backspace, Delete

Press|ID|searchField|Enter
Press|class|text-input|Escape
Press|name|username|a
Press|aria|Message Box|Space
Press|ID|textArea|Backspace

loop

Purpose: Create loops to repeat commands. Must be closed with loop|end.

loop|[number] – Loop a specific number of times
loop|each line|~sourceVar|~currentLineVar – Loop through lines
loop|end – End the loop

// Loop 5 times
loop|5
Click|ID|likeButton
Wait|1|Seconds
loop|end

// Loop through each line
set|~names|file|names.txt
loop|each line|~names|~currentName
Type|ID|nameField|~currentName
Click|ID|submitBtn
Wait|2|Seconds
loop|end

// Loop through items
loop|each item|~itemList|~currentItem
js|console.log('Processing item: ~currentItem');
loop|end

shell

Purpose: Run a local shell command (synchronous execution) with support for different shell types and visibility options

shell|[command] – Use default shell (hidden)
shell|visible|[command] – Use default shell (visible window)
shell|hidden|[command] – Use default shell (explicitly hidden)
shell|powershell|[command] – Use PowerShell (hidden)
shell|powershell|visible|[command] – Use PowerShell (visible window)

// Default shell (hidden)
shell|ls -la
shell|mkdir new_folder

// Visible shell windows
shell|visible|dir
shell|powershell|visible|Get-Process

// PowerShell with specific visibility
shell|powershell|hidden|New-Item -ItemType Directory -Path "C:\TestFolder"
shell|powershell|visible|Get-ChildItem | Where-Object {$_.Length -gt 1MB}

Note: Both shell type and visibility are optional parameters. Default behavior is hidden execution with the system default shell. Parameters can be specified in any order.

Snapshot

Purpose: Take a screenshot of the current browser view using various capture methods. Supports multiple screenshot techniques with optional scrolling capabilities.

Snapshot|[method] – Basic snapshot with specified method
Snapshot|[method]|[scrollAmount] – Snapshot with scroll loading
Snapshot|[method]|[scrollAmount]|[scrollTarget] – Snapshot with scroll and target

Available Methods:

Method	Description	Best For
`visible`	Captures the visible browser window area	Fast, reliable screenshots of viewport
`canvas`	Captures HTML5 canvas elements directly	Games, charts, drawing applications
`html2canvas`	Renders full page content to canvas	Complete page screenshots, complex layouts
`dom2image`	Converts DOM elements to image format	Styled content, CSS-heavy pages

Parameters:

method – Required. Screenshot capture method (visible, canvas, html2canvas, dom2image)
scrollAmount – Optional. Pixel amount to scroll before capture, or CSS selector to scroll to
scrollTarget – Optional. Additional scroll target after loading content

// Basic visible screenshot
Snapshot|visible

// HTML2Canvas screenshot
Snapshot|html2canvas

// Canvas capture with scroll loading
Snapshot|canvas|1000

// Dom2image with scroll and target
Snapshot|dom2image|2000|#footer

// Scroll to element before capture
Snapshot|html2canvas|#main-content

Notes:

The visible method is fastest and most reliable
Methods that require external libraries (html2canvas, dom2image, html2pdf) will auto-load dependencies
Progress indicators are automatically shown during capture process
Scroll parameters allow capturing content that loads dynamically as you scroll
Use the Array’s “Test Screenshots” feature to determine which method works best for specific sites
Large pages or complex content may take longer to process
PDF generation typically takes the longest due to additional processing

Best Practices:

Test different methods to find what works best for each site
Use Wait commands before snapshots to ensure page loading is complete
For long pages, use scroll loading to capture off-screen content
The visible method works in all browsers and requires no external dependencies

Tips and Best Practices

✓ DO:

Always use Wait commands between actions to avoid overwhelming servers
Use random wait times (e.g., Wait|3,6|Seconds) to create some variability in the wait times.
Store sensitive data in variables rather than hardcoding them
Add comments to document your scripts
Test your scripts on a small scale before running large batches
Use the get command to verify actions completed successfully

✗ DON’T:

Don’t run scripts too quickly without appropriate delays
Don’t ignore rate limits or terms of service
Don’t hardcode passwords or sensitive information
Don’t forget to handle errors and edge cases
Don’t run untested scripts on production websites

Advanced Browser Toolset & A.I Agent for Entrepreneurs, Developers & Creatives