robotframework-browser

---

Robot Framework Browser library powered by Playwright. Propelling browser automation into the future!

Aiming for :rocket: speed, :white_check_mark: reliability and :microscope: visibility.

See keyword documentation and web page for more details.

Installation instructions

For both installation options Python 3.11 or newer is supported. There are two main ways to install Browser library, with or without user having NodeJS installed.

The easiest way to install the Browser library is to use the robotframework-browser-batteries package (BrowserBatteries). BrowserBatteries contains precompiled NodeJS binaries and NodeJS dependencies, so that users do not need to install NodeJS or its Node-side dependencies by them self.

Limitations:

• BrowserBatteries may not be available for every operating system or processor architecture.
• If you develop plugins that require third-party NodeJS modules, those modules are not included in the BrowserBatteries package.

See Installation without NodeJS for more details.

If BrowserBatteries package is not suitable for you, for some reason, then you need to install NodeJS, install robotframework-browser and install NodeJS dependencies. See more detail in Installation with NodeJS chapter

Installation without NodeJS

1. Update pip pip install -U pip to ensure latest version is used
2. Install robotframework-browser and robotframework-browser-batteries from the commandline: pip install robotframework-browser[bb]
3. Install the Playwright browser binaries, run: rfbrowser install

• if rfbrowser is not found, try python -m Browser.entry install

Installation with NodeJS

From Node side 22, 24 and 26 LTS versions are supported.

1. Install NodeJS e.g. from https://nodejs.org/en/download/
2. Update pip pip install -U pip to ensure latest version is used
3. Install robotframework-browser from the commandline: pip install robotframework-browser
4. Install the node dependencies: run rfbrowser init in your shell

• if rfbrowser is not found, try python -m Browser.entry init

Please note that by default Chromium, Firefox and WebKit browser are installed, even those would be already installed in the system. The installation size depends on the operating system, but usually is +700Mb. It is possible to skip browser binaries installation with rfbrowser install-browser --skip-browsers or rfbrowser init --skip-browsers command, but then user is responsible for Playwright browser binary installation. It is possible to install only selected browser binaries by adding chromium, firefox or webkit as arguments to init command. Example rfbrowser init firefox would install only Firefox binaries and rfbrowser install-browser firefox chromium would install both Firefox and Chromium binaries.

Or use the docker images . Documented at docker/README.md.

NodeJS 26 and npm 12 support

If you are installing Browser library with NodeJS 26 and are using npm 12.x, then there are few additional steps on the install process. This is because npm 12.x dropped support for post install scripts: https://installsafe.dev/ At this writing Browser library uses many dependencies which do use post install scripts. If you are using NodeJS 26 and npm 12.x, then users need to approve the post install scripts for the Browser library NodeJS dependencies. Because this is moving target, easiest way to do this to install Browser library, run rfbrowser init. Then un the following npm commands:

1. npm approve-scripts --allow-scripts-pending
2. npm approve-scripts

Where <package-a>, <package-b> are replaced with the packages which are listed in step 1. Review the packages, because if you several NodeJS projects, the pending list may contain packages out of the Browser library ecosystem.

After user has allowed required packages, rerun the rfbrowser init commend. The installation without NodeJS does not need these extra steps, because it has NodeJS dependencies build as binary.

Install with transformer

Starting from release 19.11.0 Browser library has optional dependency with Robocop. Install library with Robocop, run install with: pip install robotframework-browser[robocop]. Starting from 18.3.0 release, library will provide external Robocop transformer. Transformer provided by Browser library can be run with command: rfbrowser transform --transformer-name /path/to/tests. Example: rfbrowser transform --wait-until-network-is-idle /path/to/tests would transform deprecated Wait Until Network Is Idle keyword to Wait For Load State keyword. To see full list of transformers provided by Browser library, run command: rfbrowser transform --help.

Update instructions without NodeJS

To upgrade your already installed robotframework-browser and robotframework-browser-batteries follow steps in below. Please note that robotframework-browser and robotframework-browser-batteries packages are tied together and having different versions of these packages is not supported.

1. Update from commandline: pip install -U robotframework-browser robotframework-browser-batteries
2. Clean old node side dependencies and browser binaries: rfbrowser clean-node
3. Install the node dependencies for the newly installed version: rfbrowser install

Update instructions with NodeJS

To upgrade your already installed robotframework-browser library

1. Update from commandline: pip install -U robotframework-browser
2. Clean old node side dependencies and browser binaries: rfbrowser clean-node
3. Install the node dependencies for the newly installed version: rfbrowser init

Nightly builds

