Abai Autoplus Chatgpt Registration

aBaiAutoplus ChatGPT Registration Skill

Skill by ara.so — AI Agent Skills collection.

aBaiAutoplus is a web-based automation panel for registering, managing, and configuring ChatGPT free accounts at scale. It features multi-threaded registration workflows, OAuth bypass capabilities, pluggable email/SMS/captcha providers, proxy rotation, and BitBrowser integration for fingerprint management.

What It Does

• Automated ChatGPT Registration: Multi-threaded account creation with configurable concurrency and identity generation
• Provider Management: Configure email services, captcha solvers, SMS verification providers, and proxy pools
• Account Management: View, export, and manage registered accounts with status tracking
• Web Dashboard: React-based UI for monitoring registration tasks, account statistics, and system health
• BitBrowser Integration: Profile pool management for browser fingerprinting
• Flexible Configuration: Strategy-based registration with OAuth provider selection

Installation

Prerequisites

• Python 3.11+
• Node.js 18+
• Playwright (for browser automation)

Windows Setup

# Clone and enter directory
git clone https://github.com/asz798838958/freeAgentIdentity.git
cd freeAgentIdentity

# Create virtual environment
python -m venv .venv
.\.venv\Scripts\Activate.ps1

# Install Python dependencies
pip install -r requirements.txt

# Install browser automation runtime
python -m playwright install chromium

# Build frontend
cd frontend
npm install
npm run build
cd ..

# Start the server
python -m uvicorn main:app --host 0.0.0.0 --port 8000

macOS/Linux Setup

# Clone and enter directory
git clone https://github.com/asz798838958/freeAgentIdentity.git
cd freeAgentIdentity

# Create virtual environment
python3 -m venv .venv
source .venv/bin/activate

# Install dependencies
pip install -r requirements.txt
python -m playwright install chromium

# Build frontend
cd frontend
npm install
npm run build
cd ..

# Start server
python -m uvicorn main:app --host 0.0.0.0 --port 8000

Access the web UI at http://localhost:8000

Docker Deployment

# Start with Docker Compose
docker compose up -d --build

Configuration

Environment Variables

Create .env file from template:

cp .env.example .env

Key environment variables:

# Security (REQUIRED for production)
APP_PASSWORD=your-secure-password

# Database
ACCOUNT_MANAGER_DATABASE_URL=sqlite:///./data/account_manager.db

# Optional: Custom host/port
HOST=0.0.0.0
PORT=8000

Web UI Configuration

Most configuration is done through the Settings menu in the web UI:

1. General: Theme, language, default registration strategy, browser reuse
2. Registration Strategy: Default identity generation, execution method, OAuth providers
3. Email Services: Add and configure email providers (IMAP/POP3 credentials)
4. Verification Services: Configure captcha solving providers
5. SMS Services: Add phone number verification providers
6. Proxy Resources: Configure static/dynamic proxy pools
7. ChatGPT: Platform-specific settings
8. BitBrowser: Profile pool management
9. Advanced: Override platform capabilities

Core Application Structure

# main.py - FastAPI application entry point
from fastapi import FastAPI
from application.routes import router

app = FastAPI()
app.include_router(router)

# application/ - Task orchestration and API endpoints
# core/ - Core models, configuration, utilities
# platforms/chatgpt/ - ChatGPT platform adapter
# frontend/ - React + Vite web UI

Key API Patterns

Starting a Registration Task

# application/tasks/registration_task.py usage pattern
from application.tasks.registration_task import start_registration_task

# Start automated registration
task_id = await start_registration_task(
    count=10,              # Number of accounts to register
    concurrency=3,         # Parallel threads
    identity_type="auto",  # Identity generation strategy
    execution_mode="headless",  # Browser mode
    oauth_provider="google",    # OAuth method
    workspace_join=True,   # Auto-join workspace after registration
)

Fetching Account List

# Via API endpoint pattern
from fastapi import APIRouter
from core.database import get_session

