什么是动态 CAPTCHA 参数？

动态 CAPTCHA 参数是每次 CAPTCHA 请求或用户会话重新生成的值。它们可能包括 token、challenge ID、context、rqdata 等，用于确认会话的唯一性并防止重复使用已解决的验证码结果。

动态参数和静态参数有什么区别？

静态参数（例如 sitekey）在同一个网站中保持不变，而动态参数会在每次请求时发生变化。这些动态值与特定用户会话以及 CAPTCHA 生成时间相关联。

为什么网站使用动态参数？

主要目的是防止自动化攻击。即使机器人成功解决了一次 CAPTCHA，也无法重复使用该结果，因为服务器每次都要求新的参数。这大大增加了脚本化和重放攻击的难度。

如何识别动态参数？

最简单的方法是使用 DevTools 对比多个请求：打开包含 CAPTCHA 的页面进入 Network 面板多次刷新页面对比参数值如果每次请求的值都不同，则说明它是动态参数。

为什么使用 CapMonster Cloud 等工具？

这些工具可以自动处理 CAPTCHA，即使涉及动态参数，因为这些参数是在页面加载和会话初始化过程中生成的。

动态验证码参数：它们是什么，如何识别和提取。利用动态数据成功解决验证码问题

验证码有哪些动态参数

验证码中的动态参数会根据所使用的解决方案、服务商以及具体的防护系统而有所不同。它们通常在会话期间或验证完成后生成。下面我们来了解这些主要类型：

Challenge（挑战）——本质上就是验证码本身，用户需要完成它以证明身份。它可以有多种形式，包括文本任务、图片选择或特定操作。Challenge 由服务器在页面加载时生成，并且对每个请求都是唯一的。用户完成 Challenge 后，服务器会验证答案，如果正确，则允许继续访问网站。
Token 用于验证用户会话并确认请求来自真实用户而非机器人。Token 可以在服务器端生成，并传递给客户端用于验证码流程中。通常 Token 在会话开始时或每次验证码请求时生成，并在验证码通过后发送回服务器进行验证。

除了 challenge 和 token 之外，还有一些针对不同验证码类型的附加参数，例如：

context（例如用于 AWS WAF）——包含与当前用户会话绑定的唯一数据。它通常在脚本 window.gokuProps 中生成：
```
window.gokuProps = {
            "key":"",
            "iv":"",
            "context":""
        };     
```
geetest_challenge 或 challenge（用于 GeeTest v.3）——用于将用户请求与特定验证会话关联的标识符。它通常通过如下 URL 生成（注意该链接包含时间戳以防止缓存）：
```
https://example.com/api/v1/gee-test/init-params?t=1730640766594  
```

在 GeeTest v.3 中还使用以下参数：

geetest_validate ——用于确认验证码已正确完成的代码。成功完成验证后生成，并证明验证已通过；
geetest_seccode ——额外的安全验证码，用于确认验证成功。
dataDome cookie（用于 DataDome）——由 DataDome 系统生成的 Cookie，用于追踪并检测自动化行为，并根据用户行为动态更新。
g-recaptcha-response（用于 reCAPTCHA）——验证码通过后生成的 token，用于提交到服务器进行验证。
cf_clearance（用于 Cloudflare 验证）——验证码通过后生成的 Cookie，用于访问受保护资源。

另外还需要提到以下参数：

s（或 sentinel/motionData）——可能包含鼠标移动与验证码交互的数据。
v（版本）——表示验证码版本，该值可能在服务器端更新，并且每个会话都需要对应的新版本值。

上述示例仅展示了部分会随会话变化的参数；实际上这些参数种类很多，并且不同验证码系统各不相同。了解它们的存在对于后续分析与成功处理验证码非常重要。

使用 CapMonster Cloud

在你分析并找到所有必要的验证码参数之后，下一步就是使用 CapMonster Cloud 创建并向服务器发送任务，以自动完成验证码的解决。将该工具集成到你的代码中非常简单。该服务支持多种编程语言，例如 Python、JavaScript、C#。你只需要选择合适的语言并安装用于使用它的官方库即可。

CapMonster Cloud 在 Python 中的集成示例：

首先在 CapMonster Cloud 注册并获取用于访问服务的 API 密钥。
安装库

在 Python 中，通过 pip 安装官方库：

pip install capmonstercloudclient

在你的代码中创建一个验证码任务并获取结果。以下是 Python 上解决 reCAPTCHA v2 的示例：

# https://github.com/CapMonsterCloud/capmonsterclient-python

import asyncio
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import RecaptchaV2Request
# from capmonstercloudclient.requests.baseRequestWithProxy import ProxyInfo  # 如果计划使用代理，请取消注释

API_KEY = "YOUR_API_KEY"  # 请填写您的 CapMonster Cloud API 密钥

async def solve_recaptcha_v2():
    client_options = ClientOptions(api_key=API_KEY)
    cap_monster_client = CapMonsterClient(options=client_options)

    # 基础示例（无代理）
    # CapMonster Cloud 会自动使用其代理
    recaptcha2_request = RecaptchaV2Request(
        websiteUrl="https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=high",
        websiteKey="6Lcg7CMUAAAAANphynKgn9YAgA4tQ2KI_iqRyTwd"
    )

    # 使用自定义代理的示例
    # 如果需要使用自己的代理，请取消以下注释
    # proxy = ProxyInfo(
    #     proxyType="http",
    #     proxyAddress="123.45.67.89",
    #     proxyPort=8080,
    #     proxyLogin="username",
    #     proxyPassword="password"
    # )

    # recaptcha2_request = RecaptchaV2Request(
    #     websiteUrl="https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=high",
    #     websiteKey="6Lcg7CMUAAAAANphynKgn9YAgA4tQ2KI_iqRyTwd",
    #     proxy=proxy,
    #     userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36"
    # )

    # 如有需要可以检查余额
    balance = await cap_monster_client.get_balance()
    print("余额:", balance)

    result = await cap_monster_client.solve_captcha(recaptcha2_request)
    print("解决结果:", result)