Wheels built from the latest green main are always available on the nightly release. They are meant for trying out a fix or a new keyword before it is released, and they are replaced on every push to main, so pick up the current file names from that page:

base=https://github.com/MarketSquare/robotframework-browser/releases/download/nightly
pip install --pre ${base}/robotframework_browser-<version>-py3-none-any.whl
rfbrowser init

Install the matching robotframework_browser_batteries wheel for your platform from the same page if you use BrowserBatteries instead of your own NodeJS. The two packages are tied together and a nightly pair only installs as a pair. Nightly versions are .dev builds of the next milestone, so pip only considers them with --pre and a later real release always wins.

Uninstall instructions

To completely uninstall library, including the browser binaries installed by Playwright, run following commands:

1. Clean old node side dependencies and browser binaries: rfbrowser clean-node
2. Uninstall with pip: pip uninstall robotframework-browser
3. If you have BrowserBatteries installed, also run: pip uninstall robotframework-browser-batteries

Examples

Testing with Robot Framework

*** Settings ***
Library   Browser

*** Test Cases ***
Example Test
    New Page    https://playwright.dev
    Get Text    h1    contains    Playwright

and testing with Python.

import Browser

browser = Browser.Browser()
browser.new_page("https://playwright.dev")
assert "Playwright" in browser.get_text("h1")
browser.close_browser()

But please note that not all features all available from Python. Example automatic closing, run on failure and some others features depends with the library interacting with Robot Framework. Either by using the Robot Framework listener or by using the Robot Framework dynamic library API. If there is need to use these features from Python, then Python code must mimic the the required Robot Framework interfaces that the library requires.

and extending with JavaScript

async function myGoToKeyword(url, page, logger) {
    logger("Going to " + url)
    return await page.goto(url);
}
myGoToKeyword.rfdoc = "This is my own go to keyword";
exports.__esModule = true;
exports.myGoToKeyword = myGoToKeyword;

*** Settings ***
Library   Browser  jsextension=${CURDIR}/mymodule.js

*** Test Cases ***
Example Test
   New Page
   myGoToKeyword   https://www.robotframework.org

See example. Ready made extensions and a place to share your own at robotframework-browser-extensions.

Ergonomic selector syntax, supports chaining of text, css and xpath selectors

# Select element containing text "Login" with text selector strategy
# and select it's parent `input` element with xpath
Click    "Login" >> xpath=../input
# Select element with CSS strategy and select button in it with text strategy
Click    div.dialog >> "Ok"

Evaluate in browser page

New Page   ${LOGIN_URL}
${ref}=    Get Element    h1
Get Property    ${ref}    innerText    ==    Login Page
Evaluate JavaScript    ${ref}    (elem) => elem.innerText = "abc"
Get Property    ${ref}    innerText    ==    abc

Asynchronously waiting for HTTP requests and responses

# The button with id `delayed_request` fires a delayed request. We use a promise to capture it.
${promise}=    Promise To    Wait For Response    matcher=    timeout=3s
Click    \#delayed_request
${body}=    Wait For    ${promise}

Device Descriptors

${device}=  Get Device  iPhone X
New Context  &{device}
New Page
Get Viewport Size  # returns { "width": 375, "height": 812 }

Sending HTTP requests and parsing their responses

${response}=    HTTP    /api/post    POST    {"name": "John"}
Should Be Equal    ${response.status}    ${200}

Parallel test execution using Pabot

You can let RF Browser spawn separate processes for every pabot process. This is very simple, just run the tests normally using pabot (see https://github.com/mkorpela/pabot#basic-use ). However if you have small tests do not use --testlevelsplit, it will cause lots of overhead because tests cannot share the browsers in any case.

You can share the node side RF Browser processes by using the ROBOT_FRAMEWORK_BROWSER_NODE_PORT environment variable, and from Browser.utils import spawn_node_process helper (see the docs for the helper ). This saves some overhead based on how many splits of tests you are running. Clean up the process afterwards.

Re-using authentication credentials

• Figure out how the page is storing authentication
• If it is localstorage or cookies Save Storage State should work. See usage example: https://marketsquare.github.io/robotframework-browser/Browser.html#Save%20Storage%20State

Plugins

Browser library supports plugins to extend library. See more details in the plugin documentation.

Development

See CONTRIBUTING.md for development instructions.

Core team

In order of appearance.

• Mikko Korpela
• Tatu Aalto
• Janne Härkönen (Alumnus)
• Kerkko Pelttari
• René Rohner

Contributors

This project is community driven and becomes a reality only through the work of all the people who contribute. Supported by Robocorp through Robot Framework Foundation.