⚠️ 风险提示与免责声明
本项目及脚本仅供技术学习与研究使用。使用者必须严格遵守 Grok 的使用条款、Twitter/X 服务协议以及当地法律法规。请勿将其用于非法用途或商业获利。自动化注册行为可能触发风控，请自行承担相关账号被封禁或 IP 被限制的风险。

💡 核心逻辑：流量池架构
要实现“几乎无限制”的使用，核心在于将多个受限账号构建为一个“Token 流量池”。

实现逻辑梳理：

自动化填充 (Automation): 利用油猴脚本模拟真人行为，自动完成注册、邮箱接码、设置密码全流程。

Token 捕获 (Extraction): 脚本在注册完成后，自动从浏览器中提取 SSO Cookie。

流量池化 (Pooling): 通过 grok2api 项目搭建的服务端，将提取的 Token 自动同步至本地或服务器数据库。

智能轮询 (Load Balancing): API 服务层根据负载情况，动态调度池中的账号，绕过单账号的 80 次/20 小时限制。

🛠 准备工作
在运行脚本前，请确保你已经完成了以下基础环境的部署：

服务端环境：请先部署 grok2api 项目。这是接收并管理你的 Token 的核心容器。

浏览器准备：安装 Tampermonkey 插件。

网络环境：建议配合指纹浏览器或稳定的节点，以降低触发 Twitter 注册风控的概率。

📝 自动化脚本 (Userscript)
将以下代码保存至 Tampermonkey 新脚本中。本脚本已集成了自动注册、临时邮箱处理、Token 提取及自动清理循环功能。

JavaScript

// ==UserScript==
// @name         Grok/X.ai 自动化注册机 (集成自动清理与循环版)
// @namespace    http://tampermonkey.net/
// @version      5.10
// @description  全自动流程：注册 -> 提取Token -> 清理Cookie -> 循环重启
// @author       Bytebender
// @match        *://*/*
// @match        https://x.ai/*
// @match        https://www.x.ai/*
// @match        https://accounts.x.ai/*
// @match        https://grok.com/*
// @match        https://www.grok.com/*
// @grant        GM_setValue
// @grant        GM_getValue
// @grant        GM_registerMenuCommand
// @grant        GM_notification
// @grant        GM_xmlhttpRequest
// @grant        GM_setClipboard
// @grant        GM_cookie
// @connect      mail.chatgpt.org.uk
// @connect      100.64.0.101
// @connect      api.x.ai
// @connect      x.ai
// @connect      grok.com
// @connect      www.grok.com
// @connect      accounts.x.ai
// @connect      127.0.0.1
// ==/UserScript==