asyncio.run(solve_recaptcha_v2())

关于验证码类型及创建任务所需参数的详细信息，请参阅官方文档。

获取结果后，将其提交到需要验证的网页表单中。

Node.js

显示代码// https://github.com/CapMonsterCloud/capmonstercloud-client-js


// 导入必要的依赖
import { CapMonsterCloudClientFactory, ClientOptions, GeeTestRequest } from '@zennolab_com/capmonstercloud-client';

async function run() {
// 创建 CapMonster Cloud 客户端
  const cmcClient = CapMonsterCloudClientFactory.Create(new ClientOptions({
    clientKey: 'your_api_key', // 请替换为您的 CapMonsterCloud API 密钥
  }));

  // 通过 API 获取验证码参数
  const t = new Date().getTime();
  const response = await fetch(`https://example.com/api/v1/gee-test/init-params?t=${t}`);  // 通过 API 获取 GeeTest 动态参数。请确保使用正确的 URL
  const data = await response.json();
  
  const { challenge, gt } = data;

  const geeTestProxylessRequest = new GeeTestRequest({
    websiteURL: "https://example.com", // 验证码页面 URL
    gt: gt, // 从 API 获取的 gt 参数
    challenge: challenge, // 从 API 获取的 challenge 参数
  });

  const solutionResponse = await cmcClient.Solve(geeTestProxylessRequest);

  if (!solutionResponse || !solutionResponse.solution) {
    throw new Error('验证码未解决。');
  }

  console.log('验证码已解决:', solutionResponse.solution);
}

run()
  .then(() => {
    console.log('完成');
    process.exit(0);
  })
  .catch((err) => {
    console.error(err);
    process.exit(1);
  });

Python

显示代码# https://github.com/CapMonsterCloud/capmonsterclient-python

# 导入必要的依赖
import requests
import asyncio
import time
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import GeetestRequest

async def run():
    # 创建 CapMonster Cloud 客户端
    client_options = ClientOptions(api_key='your_api_key')  # 请替换为您的 CapMonsterCloud API 密钥
    cmc_client = CapMonsterClient(options=client_options)

    # 通过 API 获取验证码参数
    t = int(time.time() * 1000)  # 获取当前时间戳（毫秒）
    response = requests.get(f'https://example.com/api/v1/gee-test/init-params?t={t}')
    data = response.json()

    challenge = data.get('challenge')
    gt = data.get('gt')

    if not challenge or not gt:
        raise ValueError('无法获取验证码参数。')

    # 创建验证码解决请求
    gee_test_proxyless_request = GeetestRequest(
        websiteUrl='https://example.com',  # 验证码页面 URL
        gt=gt,  
        challenge=challenge 
    )

    # 发送验证码解决请求
    solution_response = await cmc_client.solve_captcha(gee_test_proxyless_request)

    if not solution_response or not solution_response:
        raise ValueError('验证码未解决。')

    print('验证码已解决:', solution_response)

asyncio.run(run())

显示代码

// https://github.com/CapMonsterCloud/capmonstercloud-client-dotnet

// 导入 CapMonster Cloud 库及必要依赖
using Zennolab.CapMonsterCloud.Requests;
using Zennolab.CapMonsterCloud;
using Newtonsoft.Json;

class Program
{
    static async Task Main(string[] args)
    {
        // 使用你的 CapMonster Cloud API 密钥配置客户端
        var clientOptions = new ClientOptions
        {
            ClientKey = "your_api_key" // 将此处替换为你的 CapMonster Cloud API 密钥
        };

        // 使用指定配置创建 CapMonster Cloud 客户端
        var cmCloudClient = CapMonsterCloudClientFactory.Create(clientOptions);

        // 创建用于发送请求的 HTTP 客户端
        using var httpClient = new HttpClient();

        // 获取当前时间戳用于请求
        var timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

        // 构造用于获取 GeeTest 验证码动态参数的 URL
        var requestUrl = $"https://example.com/api/v1/captcha/gee-test/init-params?t={timestamp}";

        // 发送请求并以字符串形式获取响应
        var response = await httpClient.GetStringAsync(requestUrl);
        dynamic data = JsonConvert.DeserializeObject(response);

        // 使用获取到的参数创建 GeeTest 验证码请求
        var geetestRequest = new GeeTestRequest
        {
            WebsiteUrl = "https://example.com/demo/geetest", // 验证码页面 URL
            Gt = data.gt, // 从响应中获取的 gt 参数
            Challenge = data.challenge // 从响应中获取的 challenge 参数
        };

        // 发送验证码解决请求并获取结果
        var geetestResult = await cmCloudClient.SolveAsync(geetestRequest);

        Console.WriteLine($"验证码解决结果:\n挑战值 (Challenge): {geetestResult.Solution.Challenge}\n验证值 (Validate):  {geetestResult.Solution.Validate}\n安全码 (SecCode):   {geetestResult.Solution.SecCode}");
    }
}

Node.js

显示代码// https://github.com/CapMonsterCloud/capmonstercloud-client-js

// 导入 CapMonster Cloud 库
import { Builder } from "selenium-webdriver";
import { Options } from "selenium-webdriver/chrome.js";
import { CapMonsterCloudClientFactory, ClientOptions, TurnstileRequest } from "@zennolab_com/capmonstercloud-client";