router = APIRouter()

@router.get("/api/chatgpt/accounts")
async def list_accounts(
    status: str = None,
    platform: str = "chatgpt",
    skip: int = 0,
    limit: int = 100
):
    """List ChatGPT accounts with filtering"""
    # Query database with filters
    # Returns: [{id, email, status, created_at, ...}]
    pass

Configuring Email Provider

# core/providers/email_provider.py pattern
from core.providers.email_provider import EmailProvider

# Add IMAP email provider
email_config = {
    "type": "imap",
    "host": "imap.gmail.com",
    "port": 993,
    "username": os.getenv("EMAIL_USERNAME"),
    "password": os.getenv("EMAIL_PASSWORD"),
    "use_ssl": True,
    "enabled": True,
    "is_default": True
}

# Providers are managed through web UI Settings → Email Services

Proxy Configuration

# core/providers/proxy_provider.py pattern
from core.providers.proxy_provider import ProxyProvider

# Static proxy configuration
static_proxy = {
    "type": "http",
    "host": "proxy.example.com",
    "port": 8080,
    "username": os.getenv("PROXY_USERNAME"),
    "password": os.getenv("PROXY_PASSWORD")
}

# Dynamic proxy pool (API-based)
dynamic_proxy = {
    "type": "api",
    "api_url": os.getenv("PROXY_API_URL"),
    "api_key": os.getenv("PROXY_API_KEY"),
    "rotation_interval": 300  # seconds
}

Registration Workflow Example

# Complete registration workflow pattern
from platforms.chatgpt.registration import ChatGPTRegistration
from core.identity_generator import generate_identity
from core.providers import get_email_provider, get_proxy_provider

async def register_chatgpt_account():
    # 1. Generate random identity
    identity = generate_identity(locale="en_US")
    
    # 2. Get providers
    email_provider = get_email_provider()
    proxy = get_proxy_provider().get_proxy()
    
    # 3. Initialize registration session
    registration = ChatGPTRegistration(
        identity=identity,
        email_provider=email_provider,
        proxy=proxy,
        headless=True
    )
    
    # 4. Execute registration steps
    try:
        # Navigate and fill registration form
        await registration.navigate_to_signup()
        await registration.fill_identity_info(identity)
        
        # Handle OAuth flow
        await registration.complete_oauth_flow(provider="google")
        
        # Verify email
        verification_code = await email_provider.get_verification_code()
        await registration.submit_verification(verification_code)
        
        # Save account credentials
        account_data = await registration.get_account_info()
        await save_account_to_database(account_data)
        
        return account_data
        
    except Exception as e:
        await registration.cleanup()
        raise e

Batch Operations

Export Accounts

# Export accounts to JSON/CSV
from application.services.account_exporter import export_accounts

# Export specific accounts
account_ids = [1, 2, 3, 4, 5]
export_data = await export_accounts(
    account_ids=account_ids,
    format="json",  # or "csv"
    include_credentials=True
)

# Result format:
# [
#   {
#     "email": "user@example.com",
#     "password": "generated_password",
#     "status": "active",
#     "created_at": "2026-07-15T10:30:00Z"
#   }
# ]

Bulk Status Update

# Update multiple account statuses
from core.database import Account, get_session

async def mark_accounts_verified(account_ids: list[int]):
    async with get_session() as session:
        accounts = await session.query(Account).filter(
            Account.id.in_(account_ids)
        ).all()
        
        for account in accounts:
            account.status = "verified"
            account.verified_at = datetime.utcnow()
        
        await session.commit()

Frontend Development

Development Mode

cd frontend
npm install

# Start dev server (with hot reload)
npm run dev
# Frontend: http://localhost:5173
# Backend must run separately on :8000

Build for Production

cd frontend
npm run build
# Static files output to frontend/dist/
# Served by FastAPI in production

Common Patterns

Task Monitoring

# Check registration task status
from application.tasks.task_manager import get_task_status

