Any Auto Register

Account automation for 11+ AI platforms · Protocol / browser dual-mode · One-click Mac / Windows desktop

Download desktop  ·  What it solves  ·  Screenshots  ·  Community  ·  中文  ·  Tiếng Việt

This is the official upstream of lxf746/any-auto-register — the original author's repository with the most timely updates. Other repositories with the same name are forks.

For learning and research only. Not for commercial misuse. Users are responsible for evaluating and complying with the terms of service of the targeted platforms, and for any consequences that arise from use.

What it solves

Most similar projects only answer "how do I register one platform" and leave the engineering gaps wide open: how to manage mailboxes, get past captchas, rotate proxies, keep accounts alive after registration, refresh expired tokens, diagnose failures. Any Auto Register handles all of it.

Pair with the Any2API gateway for an end-to-end pipeline: bulk-register → auto-push → instantly usable as OpenAI / Claude-compatible API.

At a glance

Screenshots from the latest desktop build (v1.0.29), updated with each release. The hero image above is the Overview dashboard — six real-time indicators (total / alive / failed / today's registrations / queue / retries), with a stacked success-rate + lifecycle-monitoring view and a local-runtime summary panel. Below are the other workspaces:

Account pool — unified multi-platform management

Per-platform tabs, with passwords / steward / status / quota / payment link / last query time visible at a glance. Search, bulk import / export, copy single rows, open payment links.

Task queue — batch registration and history

All tasks vs. running tasks at a glance. Each card shows platform, success / total, timestamp, and status. Pause everything, clear the queue, or open the live log for one task.

Registration log — real-time step tracing

Every step of the registration flow is streamed to the frontend via SSE — OAuth code exchange, token issuance, quota query, all visible. When something fails, you see exactly which step.

Settings — desktop-side preferences

Theme / language / global default proxy, plus desktop-only switches: launch at boot, minimize to tray, close-to-tray, check updates on launch, auto-backup directory.

Core capabilities

Grouped by responsibility:

Registration flow

• Platforms: ChatGPT / Cursor / Kiro / Trae.ai / Tavily / Grok / Blink / Cerebras / OpenBlockLabs / Windsurf, plus the Anything generic adapter
• Mailboxes: MoeMail self-hosted / Cloudflare Worker self-hosted / Laoudo / DuckMail / Testmail / Freemail / TempMail.lol / Temp-Mail Web / DuckDuckGo Email
• Captcha: YesCaptcha / 2Captcha / local Solver (Camoufox)
• SMS: SMS-Activate / HeroSMS
• Execution modes: protocol (no browser, fastest) / Headless / Headed, switchable per platform
• Local 2FA: built-in TOTP generator, no third-party app needed

Operations

• Lifecycle: scheduled validity check + token auto-refresh + trial warning, one-click refresh from the dashboard
• Risk center: centralized alerts for Token expired / Trial running out / Proxy unreachable
• Success-rate stats: global success rate + error attribution (first-try / second-factor / proxy banned / mailbox failure), broken down by platform / day / proxy
• Task queue: batch registration history + live progress + per-task logs

System

• Proxy pool: static (success-rate weighted) + dynamic API extraction + rotating gateway, auto-disable on failure
• Any2API sync: auto-push registered accounts to the gateway — ready to use immediately
• Export formats: JSON / CSV / CPA / Sub2API / Kiro-Go / Any2API admin.json
• Concurrency & logging: configurable concurrency, SSE live logs, persistent task runner
• Plugin architecture: platform / mailbox / captcha / SMS / proxy drivers — all hot-swappable

Quick start

Desktop (recommended)

🚀 Zero config. Electron bundles the full backend + frontend, double-click and go.

Install → launch → enter activation code (get one from the group) → pick a platform → configure mailbox → start registering.

Docker

mkdir -p any-auto-register && cd any-auto-register

cat > docker-compose.yml <<'EOF'
services:
  app:
    image: ghcr.io/lxf746/any-auto-register:latest
    ports:
      - "8000:8000"   # Web UI
      - "6080:6080"   # noVNC (visualize the browser)
      - "8889:8889"   # Turnstile Solver
    environment:
      - DISPLAY=:99
      # - APP_PASSWORD=changeme
    volumes:
      - ./data:/app/data
    restart: unless-stopped
EOF

docker compose up -d

When deploying to a cloud server, open ports 8000 / 6080 / 8889.

From source

The source tree contains the core registration flow and the full provider system — fine for self-hosting and extension. Advanced task-queue controls, license management, payment-flow enhancements, and the latest platform adaptations ship with the desktop build.

Requires Python 3.11+ / Node.js 18+:

git clone https://github.com/lxf746/any-auto-register.git
cd any-auto-register/account_manager

python3 -m venv .venv && source .venv/bin/activate
pip install -r requirements.txt

cd frontend && npm install && npm run build && cd ..

# Optional — required for browser modes
python3 -m playwright install chromium
python3 -m camoufox fetch

python3 -m uvicorn main:app --port 8000

Open http://localhost:8000. For frontend hot-reload see Development.

Configuration

Mailbox providers

Pick a mailbox service to receive verification codes. Mailbox, captcha, and SMS configs are driven by a backend provider catalog — the Settings page in the Web UI is list-style CRUD: existing configs on the left, unified editor on the right. New providers added on the backend appear automatically after a refresh — no frontend code changes needed.

Field formats are documented inline in the Settings editor — the backend renders each form from its provider catalog automatically.

Captcha providers

Proxy pool

• Static proxies — added manually on the Proxy page, weighted by success rate, auto-disabled after 5 consecutive failures
• API extraction — pulls IPs dynamically via HTTP API
• Rotating gateway — fixed entry, different exit IP per request — works for BrightData / Oxylabs / IPRoyal etc.

When a proxy provider is enabled in the database, registration tries dynamic proxies first and falls back to the static pool on failure.

SMS providers

For platforms requiring phone verification (e.g. Cursor):

The task-level sms_provider parameter takes priority; otherwise the default SMS provider is used.

Advanced

Account lifecycle

A background lifecycle manager runs automatically:

• Validity check every 6 hours — invalid accounts marked
• Token auto-refresh every 12 hours — refreshes expiring tokens (currently ChatGPT)
• Trial warning — flags accounts nearing expiration, updates status when expired

Manual triggers: POST /api/lifecycle/{check|refresh|warn}, GET /api/lifecycle/status for state.

Success-rate stats & error attribution

• GET /api/stats/overview — global overview (totals, success rate, status distribution)
• GET /api/stats/by-platform — per-platform
• GET /api/stats/by-day?days=30 — daily trend
• GET /api/stats/by-proxy — proxy ranking
• GET /api/stats/errors?days=7 — aggregated error attribution

Any2API integration

Pair with the Any2API gateway — registered accounts are auto-pushed and immediately usable.

Configure in Settings:

Push targets per platform:

If any2api_url is not set, this integration is silently skipped.

Tech stack

Development

account_manager/
├── main.py                 # FastAPI entry
├── api/                    # HTTP routes
│   ├── accounts.py         # account CRUD + export
│   ├── account_providers.py     # mailbox / captcha / SMS / proxy
│   ├── registration.py          # registration tasks + SSE
│   ├── query.py                 # account state queries
│   ├── payment.py               # payment links / actions
│   ├── transfer.py              # import / export
│   ├── platforms.py             # platform listing
│   ├── provider_definitions.py  # provider definitions
│   ├── proxies.py               # proxy management
│   ├── health.py                # health check
│   └── system.py                # system settings / Solver
├── application/            # application services
├── domain/                 # domain models
├── infrastructure/         # repositories + runtime adapters
├── core/                   # base classes (platform / mailbox / captcha / SMS)
├── platforms/              # platform plugins
├── providers/              # provider plugins (mailbox / captcha / SMS / proxy)
├── services/               # background services (Solver process / task runner)
├── customer_portal_api/    # consumer + admin APIs
├── electron/               # Electron desktop packaging
├── tests/                  # tests
└── frontend/               # React frontend

cd frontend
npm run dev
# Open http://localhost:5173 — Vite proxies API requests to the backend

platforms/myplatform/
├── plugin.py
├── registration/
│   ├── module.py       # registration module entry
│   ├── protocol.py     # protocol core
│   ├── worker.py       # mailbox provider → protocol flow
│   ├── browser.py      # browser registration (optional)
│   └── oauth.py        # browser OAuth (optional)
├── query.py            # query capability (optional)
├── payment.py          # payment capability (optional)
└── transfer.py         # import / export capability (optional)

from core.platform_plugin import ConfiguredPlatformPlugin
from core.plugin_registry import register

@register
class MyPlatformPlugin(ConfiguredPlatformPlugin):
    name = "myplatform"
    display_name = "My Platform"
    version = "2.0.0"
    query_class = "MyPlatformQuery"
    payment_class = "MyPlatformPayment"
    transfer_class = "MyPlatformTransfer"

FAQ

cd frontend && npm run build

docker compose build --no-cache && docker compose up -d

Community

Join the user group for latest updates, activation codes, configuration tips, and registration tricks:

Search the group ID inside QQ. For bugs and feature requests, please use Issues.

Star History

If this project saved you some repetitive work, a ⭐ helps others find it.

License

AGPL-3.0. Personal learning and research are unrestricted; commercial use must comply with AGPL-3.0 (derivative works must be open-sourced).