(async function example() {
  // 创建 Chrome 配置对象
  const options = new Options();

  // 创建并启动 Chrome 浏览器驱动
  const driver = await new Builder()
    .forBrowser("chrome")
    .setChromeOptions(options) // 设置 Chrome 配置
    .build();

  let params = null; // 用于存储验证码参数的变量

  try {
    while (!params) {
      // 打开验证码页面
      await driver.get(
        "https://example.com/challenge-page",
      ); // 验证码页面 URL

      // 在页面上执行 JavaScript 以捕获验证码参数
      await driver.executeScript(`
        window.turnstile = new Proxy(window.turnstile, {
          get(target, prop) {
            if (prop === 'render') {
              return function(a, b) {
                let p = {
                  websiteKey: b.sitekey,
                  websiteURL: window.location.href, 
                  data: b.cData, 
                  pagedata: b.chlPageData,
                  action: b.action,
                  userAgent: navigator.userAgent 
                };

                console.log(JSON.stringify(p)); 
                window.params = p; 
                window.turnstileCallback = b.callback; 
                return target.render.apply(this, arguments);
              }
            }
            return target[prop];
          }
        });
      `);

      // 从 window.params 获取参数
      params = await driver.executeAsyncScript(`
        const callback = arguments[arguments.length - 1]; // 获取回调函数以完成执行
        setTimeout(() => {
          callback(window.params); // 通过回调返回参数
        }, 5000);
      `);

      if (!params) {
        console.log("未获取到参数，正在刷新页面...");
        await driver.sleep(3000);
      }
    }

    console.log("参数：", params); // 输出获取到的参数

    // 使用 API 密钥创建 CapMonster Cloud 客户端
    const cmcClient = CapMonsterCloudClientFactory.Create(
      new ClientOptions({
        clientKey: "YOUR_API_KEY", // 替换为你的 CapMonster Cloud API 密钥
      }),
    );

    // 创建 Turnstile 验证码请求
    const turnstileRequest = new TurnstileRequest({
      websiteURL: params.websiteURL,
      websiteKey: params.websiteKey,
      data: params.data,
      action: params.action,
      cloudflareTaskType: "token",
      pageAction: "managed",
      pageData: params.pagedata,
    });

    // 发送验证码解决请求
    const response = await cmcClient.Solve(turnstileRequest);

    // 检查是否成功解决验证码
    if (!response || !response.solution) {
      throw new Error("验证码未解决。");
    }

    console.log("验证码已解决：", response.solution); // 输出验证码结果

    // 在页面中执行 JavaScript，将 token 传入 callback 函数
    await driver.executeScript(`
      window.turnstileCallback('${response.solution.token}'); // 将验证码 token 传递给回调函数
    `);
  } catch (err) {
    console.error("错误：", err);
  } finally {
    await driver.quit();
  }
})();

Python

显示代码# https://github.com/CapMonsterCloud/capmonsterclient-python

# 导入必要的依赖
import asyncio
from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService
from selenium.webdriver.chrome.options import Options
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import TurnstileRequest

# 使用 API 密钥配置 CapMonsterCloud
client_options = ClientOptions(api_key="your_api_key")  # 将其替换为你的 CapMonsterCloud API 密钥
cap_monster_client = CapMonsterClient(options=client_options)

# 用于获取验证码参数的函数
async def get_turnstile_params(driver):
    params = None  # 用于存储验证码参数的变量
    while not params: 
        driver.get("https://example.com")  # 打开带有验证码的网页

        # 执行 JavaScript 代码以拦截 render 函数并提取参数
        driver.execute_script("""
            window.turnstile = new Proxy(window.turnstile, {
                get(target, prop) {
                    if (prop === 'render') {
                        return function(a, b) {
                            let p = {
                                websiteKey: b.sitekey, 
                                websiteURL: window.location.href,  
                                data: b.cData, 
                                pagedata: b.chlPageData,
                                action: b.action,  
                                userAgent: navigator.userAgent 
                            };
                            console.log(JSON.stringify(p)); 
                            window.params = p;  
                            window.turnstileCallback = b.callback;
                            return target.render.apply(this, arguments);  
                        };
                    }
                    return target[prop];
                }
            });
        """)

        # 通过 execute_async_script 从全局变量 window.params 获取参数
        params = driver.execute_async_script("""
            const callback = arguments[arguments.length - 1];
            setTimeout(() => {
                callback(window.params);
            }, 5000); 
        """)

        if not params:
            print("未获取到参数，正在刷新页面...")
            await asyncio.sleep(3) 

    return params  # 返回获取到的参数

async def solve_turnstile(params):
    # 创建用于解决验证码的请求（使用 CapMonsterCloud）
    request = TurnstileRequest(
        websiteURL=params["websiteURL"], 
        websiteKey=params["websiteKey"], 
        data=params["data"],  
        action=params["action"], 
        pageAction="managed", 
        cloudflareTaskType="token", 
        pageData=params["pagedata"], 
        userAgent=params["userAgent"] 
    )
    # 发送验证码请求并获取 token
    response = await cap_monster_client.solve_captcha(request)
    return response["token"] 

async def main():
    chrome_options = Options()
    driver = webdriver.Chrome(service=ChromeService(), options=chrome_options)

    try:
        # 获取验证码参数
        params = await get_turnstile_params(driver)
        print("已获取参数:", params)

        # 解决验证码并获取 token
        token = await solve_turnstile(params)
        print("验证码已解决。Token:", token)

        # 执行 JavaScript，将 token 传递给 callback 函数
        driver.execute_script(f"window.turnstileCallback('{token}');")

    except Exception as e:
        # 处理可能发生的错误
        print(f"错误: {e}")

    finally:
        await asyncio.sleep(5)
        driver.quit()

asyncio.run(main())
                                        

显示代码

// https://github.com/CapMonsterCloud/capmonstercloud-client-dotnet

// 导入必要依赖
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using Zennolab.CapMonsterCloud;
using Zennolab.CapMonsterCloud.Requests;