(function() {
    'use strict';

    // ========================================================
    // 1. 随机数据生成工具
    // ========================================================

    function getRandomName() {
        const chars = 'abcdefghijklmnopqrstuvwxyz';
        const len = Math.floor(Math.random() * 5) + 4;
        let result = '';
        for (let i = 0; i < len; i++) {
            result += chars.charAt(Math.floor(Math.random() * chars.length));
        }
        return result.charAt(0).toUpperCase() + result.slice(1);
    }

    function getRandomPassword() {
        const lower = "abcdefghijklmnopqrstuvwxyz";
        const upper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
        const nums = "0123456789";
        const symbols = "!@#$%^&*";
        let pass = "";
        pass += lower[Math.floor(Math.random() * lower.length)];
        pass += upper[Math.floor(Math.random() * upper.length)];
        pass += nums[Math.floor(Math.random() * nums.length)];
        pass += symbols[Math.floor(Math.random() * symbols.length)];
        const allChars = lower + upper + nums + symbols;
        for (let i = 0; i < 8; i++) {
            pass += allChars[Math.floor(Math.random() * allChars.length)];
        }
        return pass.split('').sort(() => 0.5 - Math.random()).join('');
    }

    // ========================================================
    // 2. 任务编排配置
    // ========================================================
    const actions = [
        // --- 阶段一：Grok 首页跳转 ---
        {
            "step_name": "1. 点击 Grok 首页注册按钮",
            "type": "click",
            "selector": "a[href='/sign-up']",
            "url_keyword": "grok.com"
        },
        // --- 阶段二：选择注册方式 ---
        {
            "step_name": "2. 点击 'Sign up/Login with email'",
            "type": "click",
            "selector": "button",
            // 支持数组匹配，兼容 Sign up 和 Login 两种文案
            "text_content": ["Sign up with email", "Login with email"],
            "url_keyword": "accounts.x.ai"
        },
        // --- 阶段三：填写邮箱 ---
        {
            "step_name": "3. 自动申请并填写临时邮箱",
            "type": "get_email",
            "selector": "input[name='email'], input[type='email'], input[autocomplete='email']",
            "url_keyword": "accounts.x.ai"
        },
        // --- 阶段四：点击提交邮箱 ---
        {
            "step_name": "4. 点击 'Sign up' (提交邮箱)",
            "type": "click",
            "selector": "button[type='submit']",
            // 这里的按钮文本通常比较固定，但也可能变，暂时保持 Sign up
            "text_content": "Sign up"
        },
        // --- 阶段五：验证码 ---
        {
            "step_name": "5. 等待邮件验证码并自动填写",
            "type": "fill_code",
            "selector": "input[name='code'], input[autocomplete='one-time-code'], input[inputmode='numeric'], input[aria-label*='code']"
        },
        // --- 阶段六：填写个人信息 ---
        {
            "step_name": "6. 填写名 (First Name)",
            "type": "input",
            "selector": "input[name='givenName'], input[autocomplete='given-name']",
            "value": "__RANDOM__"
        },
        {
            "step_name": "7. 填写姓 (Last Name)",
            "type": "input",
            "selector": "input[name='familyName'], input[autocomplete='family-name']",
            "value": "__RANDOM__"
        },
        {
            "step_name": "8. 填写密码 (强密码)",
            "type": "input",
            "selector": "input[name='password'], input[type='password']",
            "value": "__RANDOM_PASS__"
        },
        // --- 阶段七：提交 ---
        {
            "step_name": "9. 点击最终提交",
            "type": "click",
            "selector": "button[type='submit']"
        },
        // --- 阶段八：提取 Token ---
        {
            "step_name": "10. 检查跳转并上传 Token",
            "type": "wait_url_and_upload",
            "target_url": "grok.com"
        },
        // --- 阶段九：清理环境并循环 ---
        {
            "step_name": "11. 清理 Cookie 并重启循环",
            "type": "clean_and_restart",
            "clean_targets": [
                "https://x.ai/",
                "https://www.x.ai/",
                "https://accounts.x.ai/",
                "https://grok.com/",
                "https://www.grok.com/"
            ]
        }
    ];

    // ========================================================
    // 3. 核心功能类
    // ========================================================

    function gmFetch(url, options) {
        return new Promise((resolve, reject) => {
            GM_xmlhttpRequest({
                url: url,
                method: options.method || 'GET',
                headers: options.headers || {},
                data: options.body || null,
                onload: (response) => {
                    if (response.status >= 200 && response.status < 300) {
                        try { resolve(JSON.parse(response.responseText)); }
                        catch (e) { resolve(response.responseText); }
                    } else { reject(new Error(`HTTP Error: ${response.status}`)); }
                },
                onerror: () => reject(new Error('Network Error')),
                ontimeout: () => reject(new Error('Timeout'))
            });
        });
    }

    class TempMailClient {
        constructor() {
            this.baseUrl = "https://mail.chatgpt.org.uk/api";
            this.headers = {
                "User-Agent": "Mozilla/5.0",
                "Origin": "https://mail.chatgpt.org.uk",
                "Referer": "https://mail.chatgpt.org.uk/"
            };
        }
        async getEmail() {
            const result = await gmFetch(`${this.baseUrl}/generate-email`, {
                method: "GET",
                headers: { ...this.headers, "content-type": "application/json" }
            });
            if (result && result.success && result.data?.email) return result.data.email;
            throw new Error("邮箱API返回异常");
        }
        async fetchMessages(email) {
            const url = `${this.baseUrl}/emails?email=${encodeURIComponent(email)}`;
            const result = await gmFetch(url, {
                method: "GET",
                headers: { ...this.headers, "cache-control": "no-cache" }
            });
            return (result.success && result.data?.emails) ? result.data.emails : [];
        }
        async waitForCode(email, timeoutSec = 120) {
            console.log(`[Mail] 开始监听 ${email} ...`);
            const startTime = Date.now();
            const codeRegex = /\b[A-Z0-9]{3}-[A-Z0-9]{3}\b|\b\d{6}\b/;
            return new Promise((resolve, reject) => {
                const timer = setInterval(async () => {
                    if (Date.now() - startTime > timeoutSec * 1000) {
                        clearInterval(timer);
                        reject(new Error("等待验证码超时"));
                    }
                    try {
                        const msgs = await this.fetchMessages(email);
                        if (msgs.length > 0) {
                            for (const msg of msgs) {
                                const content = (msg.subject || "") + " " + (msg.html_content || "");
                                const match = content.match(codeRegex);
                                if (match) {
                                    clearInterval(timer);
                                    resolve(match[0]);
                                    return;
                                }
                            }
                        }
                    } catch(e) { console.warn("Polling error:", e); }
                }, 3000);
            });
        }
    }

    async function extractAndUploadToken() {
        return new Promise((resolve, reject) => {
            GM_cookie.list({ name: "sso" }, (cookies, error) => {
                if (error || !cookies || cookies.length === 0) {
                    return reject(new Error("SSO Cookie missing"));
                }
                const ssoToken = cookies[0].value;
                console.log("获取到 Token:", ssoToken.substring(0, 10) + "...");

                GM_xmlhttpRequest({
                    url: "http://127.0.0.1:5000/api/tokens/add",
                    method: "POST",
                    headers: { "content-type": "application/json" },
                    data: JSON.stringify({ tokens: [ssoToken], token_type: "sso" }),
                    onload: (response) => {
                        if (response.status >= 200 && response.status < 300) {
                            console.log("Token 上传成功!");
                            resolve();
                        } else {
                            reject(new Error("Upload failed: " + response.responseText));
                        }
                    },
                    onerror: (err) => reject(err)
                });
            });
        });
    }

    function executeCleanCookies(targetUrls) {
        return new Promise((resolve) => {
            if (!targetUrls || targetUrls.length === 0) return resolve();
            let completed = 0;
            targetUrls.forEach(url => {
                GM_cookie.list({ url: url }, function(cookies, error) {
                    if (cookies && cookies.length > 0) {
                        cookies.forEach(c => {
                            GM_cookie.delete({ name: c.name, url: url }, () => {});
                        });
                    }
                    completed++;
                    if (completed === targetUrls.length) {
                        setTimeout(resolve, 800);
                    }
                });
            });
        });
    }

    function setNativeValue(element, value) {
        const valueSetter = Object.getOwnPropertyDescriptor(element, 'value').set;
        const prototype = Object.getPrototypeOf(element);
        const prototypeValueSetter = Object.getOwnPropertyDescriptor(prototype, 'value').set;
        if (valueSetter && valueSetter !== prototypeValueSetter) {
            prototypeValueSetter.call(element, value);
        } else {
            valueSetter.call(element, value);
        }
        element.dispatchEvent(new Event('input', { bubbles: true }));
    }

    // 增强版 waitForElement，支持文本内容匹配 (字符串或数组)
    const waitForElement = (selector, textContent = null, timeout = 10000) => {
        return new Promise((resolve, reject) => {
            const check = () => {
                const els = document.querySelectorAll(selector);
                for (const el of els) {
                    if (!textContent) {
                        return resolve(el);
                    }
                    const elText = el.textContent ? el.textContent.trim() : "";
                    if (Array.isArray(textContent)) {
                        if (textContent.includes(elText)) return resolve(el);
                    } else {
                        if (elText === textContent) return resolve(el);
                    }
                }
                // Shadow DOM 查找
                const allElements = document.querySelectorAll('*');
                for (const e of allElements) {
                    if (e.shadowRoot) {
                        const shadowEls = e.shadowRoot.querySelectorAll(selector);
                        for (const el of shadowEls) {
                            if (!textContent) {
                                return resolve(el);
                            }
                            const elText = el.textContent ? el.textContent.trim() : "";
                            if (Array.isArray(textContent)) {
                                if (textContent.includes(elText)) return resolve(el);
                            } else {
                                if (elText === textContent) return resolve(el);
                            }
                        }
                    }
                }
            };

            check();
            const observer = new MutationObserver(check);
            observer.observe(document.body, { childList: true, subtree: true });
            setTimeout(() => { observer.disconnect(); reject(new Error(`元素超时: ${selector} (text: ${textContent})`)); }, timeout);
        });
    };

    // ========================================================
    // 4. 自动化执行引擎
    // ========================================================
    const mailClient = new TempMailClient();
    let isRunning = GM_getValue('script_is_running', false);
    let currentIndex = GM_getValue('script_step_index', 0);

    console.log(`🚀 [注册机状态] Running: ${isRunning} | Step: ${currentIndex}`);

    // 自动启动逻辑
    if (location.href.includes("accounts.x.ai") && !isRunning) {
        console.log("检测到注册页，尝试自动接管...");
        if (currentIndex <= 1) {
             GM_setValue('script_is_running', true);
             isRunning = true;
             setTimeout(() => {
                 const bodyText = document.body.innerText;
                 const hasEmailBtn = bodyText.includes("Sign up with email") || bodyText.includes("Login with email");
                 const hasEmailInput = document.querySelector("input[name='email']");

                 if (hasEmailBtn) {
                     console.log("定位到: 选择注册方式页");
                     currentIndex = 1;
                 } else if (hasEmailInput) {
                     console.log("定位到: 填写邮箱页");
                     currentIndex = 2;
                 } else {
                     currentIndex = 1;
                 }
                 GM_setValue('script_step_index', currentIndex);
                 runCurrentStep();
             }, 1000);
        }
    }

    GM_registerMenuCommand(`▶️ 启动/继续`, () => {
        GM_setValue('script_is_running', true);
        isRunning = true;
        console.log("手动启动脚本...");
        runCurrentStep();
    });

    GM_registerMenuCommand("🔄 强制重置", () => {
        GM_setValue('script_step_index', 0);
        GM_setValue('script_is_running', false);
        GM_setValue('current_temp_email', '');
        location.reload();
    });

    async function runCurrentStep() {
        if (!GM_getValue('script_is_running', false)) return;

        if (currentIndex >= actions.length) {
            GM_setValue('script_step_index', 0);
            return location.reload();
        }

        const action = actions[currentIndex];
        console.log(`[Step ${currentIndex + 1}] ${action.step_name} (${action.type})`);

        if (action.url_keyword && !location.href.includes(action.url_keyword)) {
            console.log(`等待跳转到 ${action.url_keyword}...`);
            return setTimeout(runCurrentStep, 2000);
        }

        try {
            await new Promise(r => setTimeout(r, 2000));

            let el = null;
            if (action.selector) {
                el = await waitForElement(action.selector, action.text_content);
            }

            if (action.type === 'get_email') {
                const email = await mailClient.getEmail();
                console.log("获取邮箱:", email);
                GM_setValue('current_temp_email', email);
                GM_setClipboard(email);

                el.click(); el.focus();
                setNativeValue(el, email);
                el.dispatchEvent(new Event('change', { bubbles: true }));
                el.blur();
            }
            else if (action.type === 'fill_code') {
                const email = GM_getValue('current_temp_email');
                const rawCode = await mailClient.waitForCode(email);
                const code = rawCode.replace(/-/g, '');
                console.log('填入验证码:', code);

                el.scrollIntoView({block: "center"});
                el.click(); el.focus();
                const nativeSetter = Object.getOwnPropertyDescriptor(window.HTMLInputElement.prototype, "value").set;
                nativeSetter.call(el, code);
                el.dispatchEvent(new Event('input', { bubbles: true }));
                el.dispatchEvent(new Event('change', { bubbles: true }));
                await new Promise(r => setTimeout(r, 500));
                el.blur();
            }
            else if (action.type === 'input') {
                el.focus();
                let val = action.value;
                if (val === '__RANDOM__') val = getRandomName();
                if (val === '__RANDOM_PASS__') val = getRandomPassword();
                console.log(`[Input] 填写值: ${val}`);
                setNativeValue(el, val);
                el.blur();
            }
            else if (action.type === 'wait_url_and_upload') {
                if (!location.href.includes(action.target_url)) {
                    return setTimeout(runCurrentStep, 1500);
                }
                let retry = 0;
                while (retry < 5) {
                    try {
                        await extractAndUploadToken();
                        GM_notification({ text: 'Token 上传成功！准备清理...', title: '成功' });
                        break;
                    } catch (e) {
                        console.warn("Token提取失败，重试中...", e);
                        await new Promise(r => setTimeout(r, 2000));
                        retry++;
                    }
                }
            }
            else if (action.type === 'clean_and_restart') {
                GM_notification({ text: '清理 Cookie 并重启循环...', title: '系统维护' });
                await executeCleanCookies(action.clean_targets);
                GM_setValue('script_step_index', 0);
                GM_setValue('current_temp_email', '');
                console.log(">>> 循环重置完成，3秒后刷新");
                setTimeout(() => { window.location.href = "https://grok.com/"; }, 3000);
                return;
            }
            else if (action.type === 'click') {
                el.click();
            }

            currentIndex++;
            GM_setValue('script_step_index', currentIndex);
            setTimeout(runCurrentStep, 1500);

        } catch (e) {
            console.error("执行出错:", e);
        }
    }

    function tryStart() {
        if (isRunning) {
            setTimeout(runCurrentStep, 1500);
        }
    }

    if (document.readyState === 'complete' || document.readyState === 'interactive') {
        tryStart();
    } else {
        window.addEventListener('load', tryStart);
    }

})();

🔍 进阶调优建议
为了让这套系统跑得更稳，建议关注以下几个痛点：

邮箱服务稳定性：目前使用的临时邮箱接口若失效，建议替换为自建的 Mail Server 或更稳定的接码平台 API。

注册风控： Twitter/X 对自动化注册非常敏感。如果频繁出现“注册受限”，请尝试：

更换高质量 IP 代理。

适当增加 setTimeout 延迟参数，模拟更真实的人类点击间隔。

使用指纹浏览器环境（如 AdsPower, Hubstudio 等）运行脚本。

Cookie 清理：脚本中已包含 executeCleanCookies 函数，确保多账号之间不会发生 Session 污染，这一点至关重要。