English | 简体中文 (Mandarin) | Technical Architecture | Troubleshooting Playbook

Unattended pipeline for creating Muse.ai accounts in bulk: disposable inboxes for the OTP, CloakBrowser for the fingerprint, residential proxies for the egress IP, and automatic invite-code redemption on every account. Every credential lands in a local ledger.

Anti-detect engine: built on CloakBrowser (0xceneor/CloakBrowser) — 87 source-level C++ fingerprint patches, Desktop Profile Manager, and the local loopback proxy bridge.

Muse.ai runs on Meta's shared account and risk infrastructure, which fingerprints the device and scores the payment on every signup. Each layer of this stack exists to keep a run clean:

┌────────────────────────────────────────────────────────┐
│                   Playwright Automation                │
│       (CDP / connect_over_cdp to 127.0.0.1:9222)       │
└───────────────────────────┬────────────────────────────┘
                            │
┌───────────────────────────▼────────────────────────────┐
│                    CloakBrowser                        │
│    - Windows 11 platform persona                       │
│    - Taskbar height coherence (48px offset)            │
│    - Anti-tamper preset (disabled noise, MediaRouter)  │
│    - WebRTC leak protection (disable_non_proxied_udp)  │
└───────────────────────────┬────────────────────────────┘
                            │
┌───────────────────────────▼────────────────────────────┐
│               LocalProxyBridge (Node.js)               │
│    - 127.0.0.1:<port> loopback listener                │
│    - Upstream proxy credential injection               │
│    - Eliminates 502 Bad Gateway intranet probe errors  │
└───────────────────────────┬────────────────────────────┘
                            │
┌───────────────────────────▼────────────────────────────┐
│           Residential Proxy (US / Windows)             │
│    - Egress IP matching system timezone / locale       │
└───────────────────────────┬────────────────────────────┘
                            │
┌───────────────────────────▼────────────────────────────┐
│                   Target: Muse.ai                      │
└────────────────────────────────────────────────────────┘

1. Stealth fingerprint coherence:
   • Pinned Windows 11 persona via --fingerprint-platform=windows and --fingerprint-windows-font-metrics.
   • Screen geometry offset for the Windows taskbar: --fingerprint-taskbar-height=48.
   • Anti-tamper preset: synthetic Canvas/WebGL noise is disabled (--fingerprint-noise=false) so hash-tamper tripwires stay quiet.
2. Local loopback proxy bridge:
   • Upstream residential proxies with authentication return 502 Bad Gateway on Chromium's single-word background omnibox probes (e.g. http://google/).
   • A dedicated Node.js LocalProxyBridge listens on 127.0.0.1:<port>, answers non-FQDN probes itself, and manages upstream authentication transparently. TLS upstreams are supported.
3. WebRTC leak defense:
   • --webrtc-ip-handling-policy=disable_non_proxied_udp and --enforce-webrtc-ip-permission-check stop UDP-based leaks of the real IP.
4. Disposable inboxes and IP-matched billing:
   • Each account gets a throwaway mail.tm inbox, so a run is bounded by proxy and card throughput, not by mailbox supply.
   • The billing ZIP is pulled from the live egress IP, so the card's address agrees with the proxy's geolocation instead of tripping the risk score.

muse-ai-automation/
├── accounts.csv              # Credential ledger (written at runtime, gitignored)
├── requirements.txt          # Python dependencies
├── package.json              # Node.js dependencies
├── .env.example              # Configuration template
├── proxies.txt               # Optional residential proxy pool (host:port:user:pass, gitignored)
└── scripts/
    ├── launch_profile.js     # CloakBrowser launcher with local bridge & proxy pool rotation
    ├── clean_and_verify.py   # Purges supercookies, caches, randomizes seeds, verifies stealth
    ├── register_custom_email.py # Stepped runner for custom/Gmail addresses
    ├── run_batch.py          # Automated batch provisioner across dedicated profiles
    ├── run_one.py            # Streamlined single-account end-to-end runner
    ├── accounts.py           # mail.tm inboxes + credential ledger
    ├── muse_bot.py           # CLI automation bot (CDP driver)
    └── automate_account.py   # Onboarding, card verification, invite redemption

