# robotframework-browser: Robot Framework keywords driving Playwright over gRPC

> This library gives Robot Framework the Playwright automation engine, with a Python side that exposes keywords and a Node side that runs the browser, connected by gRPC. The installation is the hard part: you either ship a precompiled Node runtime in the batteries package or bring your own Node and approve its install scripts.

**MarketSquare/robotframework-browser** — Robot Framework Browser library powered by Playwright.

- Repository: https://github.com/MarketSquare/robotframework-browser
- Stars: 660 · Forks: 147
- Language: Python
- License: Apache-2.0
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/marketsquare-robotframework-browser

## Python keywords, a Node process and a gRPC link

The README describes the project as a Robot Framework Browser library powered by Playwright, and the repository description says the same thing more compactly. The keyword documentation lives on a separate site, and there is a project web page as well.

The architecture is visible in the repository layout and the two manifests. The Python side is the `Browser` package, published to PyPI as `robotframework-browser`, with the `rfbrowser` console script registered as an entry point. The Node side lives in the `node` directory and is published to npm under a different name, `robotframework-playwright`.

The two halves talk over gRPC. The Python dependencies pin `grpcio` and `grpcio-tools` at 1.84.0 and `protobuf` at 7.35.1, and the Node side depends on `@grpc/grpc-js` with `ts-proto` for the generated stubs, and the repository has a `protobuf` directory holding the service definitions. Playwright itself is a runtime dependency of the Node package at ^1.64.1.

So this is not a Python binding to Playwright. It is a Robot Framework library whose keywords are implemented in Python, which then drives a separate Node process that owns the browser, with a typed RPC boundary in between. That explains several things you would otherwise find surprising, most importantly that installing the library can require NodeJS at all.

## Batteries, or bring your own Node

For both installation options Python 3.10 or newer is supported, and the README describes two main ways to install, with or without the user having NodeJS installed.

The easier way is the `robotframework-browser-batteries` package, referred to as BrowserBatteries. It contains precompiled NodeJS binaries and the NodeJS dependencies, so that users do not need to install NodeJS or its Node-side dependencies themselves. The installation is:

```
1. Update pip `pip install -U pip` to ensure latest version is used
```

```
`pip install robotframework-browser[bb]`
```

```
3. Install the Playwright browser binaries, run: `rfbrowser install`
```

and if the `rfbrowser` command is not found, the documented fallback is:

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

Two limitations of the batteries route are stated plainly. BrowserBatteries may not be available for every operating system or processor architecture, and if you develop plugins that require third-party NodeJS modules, those modules are not included in the package.

The second limitation is the one that decides the route for many teams. The batteries package solves the runtime, but a plugin that needs its own npm dependency does not get it for free, and at that point you are back to managing a Node environment.

## With Node: three LTS lines, three browsers and 700 MB

The NodeJS route is the explicit one, and the README is specific about versions. From the Node side, versions 22, 24 and 26 LTS are supported. The steps are to install NodeJS, update pip, install the library with `pip install robotframework-browser`, and then install the Node dependencies by running `rfbrowser init` in your shell, with `python -m Browser.entry init` as the fallback when the command is not found.

The browser installation is where the space goes. By default Chromium, Firefox and WebKit browsers are installed, even those that would already be installed in the system, and the README says the installation size depends on the operating system but is usually +700Mb.

You can change that in three ways. The whole browser installation can be skipped with `rfbrowser install-browser --skip-browsers` or `rfbrowser init --skip-browsers`, in which case the user is responsible for Playwright browser binary installation. Or the selection can be narrowed by adding `chromium`, `firefox` or `webkit` as arguments to the init command, so `rfbrowser init firefox` installs only Firefox binaries and `rfbrowser install-browser firefox chromium` installs both Firefox and Chromium.

There is a third option, the container route. Docker images are published for the project, with the documentation in the `docker` directory of the repository, which is worth considering because the browser binaries are exactly the kind of thing a CI image is good at carrying for you.

## npm 12 and Node 26 break the install scripts

There is a section of the README devoted to NodeJS 26 and npm 12 support, and it exists because npm 12.x dropped support for post install scripts. The README notes that Browser library uses many dependencies which do use post install scripts.

The workaround is a pair of npm commands. After running `rfbrowser init`, you approve the pending scripts with:

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

```
2. npm approve-scripts <package-a> <package-b>
```

where the placeholders are the packages listed by the first command, and then you rerun the `rfbrowser init` command.

The README adds a warning that is worth taking seriously: review the packages, because if you have several NodeJS projects the pending list may contain packages outside the Browser library ecosystem. The list npm shows you is not filtered to this project, and you are about to approve install scripts for whatever is in it.

The README also notes the reason this is awkward, that because it is a moving target the easiest way to install the library is to run `rfbrowser init` and approve what it asks for. And it points out the way out: the installation without NodeJS does not need these extra steps, because it has its NodeJS dependencies built as binary.

## rfbrowser covers install, update and code transformation

The `rfbrowser` command is the project's control surface, and it does more than install.

For upgrades there are two mirrored procedures, and the difference between them is the batteries package. Without NodeJS, you update with `pip install -U robotframework-browser robotframework-browser-batteries`, clean the old Node side dependencies and browser binaries with `rfbrowser clean-node`, and install the node dependencies for the newly installed version with `rfbrowser install`. With NodeJS, the same sequence uses `pip install -U robotframework-browser` and then `rfbrowser init`.

The README flags a constraint that catches people: the robotframework-browser and robotframework-browser-batteries packages are tied together and having different versions of them is not supported. So the upgrade has to move both, which is why the two are in one command.

