RPA Automation Panel
One panel instead of scattered scripts: 15+ sites, run in parallel
A web panel for automating work across many accounts: a fresh browser profile for each site and a connection from the right country, captcha solving and an AI helper for hard steps.
- Coverage
- 15+ sites
- Multi-threaded, with captcha solving and proxy pools
Before
Working across many accounts is a dozen jobs at once: a flow for each site, a separate browser profile and a connection from the right country, captchas, email and SMS. It usually ends up as a pile of one-off scripts only their author can run.
What I built
A web panel: the operator picks sites and the number of threads, connects data from Google Sheets and presses Run. The panel handles browser profiles, solves captchas, fetches codes from email and SMS, and an AI helper finishes a stuck step.
After
One panel replaced scattered scripts: 15+ sites run on shared rules across several threads. Captchas, email, SMS and connections by country are set up once for every site, and a new site is added without touching the rest.
What it does
-
Launch from one screen
Sites, threads, data source, start and stop, with progress visible in real time.
-
15+ ready sites
Each site switches on separately, and a new one is added from a shared template without touching the rest.
-
A fresh browser profile
Works through Octo Browser, AdsPower or CloakBrowser: the panel keeps a fresh browser profile for each site.
-
Captchas, email and SMS
Several kinds of captcha solving, disposable email and SMS for sign-ups, set up once for every site.
-
Data in Google Sheets
Input data comes from a spreadsheet, and the results are written back to it.
-
An AI helper for hard steps
When a site behaves unpredictably, an AI helper finishes the step in the same browser window.
How it looks
How it was built: details and stack
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.
Services used in this project
Related case studies
- iHerb + PochtaGlobal - Business Process AutomationA bot for a reseller of US goods: it collects iHerb orders on its own, creates purchases and parcels on PochtaGlobal, follows tracking numbers and reports every step to Telegram and the accounting system.
- LeadGen Outreach - a Client-Finding System for Freelance MarketplacesMy own CRM with an AI engine: 14 sources of work, task filtering, proposals within each platform's limits, a pipeline up to prepayment, AI reply drafts and a demand analysis across 5,811 tasks.