# Automa: a browser extension that builds automations from connected blocks

> Automa is a Chrome and Firefox extension for building browser automations as visual workflows. It installs from the browser stores, exports standalone extensions through Automa CEB, and ships under a split AGPL and commercial licence.

**AutomaApp/automa** — A browser extension for automating your browser by connecting blocks

- Repository: https://github.com/AutomaApp/automa
- Website: https://www.goautoma.com/extension
- Stars: 21,644 · Forks: 2,342
- Language: Vue
- License: NOASSERTION
- Published: 2026-09-21 · Updated: 2026-09-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/automaapp-automa

## Who Automa is for, and the problem it removes

Automa targets a specific gap: the repetitive browser task that is too irregular for a script you would maintain, and too tedious to keep doing by hand. The README lists the intended jobs plainly: auto-fill forms, do a repetitive task, take a screenshot, or scrape website data. It also states that you can schedule when the automation will execute. Those four examples cover most of the demand. A person who fills the same internal form every Monday, or who copies figures out of a dashboard into a spreadsheet, is the audience.

The design decision that follows from this audience is that the automation lives inside the browser, not beside it. There is no driver process, no separate runtime to install, and no headless environment to provision. The extension is the runtime. That is the whole proposition, and it is also the source of every constraint discussed later.

It is not aimed at engineers building a test suite for a web application, and it is not aimed at teams that need the automation to run inside a CI job. Those users have libraries built for that shape of problem. Automa's shape is a human opening a browser and pressing run.

## How the block workflow is put together

The README describes the product in one line: an extension for automating your browser by connecting blocks. The repository confirms the structure behind that sentence. The primary language is Vue, the top level holds src/, business/, utils/ and webpack.config.js, and package.json lists CodeMirror packages for CSS, HTML, JavaScript and JSON alongside @tiptap editors. A workflow is therefore a graph of blocks edited in a Vue interface, with code and expression editors embedded where a block needs raw input.

The expression layer is worth noting. The dependency list includes @n8n_io/riot-tmpl, the template engine n8n uses for expressions. That points to a data flow where values produced by one block are referenced inside another block's configuration, rather than every block being configured with static text. The @medv/finder dependency is a selector generator, which fits the element-picking behaviour a browser automation tool needs when it has to target a button on a page.

The build pipeline is a webpack setup driven by scripts in package.json: node utils/build.js for production and node utils/webserver.js for development. The build output directory is automa/build, which is the path the README tells you to load when installing locally.

## Installing Automa and running a first workflow

For normal use you do not build anything. The README links two store listings: the Chrome Web Store page for the extension and the Firefox Add-ons page. Install from the store matching your browser and the extension appears in the toolbar.

If you want to work on the source, the README gives one prerequisite before any script will run: create getPassKey.js in the src/utils directory.

```js
export default function() {
  return 'anything-you-want';
}
```

With that file in place, the README's commands are:

```bash
pnpm install
pnpm dev
```

The first pulls dependencies, the second compiles and hot-reloads for Chrome. For Firefox the script is pnpm dev:firefox, and the production equivalents are pnpm build and pnpm build:firefox. A pnpm build:zip script creates a zip from the build folder.

To load the development build in Chrome, the README says to open chrome://extensions, enable Developer mode, click Load unpacked extension, and select the automa/build directory. In Firefox, open about:debugging#/runtime/this-firefox, click Load Temporary Add-on, and select manifest.json inside automa/build. Note that package.json declares node >=14.18.1, so an older Node install will fail before webpack starts.

Once the extension is loaded, the working pattern the README implies is: create a workflow, add blocks, connect them in order, then run it or attach a schedule. The marketplace at extension.automa.site/marketplace is where the README says you can share and download workflows other people built, which is the fastest way to see a working graph before building one.

## Automa CEB and the standalone extension path

The README documents a second product alongside the extension: Automa Chrome Extension Builder, abbreviated Automa CEB. It generates a standalone Chrome extension from Automa workflows, and the README points to docs.extension.automa.site/extension-builder for the details.

This is the answer to a real objection. If a workflow is useful to a colleague who will never learn the block editor, packaging it as its own extension removes the editor from their path. The trade-off is that you now maintain a generated artifact. The README does not describe how regeneration works when the underlying workflow changes, whether the generated extension updates itself, or what happens to it when Automa ships a new version. Anyone relying on CEB should read the linked documentation before committing, because the README alone does not cover that lifecycle.

## Where Automa stops being the right choice

The extension model is the limitation. Everything runs in a browser profile that a person is logged into. That is precisely why form filling and scraping authenticated pages work without credential plumbing, and precisely why the automation cannot run on a server, in a nightly cron on a machine with no browser, or as part of a deployment pipeline.

