RPA Automation Panel
A Node.js server with a web panel that runs multi-account browser automation across anti-detect browsers, proxy pools, captcha solvers and AI agents.
Problem
Running account automation at scale means juggling anti-detect browsers, proxies, captchas, mail/SMS and per-site logic — usually as a pile of disconnected scripts no one can operate or scale.
Result
A single web panel that launches multi-threaded automation across 15+ sites, with pluggable captcha solvers, a geo proxy pool, anti-detect profiles, Google Sheets I/O and an LLM agent for recovery.
Tech Stack
Overview
RPA Automation Panel is a Node.js server with a browser-based control panel for running multi-account browser automation at scale. From one screen an operator picks the target sites, sets the thread count, wires up proxies and Google Sheets, then launches — and watches progress stream live. Under the hood it drives anti-detect browsers (Octo Browser, AdsPower, CloakBrowser) through Playwright, solves captchas, fetches mail and SMS codes, and falls back to an LLM agent when a flow is too dynamic for a deterministic script.
It is the production-grade evolution of the BAS bots elsewhere in this portfolio: the same multi-account automation discipline, rebuilt on a Node.js + Playwright architecture — and it still bridges back to BAS through bundled XML projects and modules.
Problem
Automation at account scale is not one problem but a dozen, all at once: every target site has its own flow, each needs a fresh anti-detect fingerprint and a geo-appropriate proxy, captchas appear in half a dozen flavors, registrations need throwaway email and SMS, and the whole thing has to run many threads in parallel without tripping anti-bot defenses. Built the usual way it becomes a heap of one-off scripts — impossible to operate, monitor or extend, and useless to anyone but their author.
Solution
The panel turns that chaos into one operable system. A worker layer manages browser slots for parallel execution; each site is a self-contained config module behind a shared contract, so sites are toggled independently and new ones slotted in without touching the core. Cross-cutting concerns live as reusable modules — captcha solvers, mail/SMS, Google Sheets — that any site can call. A SQLite-backed proxy pool distributes proxies by geography, and when a deterministic scenario hits a wall, the run hands off to a browser-use LLM agent (Python) that shares the same open browser over CDP and finishes the step.
Features
- Web control panel (Express server on
localhost:60000): pick sites, set threads, configure proxies and Sheets, start/stop, live console - Multi-threaded worker engine with browser-slot management for parallel runs
- Anti-detect browser support: Octo Browser, AdsPower, CloakBrowser driven via Playwright/CDP
- 15+ ready site configs (Abra, Airbnb, Cainiao, igitems, MyyShop, Klook, Yandex, Exmo, Truth Social and more) behind one shared contract
- Pluggable captcha solvers: Cap.Guru, RuCaptcha, SCTG, FunCaptcha, Geetest (slider), puzzle-captcha, Arkose, Cloudflare Turnstile
- Disposable email and SMS APIs for registration and confirmation flows
- Google Sheets integration for input data and writing results
- Geo-aware proxy pool in SQLite with proxy checking, import and country-code fixes
- AI recovery agent (browser-use + OpenAI model fallback chain) for dynamic UIs
- Site discovery & codegen — explore a site and auto-generate a new config
- BAS bridge: bundled XML projects/modules for Browser Automation Studio
- Auto-update from GitHub releases, bilingual UI (i18n), run profiling and result export
Development Process
The architecture splits cleanly into server, worker and modules so the hard parts stay isolated. The worker owns concurrency and the browser lifecycle; sites own only their own steps; modules own the reusable plumbing every site shares. That boundary is what makes the panel extensible — adding a site is writing one config against a contract, and adding a capability (a new captcha service, a new mail provider) is writing one module everyone can use. A deep test suite (per-site e2e, per-captcha solvers, proxy and worker-selection units) keeps a system with this many moving parts honest. The newest layer, the LLM agent, was added precisely where deterministic scripts are weakest — recovery and unstable UIs — without replacing the fast, predictable path.
Results
- One panel operates multi-account automation that used to be scattered, unrunnable scripts
- 15+ sites run behind a single contract, parallelized across threads
- A unified captcha/mail/SMS/proxy toolkit any site can reuse instead of reimplementing
- Anti-detect browsers and a geo proxy pool keep runs resilient against anti-bot defenses
- An LLM agent rescues flows that deterministic scenarios cannot, without slowing the rest
What Was Learned
Automation at scale is an integration problem before it is a scripting one. The win came from clean seams — worker vs. site vs. module — so concurrency, per-site logic and shared services each evolve on their own. With those boundaries in place, the exotic parts (anti-detect fingerprints, a geo proxy pool, an LLM fallback agent) became modules to plug in rather than rewrites, and the same module-per-target, shared-contract pattern from the earlier BAS work carried straight into a far larger system.