Automa: The Visual Browser Automation Tool That Compiles Workflows Into Standalone Extensions
Hook
What if you could automate your browser by drawing flowcharts instead of writing code—and then package those flowcharts into distributable Chrome extensions? That’s exactly what 21,000+ GitHub stars have discovered with Automa.
Context
Browser automation has traditionally lived in two separate worlds: visual tools like Selenium IDE for testers who avoid code, and programmable frameworks like Puppeteer for developers who demand control. Both approaches have fundamental trade-offs. Visual tools hit complexity walls quickly, while code-based solutions require programming expertise and full development environments for simple tasks like form filling or scheduled screenshots.
Automa bridges this gap with a node-based visual programming interface built entirely as a browser extension. Unlike cloud-based automation platforms that route your data through external servers, Automa runs entirely in your browser—workflows execute locally, data stays on your machine, and there’s no subscription fee. The project’s most compelling feature—and one that sets it apart from alternatives—is the Chrome Extension Builder, which reportedly transforms visual workflows into standalone, distributable extensions. This means you can design an automation once and deploy it to non-technical users without requiring them to install Automa itself.
Technical Insight
Automa’s architecture appears to split between the extension runtime and the Vue-based interface (the project is built with Vue). The core automation engine likely leverages standard WebExtension APIs—tabs for navigation, content scripts for DOM manipulation, and storage for workflow persistence. Workflows are represented as directed graphs where each node is a “block” (form filler, element click, screenshot, etc.) connected by edges that define execution order and data flow.
The visual workflow builder uses a canvas-based drag-and-drop system. Here’s what a simple form-filling workflow looks like conceptually: you drag a “New Tab” block onto the canvas, connect it to a “Forms” block configured with field selectors and values, then connect that to a “Click Element” block targeting the submit button. Behind the scenes, Automa likely serializes this graph into JSON for storage.
The extension’s block system appears to be modular. Each block type would have a configuration schema and an executor function. For example, an “Element Exists” block would check for DOM elements matching a CSS selector, while a “JavaScript Code” block would let you inject arbitrary code into the page context. Data likely flows between blocks through a shared context object—one block can scrape a table, store results in a variable, and subsequent blocks can reference that variable.
Scheduling is explicitly mentioned in the README: “You can even schedule when the automation will execute!” This likely leverages browser APIs for persistent scheduling, though the specific implementation isn’t documented. Web scraping is confirmed as a supported feature, likely using content scripts to extract data via CSS selectors or XPath.
The Chrome Extension Builder is documented as a feature that “allows you to generate a standalone chrome extension based on Automa workflows.” While the README doesn’t detail the implementation, this likely involves generating a complete extension package with manifest, scripts, and a minimal UI. The generated extension would include a streamlined version of Automa’s execution engine—just enough to run your specific workflow without the full visual editor.
Here’s a simplified example of how a workflow for scraping article titles might execute under the hood:
// Conceptual representation of what Automa might generate
// Block 1: Navigate to page
await browser.tabs.update(tabId, { url: 'https://example.com/articles' });
// Block 2: Wait for content to load
await new Promise(resolve => setTimeout(resolve, 2000));
// Block 3: Execute scraping via content script
const titles = await browser.tabs.executeScript(tabId, {
code: `
Array.from(document.querySelectorAll('h2.article-title'))
.map(el => el.textContent.trim())
`
});
// Block 4: Store results
await browser.storage.local.set({ scrapedTitles: titles[0] });The README confirms that the use cases include “Auto-fill forms, do a repetitive task, take a screenshot, or scrape website data.” While data export formats aren’t explicitly documented in the README, these are common features in scraping tools.
The marketplace integration is confirmed with a link to “extension.automa.site/marketplace” where users can “share and download workflows with others.” When you publish a workflow, it likely uploads the serialized JSON to the marketplace. Other users can browse, download, and import these workflows directly into their Automa instance, creating a network effect where common automation patterns get packaged and shared.
Gotcha
The AGPL-3.0 license is Automa’s biggest gotcha for commercial users. The README explicitly states the code is “licensed under the GNU Affero General Public License (AGPL), or the Automa Commercial License.” AGPL is the “viral” license that requires any derivative work—including network-facing services using the code—to be open-sourced. If you fork Automa to build a proprietary automation product, you’re required to release your modifications under AGPL. The project offers a commercial license for this use case, but the pricing isn’t publicly documented. For teams evaluating automation tools, this licensing complexity matters more than you’d expect.
The visual programming model likely has inherent scaling limits. Simple workflows—fill this form, click that button—are probably elegant in the block interface. But complex conditional logic with nested loops and error handling could quickly become a tangled web of connections. Debugging would involve clicking through the visual editor rather than setting breakpoints in code. The README mentions JavaScript Code blocks as an option, but at that point you’re embedding code snippets in a visual tool.
Browser extension sandboxing imposes hard constraints. Automa can’t interact with native OS applications, can’t access the file system beyond downloads, and can’t bypass CORS restrictions without configuring server headers. If your automation needs to coordinate between the browser and desktop applications, or scrape sites with aggressive bot detection, you’ll need a different architecture. The extension also inherits browser resource limitations—memory-intensive scraping jobs can cause tab crashes.
Verdict
Use Automa if you need to automate repetitive browser tasks and prefer visual configuration over code, especially for the confirmed use cases: form automation, scheduled screenshots, or basic web scraping where data extraction patterns are straightforward. It’s excellent for non-developers who need automation without learning programming, and for developers prototyping workflows before committing to code-based solutions. The Chrome Extension Builder feature is documented as a unique capability—if you need to distribute browser automation to end users who shouldn’t see or modify the underlying logic, Automa offers a compelling path. Skip it if you’re building complex automation requiring sophisticated conditional logic, error handling, or integration with external systems where code-based tools like Puppeteer give you granular control. Also skip if AGPL licensing creates complications for your organization, or if your scraping targets employ anti-bot measures that require rotating proxies, custom headers, or other techniques beyond what browser extensions can provide. Teams already invested in CI/CD pipelines with Playwright or Selenium will find limited benefit in adding a visual layer.