class Program
{
    static async Task Main(string[] args)
    {
        // 使用 API 密钥配置 CapMonster Cloud
        var clientOptions = new ClientOptions
        {
            ClientKey = "your_api_key" // 将其替换为你的 CapMonster Cloud API 密钥
        };

        // 创建 CapMonster Cloud 客户端
        var cmCloudClient = CapMonsterCloudClientFactory.Create(clientOptions);

        // ChromeDriver 配置
        var chromeOptions = new ChromeOptions();

        // 初始化 Chrome 驱动
        using var driver = new ChromeDriver(chromeOptions);

        // 获取验证码参数
        var paramsObtained = await GetTurnstileParams(driver);
        Console.WriteLine("已获取参数: " + string.Join(", ", paramsObtained));

        // 创建验证码请求
        var turnstileRequest = new TurnstileRequest
        {
            WebsiteUrl = paramsObtained["websiteURL"].ToString(),
            WebsiteKey = paramsObtained["websiteKey"].ToString(),
            Data = paramsObtained["data"].ToString(),
            PageAction = paramsObtained["pageAction"].ToString(),
            CloudflareTaskType = "token",
            PageData = paramsObtained["pagedata"].ToString(),
            UserAgent = paramsObtained["userAgent"].ToString()
        };

        // 使用 CapMonster Cloud 解决验证码
        var turnstileResult = await cmCloudClient.SolveAsync(turnstileRequest);
        Console.WriteLine("验证码已解决。Token: " + turnstileResult.Solution.Value);

        // 将 token 传递到页面 callback 函数
        ((IJavaScriptExecutor)driver).ExecuteScript($"window.turnstileCallback('{turnstileResult.Solution.Value}');");

        await Task.Delay(5000);
    }