The third capability is the transformer. Starting from release 19.11.0 the library has an optional dependency with Robocop, and installing it is `pip install robotframework-browser[robocop]`. From release 18.3.0 the library provides a Robocop transformer, run with `rfbrowser transform --transformer-name /path/to/tests`, and `rfbrowser transform --wait-until-network-is-idle /path/to/tests` transforms the deprecated `Wait Until Network Is Idle` keyword to `Wait For Load State`. The full list is available from `rfbrowser transform --help`.

That last one is the feature to notice. A library that can rewrite your deprecated keywords automatically is telling you that its own API moves, and giving you a migration path when it does.

## A Python package with a TypeScript half and its own test apps

The repository layout is larger than a typical library's, and the reason is that this project ships the whole development stack.

The Python side is `Browser`, with `utest` for unit tests and `atest` for acceptance tests, a `browser_batteries` directory, a `docker` directory with the image definitions, and `bootstrap.py` and `tasks.py` for automation. There is a `nodejs_pin.toml`, which is where the Node version is pinned, and a `package-lock.json` for the Node side.

The Node side is `node/`, with its own build script, a jest configuration, a typecheck script that runs `tsc --noEmit`, eslint with a simple-import-sort plugin and prettier for formatting. The build produces the wrapper binary that the Python side launches, and the `package.json` bin field points at it. There is a `protobuf` directory for the service definitions, and `tools` and `docs` directories.

Two things in the root are worth a mention. There are several files that read as instructions for automated coding assistants, with `AGENTS.md`, `CLAUDE.md` and a `CONTEXT-MAP.md`, and there is a `CORE_TEAM_AGREEMENT.md` alongside the code of conduct and the contribution guide. The Python manifest lists four maintainers and the author as the MarketSquare Robot Framework community, and the development status classifier is 5 - Production/Stable.

## Apache-2.0, version 20.6.0, and a nightly tag

The licence is Apache-2.0, stated in the badge, in the Node package manifest and in the Python manifest, with the LICENSE file listed in the license-files entry.

The current version is 20.6.0 in both manifests, and the recent releases are v20.6.0 on 2026-10-03, v20.5.0 on 2026-09-20, and a nightly build from main dated 2026-08-09. The repository is not archived and the last push was on 2026-10-20, so the branch moves faster than the tagged releases, and the presence of a nightly tag from main tells you the project publishes continuous builds as well as point releases.

The Python dependency set is short and specific, which is worth noting for a library that pulls in a browser engine. Robot Framework itself is required at >= 7.1.1 and < 9.0.0, and alongside it come `robotframework-pythonlibcore` at 4.6.0, `robotframework-assertion-engine` at 5.0.1, `wrapt`, `overrides`, `click` for the command line, `seedir` for the spinner, `psutil` for process handling, and `PyYAML` for configuration.

The optional dependencies are the two extras already described, `robocop` and `bb`. The `bb` extra requires `robotframework-browser-batteries>=19.7.2`, which is a useful signal: the batteries package is versioned on its own schedule, and the lower bound tells you which batteries release the library expects to work with.

## Conclusion

robotframework-browser fits a team that already writes Robot Framework tests and wants a browser automation layer with Playwright's reliability, and that is prepared to handle a Node dependency either way. It is the wrong choice for a Python-only team that wants no Node in the picture, since even the batteries route installs a precompiled Node runtime. Verify first that the batteries package is published for your operating system and processor architecture, that you can accept roughly 700 MB of browser binaries or use the skip-browsers option, and that your npm version is not one of the releases that block post install scripts.

## FAQ

### How do I install the Robot Framework Browser library without NodeJS?

Install the batteries extra, which brings precompiled NodeJS binaries and the Node side dependencies with it: pip install robotframework-browser[bb], then run rfbrowser install to fetch the Playwright browser binaries. The README notes BrowserBatteries may not be available for every operating system or processor architecture.

### Which NodeJS versions are supported by robotframework-browser?

The README states that from the Node side versions 22, 24 and 26 LTS are supported, and Python 3.10 or newer is required for both installation options.

### How do I avoid installing all three browsers with robotframework-browser?

You can skip the browser binaries entirely with rfbrowser install-browser --skip-browsers or rfbrowser init --skip-browsers, taking on responsibility for the Playwright binaries yourself, or install only the ones you want by passing chromium, firefox or webkit as arguments, for example rfbrowser init firefox.

### What is the npm approve-scripts step needed for?

The README explains that npm 12.x dropped support for post install scripts and that Browser library uses many dependencies which do use them, so on NodeJS 26 with npm 12.x you have to approve the pending scripts with npm approve-scripts --allow-scripts-pending and then approve the listed packages before rerunning rfbrowser init.

### How do I upgrade an installed robotframework-browser?

Without NodeJS, run pip install -U robotframework-browser robotframework-browser-batteries, then rfbrowser clean-node and rfbrowser install. With NodeJS, run pip install -U robotframework-browser, then rfbrowser clean-node and rfbrowser init. The README notes that the two packages are tied together and different versions of them are not supported.

## Sources

- [Issues](https://github.com/MarketSquare/robotframework-browser/issues)
- [License: Apache-2.0](https://github.com/MarketSquare/robotframework-browser/blob/main/LICENSE)
- [MarketSquare/robotframework-browser on GitHub](https://github.com/MarketSquare/robotframework-browser)
- [README](https://github.com/MarketSquare/robotframework-browser/blob/main/README.md)
- [Releases](https://github.com/MarketSquare/robotframework-browser/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/marketsquare-robotframework-browser