Regplatform Multi Account Registration

---
name: regplatform-multi-account-registration
description: Multi-platform batch account registration system supporting OpenAI, Grok, Kiro, Gemini with task scheduling, HuggingFace worker nodes, Cloudflare routing, credits system, and admin management
triggers:
  - set up regplatform registration system
  - configure batch account registration
  - deploy huggingface worker nodes for registration
  - set up cloudflare worker routing for regplatform
  - configure openai grok kiro account registration
  - manage hf space worker nodes
  - set up credits and user management for regplatform
  - troubleshoot regplatform worker deployment
---

# RegPlatform Multi-Platform Account Registration

> Skill by [ara.so](https://ara.so) — Daily 2026 Skills collection.

RegPlatform is a Go-based multi-platform batch account registration system. It orchestrates automated registration across OpenAI, Grok, Kiro, and Gemini via distributed HuggingFace Space worker nodes routed through Cloudflare Workers, with a full admin panel, credits system, JWT auth, and real-time WebSocket log streaming.

---

## Architecture

Browser → Nginx (443) → Vue 3 SPA │ Go Backend (:8000) │ TaskEngine (worker pool) │ CF Worker / | \
/openai/ /grok/ /kiro/ /ts/ │ │ │ │ HFNP HFGS HFKR HFTS (OpenAI) (Grok) (Kiro) (Turnstile)

---

## Prerequisites

- Go 1.25+
- Node.js 18+
- PostgreSQL 16+
- Docker & Docker Compose
- HuggingFace account + tokens
- Cloudflare Worker account

---

## Installation & Local Development

### 1. Clone and configure

```bash
git clone https://github.com/your-username/regplatform.git
cd regplatform
cp .env.example .env

2. Edit .env

DATABASE_URL=postgres://user:password@localhost:5432/regplatform
JWT_SECRET=your-32-char-minimum-secret-here
PORT=8000
GIN_MODE=release
DEV_MODE=false
ADMIN_USERNAME=youradminuser
SSO_SECRET=
REDIS_URL=
JWT_EXPIRE_HOURS=72
CORS_ORIGINS=https://yourdomain.com

3. Start backend

go mod tidy
go run cmd/server/main.go

4. Start frontend

cd web
npm install
npm run dev

5. Docker (production)

docker-compose -f docker-compose.prod.yml up -d

First-Time Setup

1. Navigate to http://localhost:8000
2. Register the first account — it automatically becomes admin
3. Log in and go to Admin → System Settings
4. Configure mail services, captcha solvers, and registration URLs

Project Structure

regplatform/
├── cmd/
│   ├── server/              # Main server entrypoint
│   ├── openai-worker/       # OpenAI worker binary → HFNP
│   ├── grok-worker/         # Grok worker binary → HFGS
│   └── grpctest/            # gRPC-web debug tool
├── internal/
│   ├── config/              # Viper config loading
│   ├── model/               # GORM data models
│   ├── service/             # TaskEngine, HFSpaceService, etc.
│   ├── worker/              # Platform worker implementations
│   ├── handler/             # HTTP route handlers
│   ├── middleware/          # JWT auth, CORS, rate limiting
│   ├── dto/                 # Request/response structs
│   └── pkg/                 # Internal utilities
├── web/                     # Vue 3 frontend
├── services/
│   ├── aws-builder-id-reg/  # Kiro registration microservice
│   └── turnstile-solver/    # Turnstile solver microservice
├── cloudflare/              # CF Worker source
├── HFNP/                    # OpenAI HF Space template
├── HFGS/                    # Grok HF Space template
├── HFKR/                    # Kiro HF Space template
└── HFTS/                    # Turnstile HF Space template

API Reference

Authentication

# Register (rate limited: 3/min per IP)
curl -X POST http://localhost:8000/api/auth/register \
  -H "Content-Type: application/json" \
  -d '{"username":"myuser","password":"MyPass123"}'

# Login
curl -X POST http://localhost:8000/api/auth/login \
  -H "Content-Type: application/json" \
  -d '{"username":"myuser","password":"MyPass123"}'
# Returns: {"token":"eyJ..."}

# Get current user
curl http://localhost:8000/api/me \
  -H "X-Auth-Token: $TOKEN"

Password requirements: ≥8 chars, uppercase + lowercase + digit.

Token can be passed as:

• Cookie
• X-Auth-Token: <token> header
• Authorization: Bearer <token> header

Task Management

# Create a registration task
curl -X POST http://localhost:8000/api/tasks \
  -H "X-Auth-Token: $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "platform": "openai",
    "count": 10,
    "proxy_id": 1
  }'

# Start task
curl -X POST http://localhost:8000/api/tasks/123/start \
  -H "X-Auth-Token: $TOKEN"

# Stop task
curl -X POST http://localhost:8000/api/tasks/123/stop \
  -H "X-Auth-Token: $TOKEN"

# Get current running task
curl http://localhost:8000/api/tasks/current \
  -H "X-Auth-Token: $TOKEN"

Results

# List results
curl http://localhost:8000/api/results \
  -H "X-Auth-Token: $TOKEN"

# Export results for a task
curl http://localhost:8000/api/results/123/export \
  -H "X-Auth-Token: $TOKEN" \
  -o results.csv

Credits

# Check balance
curl http://localhost:8000/api/credits/balance \
  -H "X-Auth-Token: $TOKEN"

# Redeem a code
curl -X POST http://localhost:8000/api/credits/redeem \
  -H "X-Auth-Token: $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"code":"REDEEM-CODE-HERE"}'

Proxy Management

# Add proxy
curl -X POST http://localhost:8000/api/proxies \
  -H "X-Auth-Token: $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"url":"http://user:pass@host:port","name":"proxy1"}'

# List proxies
curl http://localhost:8000/api/proxies \
  -H "X-Auth-Token: $TOKEN"

# Delete proxy
curl -X DELETE http://localhost:8000/api/proxies/1 \
  -H "X-Auth-Token: $TOKEN"

Admin Endpoints

# List users
curl http://localhost:8000/api/admin/users \
  -H "X-Auth-Token: $ADMIN_TOKEN"

# Recharge credits for user
curl -X POST http://localhost:8000/api/admin/credits/recharge \
  -H "X-Auth-Token: $ADMIN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"user_id":2,"amount":1000}'

# Get/set system settings
curl http://localhost:8000/api/admin/settings \
  -H "X-Auth-Token: $ADMIN_TOKEN"

curl -X POST http://localhost:8000/api/admin/settings \
  -H "X-Auth-Token: $ADMIN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"key":"new_user_bonus","value":"100"}'

# HF Space overview
curl http://localhost:8000/api/admin/hf/overview \
  -H "X-Auth-Token: $ADMIN_TOKEN"

# Deploy HF Spaces
curl -X POST http://localhost:8000/api/admin/hf/spaces/deploy \
  -H "X-Auth-Token: $ADMIN_TOKEN" \
  -H "Content-Type: application/json" \
  -d '{"type":"openai","count":3}'

# Run health check
curl -X POST http://localhost:8000/api/admin/hf/spaces/health \
  -H "X-Auth-Token: $ADMIN_TOKEN"

# Autoscale spaces
curl -X POST http://localhost:8000/api/admin/hf/autoscale \
  -H "X-Auth-Token: $ADMIN_TOKEN"

# Sync CF Worker env vars
curl -X POST http://localhost:8000/api/admin/hf/sync-cf \
  -H "X-Auth-Token: $ADMIN_TOKEN"

Real-Time Logs

# SSE stream
curl -N http://localhost:8000/ws/logs/123/stream \
  -H "X-Auth-Token: $TOKEN"

# WebSocket (use wscat or browser)
wscat -c "ws://localhost:8000/ws/logs/123" \
  -H "X-Auth-Token: $TOKEN"

System Settings Reference

Configure these in Admin → System Settings (persisted to DB):

HuggingFace Space Workers

Each platform uses a dedicated HF Space type:

Deploy Worker Binaries to HF Space

Worker binaries are released via GitHub Actions to GitHub Releases. The HF Space templates in HFNP/, HFGS/, HFKR/, HFTS/ pull from the latest release tags.

# Build OpenAI worker locally
go build -o inference-runtime ./cmd/openai-worker/

# Build Grok worker locally
go build -o stream-worker ./cmd/grok-worker/

CI/CD auto-builds on push to main:

• Docker image → GHCR
• Worker zips → GitHub Release (tagged inference-runtime-latest, stream-worker-latest, etc.)

Cloudflare Worker Setup

The CF Worker routes requests by path prefix to the correct HF Space pool.

// cloudflare/ — key routing logic (simplified)
// Environment variables set via CF dashboard or sync-cf API:
// OPENAI_SPACES = comma-separated HF Space URLs
// GROK_SPACES   = comma-separated HF Space URLs
// KIRO_SPACES   = comma-separated HF Space URLs
// TS_SPACES     = comma-separated HF Space URLs

// Path prefix routing:
// /openai/* → round-robin across OPENAI_SPACES
// /grok/*   → round-robin across GROK_SPACES
// /kiro/*   → round-robin across KIRO_SPACES
// /ts/*     → round-robin across TS_SPACES

After deploying HF Spaces, use POST /api/admin/hf/sync-cf to automatically update CF Worker environment variables with active Space URLs.

Go Code Patterns

Adding a new platform worker

// internal/worker/myplatform.go
package worker

import (
    "context"
    "github.com/your-username/regplatform/internal/dto"
)

type MyPlatformWorker struct {
    cfg *Config
}

func NewMyPlatformWorker(cfg *Config) *MyPlatformWorker {
    return &MyPlatformWorker{cfg: cfg}
}

func (w *MyPlatformWorker) Register(ctx context.Context, req *dto.RegisterRequest) (*dto.RegisterResult, error) {
    // 1. Get temp email from mail service
    // 2. Submit registration form / API
    // 3. Solve captcha if needed (via turnstile_solver_url)
    // 4. Verify email
    // 5. Return credentials
    return &dto.RegisterResult{
        Email:    req.Email,
        Password: req.Password,
        Token:    "oauth-token-here",
    }, nil
}

Calling the task engine from a handler

// internal/handler/task.go
func (h *TaskHandler) CreateTask(c *gin.Context) {
    var req dto.CreateTaskRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }

    userID := c.GetUint("user_id") // set by JWT middleware

    task, err := h.taskService.Create(c.Request.Context(), userID, &req)
    if err != nil {
        c.JSON(500, gin.H{"error": err.Error()})
        return
    }

    c.JSON(201, task)
}

JWT middleware pattern

// internal/middleware/auth.go
func JWTAuth(secret string) gin.HandlerFunc {
    return func(c *gin.Context) {
        token := extractToken(c) // checks Cookie, X-Auth-Token, Authorization
        claims, err := validateJWT(token, secret)
        if err != nil {
            c.AbortWithStatusJSON(401, gin.H{"error": "unauthorized"})
            return
        }
        c.Set("user_id", claims.UserID)
        c.Set("is_admin", claims.IsAdmin)
        c.Next()
    }
}

func AdminRequired() gin.HandlerFunc {
    return func(c *gin.Context) {
        if !c.GetBool("is_admin") {
            c.AbortWithStatusJSON(403, gin.H{"error": "admin required"})
            return
        }
        c.Next()
    }
}

SSE log streaming

// internal/handler/logs.go
func (h *LogHandler) StreamLogs(c *gin.Context) {
    taskID := c.Param("taskId")

    c.Header("Content-Type", "text/event-stream")
    c.Header("Cache-Control", "no-cache")
    c.Header("Connection", "keep-alive")

    ch := h.logService.Subscribe(taskID)
    defer h.logService.Unsubscribe(taskID, ch)

    c.Stream(func(w io.Writer) bool {
        select {
        case msg, ok := <-ch:
            if !ok {
                return false
            }
            c.SSEvent("log", msg)
            return true
        case <-c.Request.Context().Done():
            return false
        }
    })
}

Vue 3 Frontend Patterns

Calling the API with auth token

// web/src/api/client.js
import axios from 'axios'
import { useAuthStore } from '@/stores/auth'

const client = axios.create({ baseURL: '/api' })

client.interceptors.request.use(config => {
  const auth = useAuthStore()
  if (auth.token) {
    config.headers['X-Auth-Token'] = auth.token
  }
  return config
})

export default client

SSE log streaming in Vue

// web/src/composables/useLogs.js
import { ref, onUnmounted } from 'vue'

export function useLogs(taskId) {
  const logs = ref([])
  const es = new EventSource(`/ws/logs/${taskId}/stream`, {
    headers: { 'X-Auth-Token': localStorage.getItem('token') }
  })

  es.addEventListener('log', e => {
    logs.value.push(JSON.parse(e.data))
  })

  onUnmounted(() => es.close())

  return { logs }
}

Docker Compose (Production)

# docker-compose.prod.yml key services
services:
  app:
    image: ghcr.io/your-username/regplatform:latest
    env_file: .env
    ports:
      - "8000:8000"
    depends_on:
      - postgres
    restart: unless-stopped

  postgres:
    image: postgres:16-alpine
    environment:
      POSTGRES_USER: ${DB_USER}
      POSTGRES_PASSWORD: ${DB_PASSWORD}
      POSTGRES_DB: regplatform
    volumes:
      - pgdata:/var/lib/postgresql/data
    restart: unless-stopped

volumes:
  pgdata:

Common Troubleshooting

Database connection fails

# Verify PostgreSQL is running and DATABASE_URL is correct
psql "$DATABASE_URL" -c "SELECT 1"
# Format: postgres://user:pass@host:5432/dbname?sslmode=disable

JWT errors in production

• Ensure JWT_SECRET is ≥32 characters
• Check token expiry: default is 72 hours (JWT_EXPIRE_HOURS)
• Verify CORS: set CORS_ORIGINS to your frontend domain

HF Space workers not responding

1. Check space status: POST /api/admin/hf/spaces/health
2. Verify HF tokens are valid in admin panel
3. Check CF Worker env vars are synced: POST /api/admin/hf/sync-cf
4. Spaces may be sleeping — autoscale wakes them: POST /api/admin/hf/autoscale

Registration tasks stuck

• Check turnstile_solver_url is set and reachable
• Verify default_proxy or task-specific proxy is working
• Check mail service settings (yydsmail_base_url or gptmail_*)
• View real-time logs: GET /ws/logs/:taskId/stream

Rate limiting

• Register endpoint: 3 requests/min per IP
• Login endpoint: 10 requests/min per IP
• Task concurrency: controlled by max_threads_per_user setting

First admin not created

• Either be the first registered user, OR
• Set ADMIN_USERNAME=yourusername in .env before registering

Dev mode login (for testing)

# Only available when DEV_MODE=true
curl http://localhost:8000/api/auth/dev-login?username=testuser

CI/CD — GitHub Actions

On push to main, the workflow builds:

HF Space templates reference these release tags to pull the latest worker binaries on startup.