Skip to content
PD
EN RU

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.

The main screen: sites, threads, data source, launch and live progress
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.

Choosing the browser profile mode (here Octo Browser) and the AI helper settings
CloakBrowser mode: profile options and the AI helper
AdsPower mode: a requests-per-minute limit and pauses between retries · View full size
Octo Browser limits: requests per minute and per hour, retries and pauses · View full size
Site data in a table: country, region, connection and SMS columns, with paste from the clipboard
How it was built: details and stack

Tech Stack

Node.jsPlaywrightExpressPython (browser-use)OpenAI APISQLiteOcto Browser / AdsPower / CloakBrowserGoogle Sheets APICaptcha-solving servicesSMS / Mail API

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

Need a similar system?

Tell me about your challenge - I will propose an architecture and the shortest path to a working product.