Page changes are the second failure mode. Any automation that targets elements on a third-party site breaks when that site changes its markup. Automa's selector tooling reduces the effort of picking a target, but it cannot make a selector resilient to a redesign. The README says nothing about retry behaviour, error handling on a failed block, or what a partially completed workflow leaves behind. If a workflow submits a form and then fails on the next block, the README does not document rollback.

Scheduling deserves the same caution. The README states that you can schedule when the automation will execute, but the extension has to be running for that schedule to fire. Treat it as a reminder inside a browser session, not as a server-side scheduler.

Finally, the licence. The README says the source code is variously licensed under the GNU Affero General Public License or the Automa Commercial License, with details in LICENSE.txt. A split like that usually means the AGPL covers the open code and commercial terms apply to some other use. Read LICENSE.txt rather than assuming which side your use falls on.

## Automa compared with scripted browser automation

The obvious alternative is writing the automation yourself with Playwright, Puppeteer or Selenium. The difference is not convenience, it is where the code lives and who can change it.

A scripted approach runs headless on a server, is version-controlled as text, and can be reviewed in a pull request. It also requires a developer every time the target page changes, and it requires a place to run. Automa inverts both: a non-developer can build and adjust the workflow in the browser, but the artifact is a graph edited in an extension, not a file in a repository, and it cannot run without a browser session.

There is a middle ground worth naming: a script you write can be pasted into Automa's JavaScript blocks, since the dependency list includes CodeMirror's JavaScript language support. That gets you the browser session and the scheduling UI while keeping the logic in code you control. It does not get you headless execution.

The marketplace is the other differentiator. Scripted automation has no equivalent of downloading someone else's working workflow, which matters when the task is common and someone has already solved it.

## Maintenance, releases and what the licence split means for you

The repository is not archived. The last push was on 2026-03-02, which is more than six months before today, so this is not a project to describe as actively developed. The most recent tagged release in the release list is v1.29.12 from 2025-08-11, while package.json on main carries version 1.30.00, so main is ahead of the latest tag. Plan for a project whose release cadence in the published data is measured in months, not weeks.

Upgrade cost for a store install is low: browser extensions update themselves and workflows are stored by the extension. Upgrade cost for a self-built or CEB-generated extension is higher, because you own the rebuild. The README's build scripts are the rebuild path, and the getPassKey.js prerequisite means a fresh clone will not build until that file exists. That is a small but real onboarding step that a contributor will hit on day one.

On licensing: the README describes a split between AGPL and the Automa Commercial License and defers to LICENSE.txt. AGPL is a copyleft licence with a network-use clause, and a commercial licence usually exists to offer terms the copyleft does not. Which applies to you depends on how you use the code, and that is a question for your own legal review, not something the README answers.

## Conclusion

Automa suits people who repeat the same browser steps and would rather drag blocks than write a Selenium or Playwright script: form filling, screenshots, scheduled runs, scraping. It is the wrong tool when the automation must run on a server with no browser session, when the flow needs to be embedded in application code, or when you cannot accept the AGPL and commercial licence split. Before adopting it, check the LICENSE.txt split and the Automa Commercial License page, confirm the build works for your target browser with pnpm build:firefox or pnpm build, and read the Automa CEB documentation if you plan to ship a standalone extension.

## FAQ

### Is Automa free to use?

The README does not state a price for the extension. It says the source code is variously licensed under the GNU Affero General Public License or the Automa Commercial License, with details in LICENSE.txt. Read that file and the linked commercial licence page to see which terms apply to your use.

### How do I use Automa?

The README links two store listings, one for the Chrome Web Store and one for Firefox Add-ons, and that is the normal install path. To run the source instead, create getPassKey.js in src/utils, run pnpm install and pnpm dev, then load the automa/build directory as an unpacked extension.

### What is an Automa alternative if I need automation outside a browser?

The README positions Automa entirely inside the browser, so a workflow cannot run without a browser session. If you need automation on a server or in a pipeline, a scripted tool such as Playwright, Puppeteer or Selenium fits that shape better. Automa's own JavaScript blocks can hold code, but execution still happens in the extension.

### Is there an Automa extension alternative for Chrome or Firefox?

The README only documents Automa itself, with store listings for the Chrome Web Store and Firefox Add-ons. It does not name any competing extension. The nearest comparison it supports is scripted browser automation, which runs outside the extension model entirely.

## Sources

- [AutomaApp/automa on GitHub](https://github.com/AutomaApp/automa)
- [Issues](https://github.com/AutomaApp/automa/issues)
- [Project website](https://www.goautoma.com/extension)
- [README](https://github.com/AutomaApp/automa/blob/main/README.md)
- [Releases](https://github.com/AutomaApp/automa/releases)

---

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