AdsPower Automation Layer: MCP Server + RPA Plus
Knowledge base section 3. Covers how Hermes actually drives AdsPower browser profiles to perform Reddit engagement actions (navigate, upvote, comment, switch profiles), plus the RPA Plus visual process builder for bulk fixed-workflow runs. Sources: AdsPower MCP help page + blog (https://www.adspower.com/blog/adspower-local-api-mcp-server), RPA Plus User Guide (https://rpa-plus-doc-en.adspower.com/), full RPA Plus detail in
06-rpa-plus-reference.md.
1. MCP Server — AI-Driven Browser Automation
1.1 What It Is
MCP = Model Context Protocol, an open-source standard connecting AI models to external systems (browsers, databases, APIs). AdsPower ships a Local API MCP Server that exposes AdsPower’s LocalAPI to any MCP-compatible client as a set of callable tools.
- Built with TypeScript + Playwright + NPM (package:
local-api-mcp-typescript) - Allows natural language control of browser automation — no scripting required
- Turns an AI assistant from a chatbot into an agent that can launch browsers, manage profiles, and drive real actions
- Transport: stdio (spawned as a subprocess by the MCP client)
1.2 Architecture
┌──────────────┐ stdio ┌─────────────────────────┐ LocalAPI ┌─────────────┐
│ Hermes Agent │ <──────────> │ local-api-mcp-typescript │ <────────────> │ AdsPower │
│ (MCP client) │ (JSON-RPC) │ (Playwright + TS) │ (HTTP :50325) │ (browser) │
└──────────────┘ └─────────────────────────┘ └─────────────┘
The MCP server is a thin TypeScript wrapper that translates MCP tool calls into AdsPower LocalAPI HTTP calls (the same REST API documented in 01-local-api.md). Playwright is the browser-automation engine under the hood for the interactive actions (click, fill, navigate, screenshot).
1.3 Setup Requirements
| Requirement | Detail |
|---|---|
| AdsPower desktop | Installed and running on the host machine |
| API verification | Disabled in AdsPower settings (only after confirming profile is trusted — prevents malicious external access) |
| Node.js | 18+ (LTS) required on the machine running the MCP client |
| NPM / npx | Available (comes with Node.js) |
| MCP client | Any MCP-compatible tool (Claude Desktop, Cursor, Hermes Agent) |
Windows config note (from the official docs): on Windows the MCP server is launched via cmd /c npx -y local-api-mcp-typescript (not bare npx).
1.4 Capabilities Exposed
The MCP server surfaces the full LocalAPI surface as MCP tools. For Reddit engagement, the relevant capability set is:
| Capability | Reddit use case |
|---|---|
| Launch / stop profile | Open a specific AdsPower profile (one Reddit account) |
| Navigate to URL | Go to a Reddit post URL |
| Click element | Click the upvote arrow |
| Fill input | Type a comment into the comment box |
| Screenshot | Capture proof of action / verify state |
| Switch profile | Close current, open next AdsPower profile = next Reddit account |
| Manage profiles (create/update/list) | Provision new Reddit accounts at scale |
Because the server is Playwright-backed, any DOM interaction that Playwright can do (click, type, wait-for-selector, evaluate JS) is available — the MCP layer just makes it callable via natural language from the AI client.
1.5 Connecting to Hermes Agent
The AdsPower MCP server is a stdio server (spawned via npx -y local-api-mcp-typescript). Hermes supports stdio MCP servers.
Status on this machine (2026-08-15): the AdsPower MCP server is already installed and working — mcp__adspower__* tools are available in Hermes (47 tools: check-status, create/open/close browser, navigate, click-element, fill-input, screenshot, get-page-visible-text, evaluate-script, iframe-click-element, profile/group/tag/proxy CRUD, fingerprint, cookies, UA, share-profile, kernels, patch, etc.). The CLI (ads.CMD) is also installed and running with a startup VBS + watchdog.
Step-by-step integration plan (reference for other machines):
- Prerequisite — Node.js 18+ on the Hermes host. AdsPower’s MCP server runs as a child process of Hermes via
npx, so Node.js must be installed on the same machine as Hermes. - AdsPower must be running and reachable. On this Windows VPS, AdsPower runs directly on the same machine as Hermes — Local API on
http://localhost:50325(app) /:50725(CLI runtime). No remote host needed. - Register the MCP server in Hermes config (
mcp_servers.adspower):mcp_servers: adspower: command: npx args: [-y, local-api-mcp-typescript] timeout: 180 connect_timeout: 60 - Verify the connection:
hermes mcp test adspower→ expect ✓ Connected, ✓ Tools discovered: N. Tools appear asmcp_adspower_<tool_name>after a session restart. - Disable API verification in AdsPower (only after confirming the profile is trusted).
- First smoke test: launch profile → navigate to Reddit → screenshot → stop.
2. RPA Plus — Visual Predefined Workflows
The old linear RPA has been superseded by RPA Plus — a node-based visual process builder. Full reference:
06-rpa-plus-reference.md. Summary below.
2.1 What It Is
RPA Plus is AdsPower’s built-in visual drag-and-drop process builder (node canvas). It keeps old RPA’s bulk execution ability (up to 100 concurrent threads, up to 5,000 profiles per task) and extends it into a full automation lifecycle: variables, if/else, loops, data processing, sub-processes, third-party tools, headless mode, and a Marketplace.
2.2 Core Concepts
| Concept | Detail |
|---|---|
| Process | A named node-graph workflow (blocks + connection lines). Default name RPA_{timestamp}. Max 3,000 processes, 500 per group. |
| Process editor | 5 sections: left sidebar (name/notes/group + operation palette), function zone (search, undo/redo 100 steps, Dagre auto-align, grouping, import/export, settings), canvas (blocks, lines, minimap), debug log, settings. |
| Operations | 8 categories: Web Actions (16: tabs, access website, refresh, back, screenshot, hover, drop-down, focus, click, input, scroll, input file, execute JS), Keyboard Actions (keys, key combos), Waits (time/random, element appears, request to finish), Get Data (URL, clipboard, element, focused element, save to txt/Excel, download file, import Excel/txt, email), Data Processing (manage variables, extract from txt via regex, convert to JSON, extract field, random extraction), Profile Information (update remark/tag), Process Management (new browser, if, for loops, while, exit loop, apply created process, quit browser), Third-Party Tools (2Captcha, Google Sheet, OpenAI). |
| Variables | System (task ID, profile notes…), global/process (8 types: String, Number, Boolean, Array, Object, Text, File, Folder; editable on Process Details page), in-process (created by Get Data / loops). |
| Control flow | Statement if (exists, numeric compare, contains, one-of), For Loop Elements/Times/Data, While Loop, Exit Loop. |
| Selectors | CSS selector, XPath, or Text. Locate via Chrome DevTools (Ctrl+Shift+I → Ctrl+F). |
| Error handling | Per-block: Interrupt / Skip / Execute other actions. |
| Process settings | Error mode, after-task-completes (clear/save tabs, quit/keep browser), headless mode, password fill, clear cache on quit, timeout (0 = disabled), delayed execution, launch args. |
| Task | Process + execution profiles (by click, group, or filter; up to 5,000). Threads up to 100. Cross-device view, but execution only on current device. Stop task stops all profiles under it. |
| Task Log | Per-task running status + log details; red exclamation = error step; saved outputs (txt/Excel/screenshots) under Log Details → View Log. |
| Marketplace | Template gallery; save a template (optionally + create task in one step). |
| Sharing | Sharing codes (e.g. Dsd9rkHdri9Ox) — Get process / Share; import/export JSON (old-RPA JSON auto-converted). |
| Sub-processes | Apply Created Process — call another process, pass variables in (Area 1), capture exported variables (Area 2, via Export Variable; ⚠️ Export Variable terminates the current process). |
2.3 Running a Process Across Profiles (the Reddit-relevant path)
- Build the process once in the RPA Plus panel (e.g. “Reddit upvote + comment”):
access website → wait element → click upvote → input comment → screenshot → quit browser. - Go to the Profiles menu (or Task page).
- Select the target profiles (one per Reddit account) — by click, by group, or by filter.
- Create a Task: choose the process, set threads (up to 100), and pick Common task (immediate) or Scheduled task (periodic / single execution).
- Track all runs in Task Log.
This is the bulk-execution path: one process, N profiles, up to 100 concurrent threads, up to 5,000 profiles per task.
2.4 RPA Plus for Reddit Engagement
| Reddit action | RPA Plus operations |
|---|---|
| Upvote a post | Access Website(post URL) → Wait element appears → Click(upvote arrow) |
| Comment on a post | Access Website → Wait → Click(comment box) → Input(comment text, variable or per-profile Excel column) → Click(submit) |
| Per-profile inputs | Import Data from Excel with serial_number first column → variables per profile |
| Human-like pacing | Waits with random interval; Input with input interval |
| Captcha handling | 2Captcha third-party tool (normal, reCAPTCHA V2/V3, hCaptcha, Turnstile) |
| Proof capture | Screenshot as the last operation (saved to Task Log) |
| Switch to next account | Handled by running the process across selected profiles — each profile = one account |
| Headless bulk runs | Enable headless mode + timeout in process settings |
Limitation for Hermes integration: RPA Plus processes are built and triggered inside the AdsPower GUI. There is still no documented programmatic API to create or trigger RPA Plus processes from outside AdsPower. RPA Plus is therefore not directly callable by Hermes — it’s a human-configured bulk runner. Hermes can generate process definitions (JSON import) and pre-fill global variable defaults, but a human must trigger the runs in the AdsPower UI.
3. MCP Server vs RPA Plus — Comparison
| Dimension | MCP Server | RPA Plus |
|---|---|---|
| Interface | Natural language → AI calls tools | Visual node-based builder in AdsPower GUI |
| Who drives it | AI agent (Hermes, Claude, Cursor) | Human operator in AdsPower UI |
| Flexibility | High — AI decides actions at runtime based on context | Medium — fixed graph defined upfront, but with if/loops/variables |
| Scripting required | No (natural language) | No (visual) |
| Code/runtime | TypeScript + Playwright, npx-spawned | Built into AdsPower desktop |
| Concurrency | One profile per AI turn (sequential, AI-paced) | Up to 100 concurrent threads, 5,000 profiles/task |
| Scheduling | Via Hermes cron jobs (AI decides when) | Built-in scheduler (periodic/one-shot) |
| Error handling | AI sees errors and adapts (retry, alt strategy) | Per-block Interrupt / Skip / Execute other actions |
| Programmatic trigger from Hermes | Yes (MCP tools are callable) | No (GUI-only) |
| Proof / logging | AI captures screenshots + logs to its own transcript | Task Log panel in AdsPower (screenshots, txt, Excel) |
| Data processing | Via AI + Playwright evaluate-script | Built-in: regex, JSON, field/random extraction, Excel/txt import |
| Third-party tools | Via AI (any API) | Built-in: 2Captcha, Google Sheet, OpenAI |
| Best for | Adaptive, context-aware actions; deciding what to upvote/comment | Bulk-running a fixed workflow across 100s of profiles |
4. Recommendation for Hermes-Driven Reddit Engagement
Use MCP Server as the primary automation layer. RPA Plus is not directly callable by Hermes, so it cannot be the integration point. The MCP server exposes every LocalAPI action as a tool Hermes can call, and the AI layer adds the decision-making RPA Plus lacks (which posts to engage, what comment to write, how to handle errors).
However, do not discard RPA Plus. The optimal architecture is a hybrid:
-
MCP Server (Hermes-driven, adaptive) — for the intelligent layer:
- Research: navigate Reddit, read posts, decide what’s worth engaging.
- Comment authoring: AI writes context-aware comments per post.
- Error recovery: AI retries, switches approach, logs outcomes.
- Single-profile precision work where judgment matters.
-
RPA Plus (human-defined, bulk) — for the volume layer:
- When the engagement workflow is fully nailed down (fixed post + fixed comment template), hand it to an RPA Plus process and run across up to 100 profiles at once (5,000 profiles/task).
- Use Hermes to generate the process definition (JSON import) + pre-fill global variable defaults (Process Details → Process Settings), then a human imports it into RPA Plus for bulk execution.
- RPA Plus’s 100-thread concurrency is the only way to hit high volume cheaply; the MCP server is AI-paced and sequential.
Phased rollout:
- Phase 1: MCP Server only — validate the Reddit engagement loop end-to-end with AI driving one profile.
- Phase 2: Codify the winning loop as an RPA Plus process; run across 10-20 profiles for scale.
- Phase 3: Hybrid — Hermes uses MCP for research + comment drafting, outputs RPA Plus-ready process definitions, human triggers bulk runs.
5. Integration Plan Summary (Hermes + AdsPower MCP)
| Step | Action | Owner | Status |
|---|---|---|---|
| 1 | Install Node.js 18+ on the machine that will run the MCP server | Rahul / ops | ✅ Done (Windows VPS) |
| 2 | AdsPower host: same Windows VPS as Hermes (Local API :50325 app / :50725 CLI) | Rahul | ✅ Done |
| 3 | In AdsPower: disable API verification (after trusting profiles), note Bearer token + LocalAPI port | Rahul | ✅ Done |
| 4 | Register adspower MCP server in Hermes config (stdio, npx -y local-api-mcp-typescript) | Hermes worker | ✅ Done — mcp__adspower__* tools live |
| 5 | hermes mcp test adspower — verify tools discovered | Hermes worker | ✅ Done |
| 6 | Smoke test: launch profile → navigate Reddit → screenshot → stop | Hermes worker | ✅ Done |
| 7 | Build Reddit engagement skill: upvote + comment flow using MCP tools | Hermes worker | In progress |
| 8 | (Phase 2) Codify winning flow as RPA Plus process for bulk execution across profiles | Rahul + Hermes | Future |
6. Open Questions / Risks
- RPA Plus has no external trigger API — confirmed from the docs. Bulk RPA Plus runs remain a human-operated step unless AdsPower adds an API.
- API verification disabled is a security trade-off — only disable for trusted profiles to avoid malicious external access.
- MCP tool surface — the full tool list is discovered via
hermes mcp test adspower; 47mcp__adspower__*tools are currently available on this machine. - Synchronizer (multi-window manual sync) is a separate human tool — see
07-synchronizer.md. It is not scriptable via API/MCP.