task_status = await get_task_status(task_id)
# Returns: {
#   "status": "running",
#   "progress": 7,
#   "total": 10,
#   "completed": 7,
#   "failed": 0,
#   "logs": [...]
# }

Account Filtering

# Query accounts by criteria
from core.database import Account, get_session

async def get_active_accounts(platform: str = "chatgpt"):
    async with get_session() as session:
        accounts = await session.query(Account).filter(
            Account.platform == platform,
            Account.status == "active"
        ).all()
        return accounts

Captcha Solving Integration

# core/providers/captcha_provider.py pattern
from core.providers.captcha_provider import solve_captcha

# Solve reCAPTCHA v2
solution = await solve_captcha(
    captcha_type="recaptcha_v2",
    site_key=os.getenv("RECAPTCHA_SITE_KEY"),
    page_url="https://chatgpt.com/signup",
    provider="2captcha"  # or configured provider
)

await page.evaluate(f"document.getElementById('g-recaptcha-response').value='{solution}'")

Troubleshooting

Registration Fails with "Browser not found"

Problem: Playwright browsers not installed

Solution:

python -m playwright install chromium

Email Verification Timeout

Problem: Email provider not receiving verification codes

Solution:

1. Check email provider settings in Settings → Email Services
2. Verify IMAP/POP3 credentials and connection
3. Check spam/junk folders configuration
4. Increase verification timeout in registration strategy

Proxy Connection Errors

Problem: Proxy authentication failing or timeouts

Solution:

# Verify proxy configuration
# Check proxy provider credentials in .env
PROXY_USERNAME=your_username
PROXY_PASSWORD=your_password

# Test proxy connection manually
import httpx

async with httpx.AsyncClient(
    proxies=f"http://{username}:{password}@{host}:{port}"
) as client:
    response = await client.get("https://api.ipify.org?format=json")
    print(response.json())  # Should show proxy IP

Database Locked Errors

Problem: SQLite database locked during concurrent operations

Solution:

# Use PostgreSQL for high concurrency
ACCOUNT_MANAGER_DATABASE_URL=postgresql://user:pass@localhost/dbname

Or reduce concurrency in registration tasks:

# Lower concurrency value
task_id = await start_registration_task(
    count=10,
    concurrency=2,  # Reduce from 5+ to 2-3
    # ...
)

Frontend Build Fails

Problem: npm build errors or missing dependencies

Solution:

cd frontend
rm -rf node_modules package-lock.json
npm install
npm run build

OAuth Flow Interrupted

Problem: Google/OAuth login fails or times out

Solution:

1. Ensure browser is running in non-headless mode for debugging:

registration = ChatGPTRegistration(
    headless=False  # See browser window
)

2. Check OAuth provider configuration in Settings → Registration Strategy
3. Verify identity data quality (valid names, DOB, etc.)
4. Check for captcha challenges that require manual solving

Testing

# Run test suite
pytest

# Test specific module
pytest tests/test_frontend_sidebar_nav.py

# Run with coverage
pytest --cov=application --cov=core --cov=platforms

Security Best Practices

Never commit to repository:

• Real account credentials (email, password, tokens)
• API keys (captcha services, proxy providers, SMS services)
• Database files (*.db)
• Browser profiles and cookies
• .env file with secrets

Use environment variables:

EMAIL_USERNAME=${EMAIL_USERNAME}
EMAIL_PASSWORD=${EMAIL_PASSWORD}
PROXY_API_KEY=${PROXY_API_KEY}
CAPTCHA_API_KEY=${CAPTCHA_API_KEY}
APP_PASSWORD=${APP_PASSWORD}

Secure production deployments:

# Always set password for public deployments
APP_PASSWORD=strong-random-password-here

# Use HTTPS reverse proxy (nginx, Caddy)
# Restrict firewall access to port 8000

Additional Resources

• QQ Group: https://qm.qq.com/q/JigtiO2Hyc
• License: AGPL-3.0
• Original Framework: lxf746/any-auto-register