[Start profile]                      (once per account, fresh profile dir)
       │
       ▼
[python scripts/muse_bot.py --new-account]
  ├─ Mint mail.tm inbox
  ├─ Append address + password to accounts.csv
  └─ Submit email
       │
       ▼
[python scripts/muse_bot.py --fetch-otp]
  ├─ Poll the inbox for the 6-digit code
  └─ Submit it (pierces the sr-only hidden input)
       │
       ▼
[python scripts/automate_account.py --account <address>]
  ├─ Select 18+ random adult birthday
  ├─ Accept terms disclosure
  ├─ Read egress IP, set matching ZIP, submit card
  └─ Redeem invite code → 1B tokens credited
       │
       ▼
[Status "active" in accounts.csv]

--new-account and --fetch-otp work as a pair. --fetch-otp targets the most recent account still pending, unless --account names one explicitly; both forms are equivalent to the plain --submit-email / --otp steps but with the inbox handled for you.

• Node.js: v20+ or v24+
• Python: 3.10+
• CloakBrowser: stealth Chromium binary installed (~/.cloakbrowser/chromium-*/chrome.exe)

pip install -r requirements.txt
npm install

Copy .env.example to .env — both Python scripts load it automatically:

cp .env.example .env

PROXY_URL=http://username:password@host:port
CARD_NUMBER=4000123456789010
CARD_EXPIRY=MM/YY
CARD_CVV=000
INVITE_CODE=YOUR_INVITE_CODE

INVITE_CODE is optional. With it set, onboarding ends in redemption; without it, the run stops once the workspace loads and the account is still usable.

python scripts/run_one.py

Or manually step-by-step:

node scripts/launch_profile.js          # terminal 1, leave running
python scripts/muse_bot.py --new-account     # terminal 2
python scripts/muse_bot.py --fetch-otp
python scripts/automate_account.py

When using custom or personal emails where OTP is delivered to your private mailbox:

# Step 1: Submit email and wait on OTP screen
python scripts/register_custom_email.py --email user@gmail.com

# Step 2: Once OTP is received, submit the code to complete onboarding and token redemption
python scripts/register_custom_email.py --code 123456

If you suspect browser profile or fingerprint flagging, run the automated cleaner:

python scripts/clean_and_verify.py

This terminates lingering processes, purges all stored caches and supercookies, generates a new randomized hardware seed, and verifies stealth properties (navigator.webdriver === false, authentic WebGL renderer, taskbar offset, and WebRTC proxy binding).

Give each account its own profile and port so browser state never carries over:

# terminal 1 — one browser per account, each on its own profile and port
PROFILE_NAME=acct_02 CDP_PORT=9223 node scripts/launch_profile.js

# terminal 2 — point the drivers at that port
export CDP_URL=http://127.0.0.1:9223
python scripts/muse_bot.py --new-account && \
python scripts/muse_bot.py --fetch-otp && \
python scripts/automate_account.py

Pass --account <address> to automate_account.py to have it mark that row active when the run finishes. Without it the onboarding still happens; the ledger row just keeps its last status. CDP_URL must match the CDP_PORT of the browser you are driving.

Launch-Muse-Automation.cmd drives a single account end to end on Windows: it checks dependencies, brings the browser up, then runs inbox, OTP and onboarding in order, passing the new address through the ledger as it goes.

accounts.csv sits next to the repo root (override with LEDGER_PATH):

Rows are appended the moment an inbox is minted, so an interrupted run never strands an account. Muse itself is passwordless: sign-in is by emailed code, which is why the inbox password is the credential that matters.

MIT License.