    // 获取验证码参数的函数
    static async Task<Dictionary<string, object>> GetTurnstileParams(IWebDriver driver)
    {
        Dictionary<string, object> paramsObtained = null; // 用于存储参数

        while (paramsObtained == null) // 循环直到获取参数
        {
            driver.Navigate().GoToUrl("https://example.com"); // 打开验证码页面

            // 执行 JavaScript 拦截验证码 render 并提取参数
            ((IJavaScriptExecutor)driver).ExecuteScript(@"
                window.turnstile = new Proxy(window.turnstile, {
                    get(target, prop) {
                        if (prop === 'render') {
                            return function(a, b) {
                                let p = {
                                    websiteURL: window.location.href, 
                                    websiteKey: b.sitekey,
                                    data: b.cData, 
                                    pageAction: b.action,
                                    pagedata: b.chlPageData, 
                                    userAgent: navigator.userAgent 
                                };
                                console.log(JSON.stringify(p)); 
                                window.params = p; 
                                window.turnstileCallback = b.callback; 
                                return target.render.apply(this, arguments); 
                            };
                        }
                        return target[prop]; 
                    }
                });
            ");

            // 从 window.params 获取参数
            paramsObtained = await Task.Run(() =>
            {
                return (Dictionary<string, object>)((IJavaScriptExecutor)driver).ExecuteAsyncScript(@"
                    const callback = arguments[arguments.length - 1]; // 回调函数用于结束执行
                    setTimeout(() => {
                        callback(window.params); // 通过 callback 返回参数
                    }, 5000); 
                ");
            });

            // 如果未获取到参数则等待重试
            if (paramsObtained == null)
            {
                Console.WriteLine("未获取到参数，正在重新加载页面...");
                await Task.Delay(3000);
            }
        }

        return paramsObtained; // 返回获取到的参数
    }
}

Node.js

显示代码// https://github.com/CapMonsterCloud/capmonstercloud-client-js

import { Buffer } from "buffer";
import {
  CapMonsterCloudClientFactory,
  ClientOptions,
  TurnstileRequest,
} from "@zennolab_com/capmonstercloud-client";

import { ProxyAgent } from "undici";

async function main() {
  const API_KEY = "YOUR_API_KEY_HERE";

  const URL = "https://www.example.com/"; // 替换为需要的 URL

  const cmcClient = CapMonsterCloudClientFactory.Create(
    new ClientOptions({ clientKey: API_KEY }),
  );

  // ===== 代理 =====
  const proxy = {
    proxyType: "http",
    proxyAddress: "PROXY_ADDRESS_HERE",
    proxyPort: 1234,
    proxyLogin: "PROXY_LOGIN_HERE",
    proxyPassword: "PROXY_PASSWORD_HERE",
  };

  const proxyUrl = `http://${proxy.proxyLogin}:${proxy.proxyPassword}@${proxy.proxyAddress}:${proxy.proxyPort}`;
  const dispatcher = new ProxyAgent(proxyUrl);

  const userAgent =
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36";

  // ===== 1. 获取 HTML =====
  const res = await fetch(URL, {
    dispatcher,
    headers: {
      // 设置所需请求头
      "User-Agent": userAgent,
      Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
    },
  });

  const html = await res.text();

  console.log("状态码:", res.status);

  const htmlBase64 = Buffer.from(html, "utf-8").toString("base64");

  // ===== 2. 向 CAPMONSTER CLOUD 发送请求 =====
  const turnstileRequest = new TurnstileRequest({
    websiteURL: URL,
    websiteKey: "xxxxx",
    cloudflareTaskType: "cf_clearance",
    proxy,
    htmlPageBase64: htmlBase64,
    userAgent,
  });

  const result = await cmcClient.Solve(turnstileRequest);

  const cookie = result.solution?.cf_clearance || result.solution;

  console.log("cf_clearance:", cookie);

  // ==========================
  // 设置 COOKIE
  // ==========================
  const cookieHeader = `cf_clearance=${cookie}`;

  // ===== 3. 携带 Cookie 重新请求 =====
  const res2 = await fetch(URL, {
    dispatcher,
    headers: {
      // 设置所需请求头
      "User-Agent": userAgent,
      Accept: "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
      Cookie: cookieHeader,
    },
  });

  const html2 = await res2.text();

  console.log("最终状态码:", res2.status);
  console.log("最终 HTML 片段:\n", html2.slice(0, 800));
}

main().catch(console.error);

Python

显示代码// https://github.com/CapMonsterCloud/capmonsterclient-python

import asyncio
import base64
import requests
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import TurnstileRequest
from capmonstercloudclient.requests.baseRequestWithProxy import ProxyInfo  # 使用 ProxyInfo

API_KEY = "YOUR_API_KEY_HERE"  # 请填写你的 CapMonster Cloud API 密钥

async def solve_cf_clearance():
    client_options = ClientOptions(api_key=API_KEY)
    cap_monster_client = CapMonsterClient(options=client_options)

    # 代理配置示例
    proxy = ProxyInfo(
        proxyType="http",
        proxyAddress="PROXY_ADDRESS_HERE",
        proxyPort=1234,
        proxyLogin="PROXY_LOGIN_HERE",
        proxyPassword="PROXY_PASSWORD_HERE" 
    )

    # ===== 获取 HTML 页面并转换为 BASE64 =====
    URL = "https://www.example.com"
    UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36"
    
    PROXY_URL = f"http://{proxy.proxyLogin}:{proxy.proxyPassword}@{proxy.proxyAddress}:{proxy.proxyPort}"
    PROXY_DICT = {
        "http": PROXY_URL,
        "https": PROXY_URL
    }
    
    session = requests.Session()
    session.proxies.update(PROXY_DICT)
    # 设置必要的请求头
    session.headers.update({
        "User-Agent": UA,
        "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8",
        "Accept-Language": "en-US,en;q=0.9",
        "Accept-Encoding": "gzip, deflate, br",
        "Connection": "keep-alive",
        "Upgrade-Insecure-Requests": "1",
        "Sec-Fetch-Dest": "document",
        "Sec-Fetch-Mode": "navigate",
        "Sec-Fetch-Site": "none",
        "Sec-Fetch-User": "?1",
        "sec-ch-ua": '"Chromium";v="148", "Google Chrome";v="148", "Not:A-Brand";v="99"',
        "sec-ch-ua-mobile": "?0",
        "sec-ch-ua-platform": '"Windows"'
    })
    
    # 第一次请求：获取带验证码的页面
    resp = session.get(URL, verify=True, timeout=30)
    print("初始状态码:", resp.status_code)
    print("\n--- 原始页面片段 ---")
    print(resp.text[:800])
    print("\n----------------------------------\n")
    
    html_base64 = base64.b64encode(resp.content).decode()
    # ===== BASE64 提取结束 =====

    # Cloudflare cf_clearance 必须使用你的代理进行解决
    turnstile_request = TurnstileRequest(
        websiteURL=URL,
        websiteKey="xxxxx",
        cloudflareTaskType="cf_clearance",
        htmlPageBase64=html_base64,
        userAgent=UA,
        proxy=proxy
    )

    # 如有需要，可以检查余额
    balance = await cap_monster_client.get_balance()
    print("余额:", balance)

    result = await cap_monster_client.solve_captcha(turnstile_request)
    print("解决结果:", result)
    
    # 从结果中获取 cf_clearance
    cf_clearance_cookie = result.get("gRecaptchaResponse") or result.get("cf_clearance")
    print("cf_clearance:", cf_clearance_cookie)
    
    # 将 cf_clearance 写入 session cookie
    session.cookies.set("cf_clearance", cf_clearance_cookie)
    
    # 第二次请求（携带 cookie）
    resp2 = session.get(URL, verify=True, timeout=30)
    print("最终状态码:", resp2.status_code)
    print("\n--- 最终页面片段 ---")
    print(resp2.text[:800])

asyncio.run(solve_cf_clearance())
                                                

显示代码

// https://github.com/CapMonsterCloud/capmonstercloud-client-dotnet

using System;
using System.Net;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;
using Zennolab.CapMonsterCloud;
using Zennolab.CapMonsterCloud.Requests;

class Program
{
    static async Task Main(string[] args)
    {
        var API_KEY = "YOUR_API_KEY_HERE"; // 请替换为你的 CapMonster Cloud API 密钥

        var URL =
            "https://www.example.com";

        // ===================== CAPMONSTER CLOUD 客户端 =====================
        var cmCloudClient = CapMonsterCloudClientFactory.Create(
            new ClientOptions
            {
                ClientKey = API_KEY
            }
        );

        // ===================== 代理设置 =====================
        var proxyHost = "YOUR_PROXY_ADDRESS_HERE";
        var proxyPort = 1234;
        var proxyUser = "YOUR_PROXY_LOGIN_HERE";
        var proxyPass = "YOUR_PROXY_PASSWORD_HERE";

        var proxy = new WebProxy(proxyHost, proxyPort)
        {
            Credentials = new NetworkCredential(proxyUser, proxyPass)
        };

        // ===================== HTTP 客户端 =====================
        var handler = new HttpClientHandler
        {
            Proxy = proxy,
            UseProxy = true,
            UseCookies = true,
            CookieContainer = new CookieContainer()
        };

        var http = new HttpClient(handler);

        var userAgent =
            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36";
        // 设置必要的请求头
        http.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
        http.DefaultRequestHeaders.Accept.ParseAdd(
            "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
        );

        // ===================== 1. 初始请求 =====================
        var response = await http.GetAsync(URL);

        Console.WriteLine($"初始状态: {(int)response.StatusCode} {response.StatusCode}");

        var html = await response.Content.ReadAsStringAsync();

        Console.WriteLine(html.Substring(0, Math.Min(800, html.Length)));

        var htmlBase64 = Convert.ToBase64String(Encoding.UTF8.GetBytes(html));

        // ===================== 2. 解决 CF Challenge =====================
        var turnstileRequest = new TurnstileRequest
        {
            WebsiteUrl = URL,
            WebsiteKey = "xxxxx",
            CloudflareTaskType = "cf_clearance",
            HtmlPageBase64 = htmlBase64,
            UserAgent = userAgent,
            Proxy = new ProxyContainer(
                proxyHost,
                proxyPort,
                ProxyType.Http,
                proxyUser,
                proxyPass
            )
        };

        var result = await cmCloudClient.SolveAsync(turnstileRequest);

        var cookie = result.Solution?.Clearance?.ToString();

        Console.WriteLine("\ncf_clearance Cookie:");
        Console.WriteLine(cookie);

        if (string.IsNullOrEmpty(cookie))
        {
            Console.WriteLine("未获取到令牌");
            return;
        }

        // ===================== 设置 COOKIE =====================
        handler.CookieContainer.Add(
            new Uri(URL),
            new Cookie("cf_clearance", cookie)
        );

        // ===================== 3. 携带 COOKIE 的请求 =====================
        var finalResponse = await http.GetAsync(URL);

        Console.WriteLine($"最终状态: {(int)finalResponse.StatusCode} {finalResponse.StatusCode}");

        var finalHtml = await finalResponse.Content.ReadAsStringAsync();

        Console.WriteLine(finalHtml.Substring(0, Math.Min(800, finalHtml.Length)));
    }
}

Node.js

显示代码// https://github.com/CapMonsterCloud/capmonstercloud-client-js

// 导入必要依赖
import { Builder } from "selenium-webdriver";
import { Options } from "selenium-webdriver/chrome.js";
import {
  CapMonsterCloudClientFactory,
  ClientOptions,
  AmazonRequest,
} from "@zennolab_com/capmonstercloud-client";

(async function run() {
  // Chrome 设置
  const options = new Options();
  // options.addArguments("--headless=new");

  // 创建并启动 ChromeDriver
  const driver = await new Builder()
    .forBrowser("chrome")
    .setChromeOptions(options)
    .build();

  const pageUrl =
    "https://www.example.com/amazon-captcha-page"; // 替换为 Amazon 验证码页面 URL

  try {
    // ===== 1. 打开页面 =====
    await driver.get(pageUrl);

    // ===== 2. 获取 AWS WAF 验证码参数 =====
    const captchaParams = await driver.executeScript(() => {
      const gokuProps = window.gokuProps || {};
      const scripts = [...document.querySelectorAll("script")];

      return {
        websiteKey: gokuProps.key || null,
        context: gokuProps.context || null,
        iv: gokuProps.iv || null,
        challengeScriptUrl:
          scripts.find((s) => s.src.includes("challenge.js"))?.src || null,
        captchaScriptUrl:
          scripts.find((s) => s.src.includes("captcha.js"))?.src || null,
      };
    });

    console.log("验证码参数:");
    console.dir(captchaParams, { depth: null });

    // ===== 3. 创建 CapMonster Cloud 客户端 =====
    const cmcClient = CapMonsterCloudClientFactory.Create(
      new ClientOptions({
        clientKey: "YOUR_CAPMONSTER_API_KEY", // 替换为你的 CapMonster API 密钥
      }),
    );

    // ===== 4. 创建 AWS WAF 验证码解决请求 =====
    const request = new AmazonRequest({
      websiteURL: pageUrl,
      challengeScript: captchaParams.challengeScriptUrl,
      captchaScript: captchaParams.captchaScriptUrl,
      websiteKey: captchaParams.websiteKey,
      context: captchaParams.context,
      iv: captchaParams.iv,
      cookieSolution: true,
    });

    // ===== 5. 发送请求到 CapMonster Cloud =====
    const response = await cmcClient.Solve(request);

    console.log("完整响应:");
    console.dir(response, { depth: null });

    if (!response?.solution) {
      throw new Error("CapMonster Cloud 返回空解");
    }

    const solution = response.solution;

    const wafToken = solution.cookies?.["aws-waf-token"];

    if (!wafToken) {
      throw new Error(
        `未找到 AWS WAF Token:\n${JSON.stringify(solution, null, 2)}`,
      );
    }

    console.log("AWS WAF Token:");
    console.log(wafToken);

    // ==========================
    // 设置 COOKIE
    // ==========================
    await driver.manage().deleteCookie("aws-waf-token");

    await driver.manage().addCookie({
      name: "aws-waf-token",
      value: wafToken,
      path: "/",
      secure: true,
    });

    const cookies = await driver.manage().getCookies();

    console.log("设置后的 Cookies:");
    console.dir(cookies, { depth: null });

    // ===== 6. 刷新页面 =====
    console.log("正在刷新页面...");
    await driver.navigate().refresh();

    // 等待页面加载完成
    await driver.sleep(3000);

    console.log("当前 URL:");
    console.log(await driver.getCurrentUrl());
  } catch (err) {
    console.error("错误:");
    console.error(err);
  } finally {
    // await driver.quit();
  }
})()
  .then(() => {
    console.log("完成");
    process.exit(0);
  })
  .catch((err) => {
    console.error(err);
    process.exit(1);
  });

Python

显示代码# https://github.com/CapMonsterCloud/capmonsterclient-python

# 导入必要依赖
import asyncio
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import AmazonWafRequest
from selenium import webdriver
from selenium.webdriver.chrome.options import Options

CAPTCHA_URL = "https://www.example.com"  # 指定目标 URL

# ===== CHROMEDRIVER 配置 =====
chrome_options = Options()
# chrome_options.add_argument('--headless')  # 取消注释以启用后台运行
driver = webdriver.Chrome(options=chrome_options)

# ===== 获取验证码参数函数 =====
def get_captcha_params():
    driver.get(CAPTCHA_URL)
    captcha_params = driver.execute_script("""
        const gokuProps = window.gokuProps || {};
        const scripts = Array.from(document.querySelectorAll('script'));

        return {
            websiteKey: gokuProps.key || "Not found",
            context: gokuProps.context || "Not found",
            iv: gokuProps.iv || "Not found",
            challengeScriptUrl: scripts.find(script => script.src.includes('challenge.js'))?.src || "Not found",
            captchaScriptUrl: scripts.find(script => script.src.includes('captcha.js'))?.src || "Not found"
        };
    """)
    return captcha_params

# ===== CAPMONSTER CLOUD 配置 =====
client_options = ClientOptions(api_key="YOUR_API_KEY")  # 替换为你的 API 密钥
cap_monster_client = CapMonsterClient(options=client_options)

async def solve_captcha(captcha_params):

    # ===== 创建 CapMonsterCloud 请求并发送验证码求解 =====
    amazon_waf_request = AmazonWafRequest(
        websiteUrl=CAPTCHA_URL,
        challengeScript=captcha_params["challengeScriptUrl"],
        captchaScript=captcha_params["captchaScriptUrl"],
        websiteKey=captcha_params["websiteKey"],
        context=captcha_params["context"],
        iv=captcha_params["iv"],
        cookieSolution=True
    )
    return await cap_monster_client.solve_captcha(amazon_waf_request)

async def main():
    try:
        # ===== 1. 获取 AWS WAF 验证码参数 =====
        captcha_params = get_captcha_params()
        print("验证码参数:", captcha_params)

        # ===== 2. 发送请求到 CapMonster Cloud =====
        response = await solve_captcha(captcha_params)
        print("验证码求解结果:", response)

        if not response or "cookies" not in response:
            raise Exception("CapMonster 返回空结果")

        solution = response

        waf_token = solution["cookies"].get("aws-waf-token")

        if not waf_token:
            raise Exception(f"未找到 AWS WAF token:\n{solution}")

        print("AWS WAF token:")
        print(waf_token)

        # ==========================
        # 设置 COOKIE
        # ==========================

        # 删除旧 cookie
        driver.delete_cookie("aws-waf-token")

        # 添加新 cookie
        driver.add_cookie({
            "name": "aws-waf-token",
            "value": waf_token,
            "path": "/",
            "secure": True
        })

        # 检查 cookies
        cookies = driver.get_cookies()
        print("插入后的 Cookies:")
        print(cookies)

        # ===== 3. 刷新页面 =====
        print("正在刷新页面...")
        driver.refresh()

        # 等待加载
        await asyncio.sleep(3)

        print("当前 URL:")
        print(driver.current_url)

    except Exception as e:
        print("发生错误:", e)

    finally:
        driver.quit()

asyncio.run(main())

显示代码

// https://github.com/CapMonsterCloud/capmonstercloud-client-dotnet

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using Zennolab.CapMonsterCloud;
using Zennolab.CapMonsterCloud.Requests;

class Program
{
    static async System.Threading.Tasks.Task Main(string[] args)
    {
        const string CAPTCHA_URL = "https://www.example.com"; // 验证码页面 URL

        // ===== CHROMEDRIVER 配置 =====
        var chromeOptions = new ChromeOptions();
        // chromeOptions.AddArgument("--headless"); // 如有需要可启用
        using var driver = new ChromeDriver(chromeOptions);

        try
        {
            // ===== 1. 获取 AWS WAF 验证码参数 =====
            var captchaParams = GetCaptchaParams(driver, CAPTCHA_URL);

            // ===== 2. 创建 CAPMONSTER CLOUD 客户端 =====
            var clientOptions = new ClientOptions
            {
                ClientKey = "YOUR_API_KEY" // 替换为你的 API Key
            };

            var cmCloudClient = CapMonsterCloudClientFactory.Create(clientOptions);

            // ===== 3. 创建 AWS WAF 验证码请求 =====
            var amazonWafRequest = new AmazonWafRequest
            {
                WebsiteUrl = CAPTCHA_URL,
                ChallengeScript = captchaParams["challengeScriptUrl"],
                CaptchaScript = captchaParams["captchaScriptUrl"],
                WebsiteKey = captchaParams["websiteKey"],
                Context = captchaParams["context"],
                Iv = captchaParams["iv"],
                CookieSolution = true
            };

            // ===== 4. 发送请求到 CAPMONSTER CLOUD =====
            var solveResult = await cmCloudClient.SolveAsync(amazonWafRequest);

            Console.WriteLine("完整响应:");
            Console.WriteLine(solveResult);

            if (solveResult?.Solution?.Cookies == null)
                throw new Exception("CapMonster 返回空结果");

            var wafToken = solveResult.Solution.Cookies.ContainsKey("aws-waf-token")
                ? solveResult.Solution.Cookies["aws-waf-token"]
                : null;

            if (string.IsNullOrEmpty(wafToken))
                throw new Exception("未找到 AWS WAF token");

            Console.WriteLine("AWS WAF token:");
            Console.WriteLine(wafToken);

            // ==========================
            // 设置 COOKIE
            // ==========================

            // 删除旧 cookie
            try
            {
                driver.Manage().Cookies.DeleteCookieNamed("aws-waf-token");
            }
            catch { }

            // 获取域名
            var uri = new Uri(CAPTCHA_URL);
            var domain = uri.Host;

            // 添加新 cookie
            driver.Manage().Cookies.AddCookie(new Cookie(
                "aws-waf-token",
                wafToken,
                domain,
                "/",
                DateTime.Now.AddDays(1)
            ));

            // 检查 cookies
            var cookies = driver.Manage().Cookies.AllCookies;

            Console.WriteLine("插入后的 Cookies:");
            foreach (var cookie in cookies)
            {
                Console.WriteLine($"{cookie.Name} = {cookie.Value}");
            }

            // ===== 5. 刷新页面 =====
            Console.WriteLine("正在刷新页面...");
            driver.Navigate().Refresh();

            Thread.Sleep(3000);

            Console.WriteLine("当前 URL:");
            Console.WriteLine(driver.Url);
        }
        catch (Exception ex)
        {
            Console.WriteLine("错误:");
            Console.WriteLine(ex);
        }
        finally
        {
            driver.Quit();
        }
    }

    private static Dictionary<string, string> GetCaptchaParams(IWebDriver driver, string url)
    {
        driver.Navigate().GoToUrl(url);

        var jsExecutor = (IJavaScriptExecutor)driver;

        var result = jsExecutor.ExecuteScript(@"
            const gokuProps = window.gokuProps || {};
            const scripts = Array.from(document.querySelectorAll('script'));

            return {
                websiteKey: gokuProps.key || 'Not found',
                context: gokuProps.context || 'Not found',
                iv: gokuProps.iv || 'Not found',
                challengeScriptUrl: scripts.find(s => s.src.includes('challenge.js'))?.src || 'Not found',
                captchaScriptUrl: scripts.find(s => s.src.includes('captcha.js'))?.src || 'Not found'
            };
        ") as IDictionary<string, object>;

        return result.ToDictionary(
            k => k.Key,
            v => v.Value?.ToString() ?? "Not found"
        );
    }
}

稳定测试与降低限制风险的建议

动态参数处理和自动化测试通常会伴随一些复杂问题，例如请求限制、额外验证或页面元素动态更新等。以下是一些实用建议，可帮助测试过程更加稳定和可预测。

1. 使用 Undetected ChromeDriver

某些网站可能会检测标准的 Selenium WebDriver 特征，并启用额外的验证机制。

为了更真实地模拟网站访问行为，可以使用 undetected_chromedriver，它有助于让浏览器更接近普通用户环境。

pip install undetected-chromedriver

示例用法：

import undetected_chromedriver.v2 as uc

options = uc.ChromeOptions()
options.add_argument("--headless")  # 无头模式运行
options.add_argument("--disable-blink-features=AutomationControlled")

driver = uc.Chrome(options=options)
driver.get("https://example.com")

print(driver.page_source)

driver.quit()

2. 模拟用户行为

在测试过程中，建议模拟真实用户与网站的交互行为。不要连续过快执行操作，建议在操作之间加入随机延迟：

import time
import random

time.sleep(random.uniform(1, 3))  # 延迟1到3秒

页面滚动：某些元素只有在滚动后才会加载：

driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")

鼠标移动：可以使用 pyautogui 或 selenium-wire 等库模拟鼠标行为

3. 使用代理服务器
代理可以帮助避免 IP 被封锁：

使用代理轮换机制，并确保代理地理位置与目标网站区域一致：

from selenium.webdriver.common.proxy import Proxy, ProxyType

proxy = Proxy()
proxy.proxy_type = ProxyType.MANUAL
proxy.http_proxy = "http://username:password@proxy_ip:port"

capabilities = webdriver.DesiredCapabilities.CHROME
proxy.add_to_capabilities(capabilities)

driver = webdriver.Chrome(desired_capabilities=capabilities)

4. 更新 user-agent 和请求头

options.add_argument("user-agent=您的 User-Agent")

总结：长期稳定运行避免封锁的建议

避免过于频繁的请求。
注意测试目标资源的负载情况。
使用真实的延迟与交互行为。
同时测试普通模式与无头模式。
定期更新浏览器和自动化工具库。

结论

动态参数与验证码处理是一个非常有趣的过程，它可以帮助更好地理解 Web 安全机制的工作方式。在本文中，我们详细讲解了关键内容：从如何识别与分析动态参数，到如何提取它们并高效解决验证码。

我们还提供了 JavaScript（Node.js）、Python 和 C# 的代码示例，帮助你更轻松地学习如何提取必要数据，并使用 CapMonster Cloud 自动化验证码处理。

同时也介绍了用于模拟用户行为和代理服务器的工具。使用 Selenium、Puppeteer、Playwright、Undetected ChromeDriver、优质代理、User-Agent 轮换以及用户行为模拟，可以帮助你绕过许多限制。

需要注意的是请求频率，并遵守网站使用规则，以确保自动化既高效又合规。祝你在项目实现和开发中取得成功！

如何处理 CAPTCHA 的动态参数：完整指南

✅ 请求已发送

请求加入

CAPTCHA：在线安全的意义

CapMonster Cloud 的 Header 顺序：如何复现浏览器请求头并绕过反机器人保护

验证码与网站的其他安全防护机制

什么是验证码的动态参数

这些措施如何防止机器人

验证码有哪些动态参数

查找动态参数：使用开发者工具

如何判断哪些参数是动态的？

使用自动化工具：Selenium、Puppeteer、Playwright

Selenium、Puppeteer 和 Playwright 的通用能力

浏览器模拟器如何帮助识别动态内容？

处理动态内容的方法与参数：

Selenium

Puppeteer

Playwright

使用 CapMonster Cloud

CapMonster Cloud 在 Python 中的集成示例：

动态参数提取与验证码解决示例

GeeTest v3（通过 API 获取动态参数）：

Cloudflare Challenge

AWS WAF:

稳定测试与降低限制风险的建议

结论

常见问题

如何绕过反机器人系统：TLS 指纹识别与 CAPTCHA 处理

如何避免 CAPTCHA：真正有效的方法

Captcha Reader – 通过 API 访问的 AI 驱动验证码求解服务

2025年用于重复性网页任务的五大无代码自动化工具