How to Work with Dynamic CAPTCHA Parameters: A Complete Guide

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


// Import required dependencies
import { CapMonsterCloudClientFactory, ClientOptions, GeeTestRequest } from '@zennolab_com/capmonstercloud-client';

async function run() {
// Create CapMonster Cloud client
  const cmcClient = CapMonsterCloudClientFactory.Create(new ClientOptions({
    clientKey: 'your_api_key', // Replace with your CapMonsterCloud API key
  }));

  // Get captcha parameters via API
  const t = new Date().getTime();
  const response = await fetch(`https://example.com/api/v1/gee-test/init-params?t=${t}`);  // Retrieve dynamic GeeTest captcha parameters via API. Make sure you are using the correct URL for your case
  const data = await response.json();
  
  const { challenge, gt } = data;

  const geeTestProxylessRequest = new GeeTestRequest({
    websiteURL: "https://example.com", // Captcha page URL
    gt: gt, // gt parameter obtained via API
    challenge: challenge, // challenge parameter obtained via API
  });

  const solutionResponse = await cmcClient.Solve(geeTestProxylessRequest);

  if (!solutionResponse || !solutionResponse.solution) {
    throw new Error('Captcha not solved.');
  }

  console.log('Captcha solved:', solutionResponse.solution);
}

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

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

# Import required dependencies
import requests
import asyncio
import time
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import GeetestRequest

async def run():
    # Create CapMonster Cloud client
    client_options = ClientOptions(api_key='your_api_key')  # Replace with your CapMonsterCloud API key
    cmc_client = CapMonsterClient(options=client_options)

    # Get captcha parameters via API
    t = int(time.time() * 1000)  # Get current timestamp in milliseconds
    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('Failed to obtain captcha parameters.')

    # Create captcha solving request
    gee_test_proxyless_request = GeetestRequest(
        websiteUrl='https://example.com',  # Captcha page URL
        gt=gt,  
        challenge=challenge 
    )

    # Send captcha solving request
    solution_response = await cmc_client.solve_captcha(gee_test_proxyless_request)

    if not solution_response or not solution_response:
        raise ValueError('Captcha not solved.')

    print('Captcha solved:', solution_response)

asyncio.run(run())
                

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

// Import CapMonster Cloud library and required dependencies
using Zennolab.CapMonsterCloud.Requests;
using Zennolab.CapMonsterCloud;
using Newtonsoft.Json;

class Program
{
    static async Task Main(string[] args)
    {
        // Client setup with your CapMonster Cloud API key
        var clientOptions = new ClientOptions
        {
            ClientKey = "your_api_key" // Replace with your CapMonster Cloud API key
        };

        // Creating CapMonster Cloud client with the specified settings
        var cmCloudClient = CapMonsterCloudClientFactory.Create(clientOptions);

        // Creating HTTP client for sending requests
        using var httpClient = new HttpClient();

        // Getting current timestamp for the request
        var timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

        // Forming URL to get dynamic GeeTest captcha parameters
        var requestUrl = $"https://example.com/api/v1/captcha/gee-test/init-params?t={timestamp}";

        // Sending request and receiving response as string
        var response = await httpClient.GetStringAsync(requestUrl);
        dynamic data = JsonConvert.DeserializeObject(response);

        // Creating GeeTest captcha solving request with obtained parameters
        var geetestRequest = new GeeTestRequest
        {
            WebsiteUrl = "https://example.com/demo/geetest", // Captcha page URL
            Gt = data.gt, // gt parameter obtained from response
            Challenge = data.challenge // challenge parameter obtained from response
        };

        // Sending captcha solving request and receiving result
        var geetestResult = await cmCloudClient.SolveAsync(geetestRequest);

        Console.WriteLine($"Captcha solution:\nChallenge: {geetestResult.Solution.Challenge}\nValidate:  {geetestResult.Solution.Validate}\nSecCode:   {geetestResult.Solution.SecCode}");
    }
}

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

// Import required libraries
import { Builder } from "selenium-webdriver";
import { Options } from "selenium-webdriver/chrome.js";
import { CapMonsterCloudClientFactory, ClientOptions, TurnstileRequest } from "@zennolab_com/capmonstercloud-client";

(async function example() {
  // Create Chrome options object
  const options = new Options();

  // Create and start Chrome WebDriver
  const driver = await new Builder()
    .forBrowser("chrome")
    .setChromeOptions(options) // Set Chrome options
    .build();

  let params = null; // Variable to store captcha parameters

  try {
    while (!params) {
      // Open captcha page
      await driver.get(
        "https://example.com/challenge-page",
      ); // URL of the captcha page

      // Execute JavaScript on the page to capture captcha parameters
      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];
          }
        });
      `);

      // Get parameters from global variable window.params
      params = await driver.executeAsyncScript(`
        const callback = arguments[arguments.length - 1]; // Get callback to finish execution
        setTimeout(() => {
          callback(window.params); // Pass parameters through callback
        }, 5000);
      `);

      if (!params) {
        console.log("Parameters not received, reloading page...");
        await driver.sleep(3000);
      }
    }

    console.log("Parameters:", params); // Output received parameters

    // Create CapMonster Cloud client using API key
    const cmcClient = CapMonsterCloudClientFactory.Create(
      new ClientOptions({
        clientKey: "YOUR_API_KEY", // Replace with your CapMonster Cloud API key
      }),
    );

    // Create request to solve Turnstile captcha using received parameters
    const turnstileRequest = new TurnstileRequest({
      websiteURL: params.websiteURL,
      websiteKey: params.websiteKey,
      data: params.data,
      action: params.action,
      cloudflareTaskType: "token",
      pageAction: "managed",
      pageData: params.pagedata,
    });

    // Send captcha solving request
    const response = await cmcClient.Solve(turnstileRequest);

    // Check if captcha is solved
    if (!response || !response.solution) {
      throw new Error("Captcha not solved.");
    }

    console.log("Captcha solved:", response.solution); // Output captcha solution

    // Execute JavaScript on the page to pass token to callback function
    await driver.executeScript(`
      window.turnstileCallback('${response.solution.token}'); // Pass solved token to callback function
    `);
  } catch (err) {
    console.error("Error:", err);
  } finally {
    await driver.quit();
  }
})();

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

# Import required dependencies
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

# CapMonsterCloud configuration using API key
client_options = ClientOptions(api_key="your_api_key")  # Replace with your CapMonsterCloud API key
cap_monster_client = CapMonsterClient(options=client_options)

# Function to get captcha parameters
async def get_turnstile_params(driver):
    params = None  # Variable to store captcha parameters
    while not params: 
        driver.get("https://example.com")  # Open captcha webpage

        # Execute JavaScript code to intercept render function and extract parameters
        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];
                }
            });
        """)

        # Extract parameters from global variable `window.params` using execute_async_script
        params = driver.execute_async_script("""
            const callback = arguments[arguments.length - 1];
            setTimeout(() => {
                callback(window.params);
            }, 5000); 
        """)

        if not params:
            print("Parameters not received, reloading page...")
            await asyncio.sleep(3) 

    return params  # Return extracted parameters

async def solve_turnstile(params):
    # Create request to solve captcha using 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"] 
    )
    # Send captcha solving request and get 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:
        # Get captcha parameters
        params = await get_turnstile_params(driver)
        print("Parameters received:", params)

        # Solve captcha and get token
        token = await solve_turnstile(params)
        print("Captcha solved. Token:", token)

        # Execute JavaScript to pass token to callback function
        driver.execute_script(f"window.turnstileCallback('{token}');")

    except Exception as e:
        # Handle errors if they occur
        print(f"Error: {e}")

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

asyncio.run(main())

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

// Import required dependencies
using OpenQA.Selenium;
using OpenQA.Selenium.Chrome;
using Zennolab.CapMonsterCloud;
using Zennolab.CapMonsterCloud.Requests;

class Program
{
    static async Task Main(string[] args)
    {
        // CapMonster Cloud settings using API key
        var clientOptions = new ClientOptions
        {
            ClientKey = "your_api_key" // Replace with your CapMonster Cloud API key
        };

        // Create client for working with CapMonster Cloud
        var cmCloudClient = CapMonsterCloudClientFactory.Create(clientOptions);

        // ChromeDriver settings
        var chromeOptions = new ChromeOptions();

        // Initialize Chrome driver
        using var driver = new ChromeDriver(chromeOptions);

        // Get captcha parameters
        var paramsObtained = await GetTurnstileParams(driver);
        Console.WriteLine("Parameters received: " + string.Join(", ", paramsObtained));

        // Create captcha solving request
        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()
        };

        // Solve captcha using CapMonster Cloud
        var turnstileResult = await cmCloudClient.SolveAsync(turnstileRequest);
        Console.WriteLine("Captcha solved. Token: " + turnstileResult.Solution.Value);

        // Pass token to callback function on the page
        ((IJavaScriptExecutor)driver).ExecuteScript($"window.turnstileCallback('{turnstileResult.Solution.Value}');");

        await Task.Delay(5000);
    }

    // Function to get captcha parameters
    static async Task<Dictionary<string, object>> GetTurnstileParams(IWebDriver driver)
    {
        Dictionary<string, object> paramsObtained = null; // Variable to store parameters

        while (paramsObtained == null) // Repeat until parameters are obtained
        {
            driver.Navigate().GoToUrl("https://example.com"); // Open captcha page

            // Execute JavaScript to intercept captcha parameters
            ((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]; 
                    }
                });
            ");

            // Extract parameters from global variable `window.params` via ExecuteAsyncScript
            paramsObtained = await Task.Run(() =>
            {
                return (Dictionary<string, object>)((IJavaScriptExecutor)driver).ExecuteAsyncScript(@"
                    const callback = arguments[arguments.length - 1]; // Callback to finish execution
                    setTimeout(() => {
                        callback(window.params); // Pass parameters via callback
                    }, 5000); 
                ");
            });

            // If parameters are not received, wait before retrying
            if (paramsObtained == null)
            {
                Console.WriteLine("Parameters not received, reloading page...");
                await Task.Delay(3000);
            }
        }

        return paramsObtained; // Return obtained parameters
    }
}

// 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/"; // Replace with the required URL

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

  // ===== PROXY =====
  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. FETCH HTML =====
  const res = await fetch(URL, {
    dispatcher,
    headers: {
      // Set required 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("Status:", res.status);

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

  // ===== 2. CAPMONSTER CLOUD REQUEST =====
  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 SETUP
  // ==========================
  const cookieHeader = `cf_clearance=${cookie}`;

  // ===== 3. SECOND REQUEST WITH COOKIE =====
  const res2 = await fetch(URL, {
    dispatcher,
    headers: {
      // Set required 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("Final status:", res2.status);
  console.log("Final HTML snippet:\n", html2.slice(0, 800));
}

main().catch(console.error);

# 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  # Using ProxyInfo

API_KEY = "YOUR_API_KEY_HERE"  # Specify your CapMonster Cloud API key

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

    # Proxy configuration example
    proxy = ProxyInfo(
        proxyType="http",
        proxyAddress="PROXY_ADDRESS_HERE",
        proxyPort=1234,
        proxyLogin="PROXY_LOGIN_HERE",
        proxyPassword="PROXY_PASSWORD_HERE" 
    )

    # ===== FETCH HTML PAGE AND CONVERT TO 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)
    # Set required headers
    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"'
    })
    
    # First request to fetch captcha page
    resp = session.get(URL, verify=True, timeout=30)
    print("Initial status:", resp.status_code)
    print("\n--- Source page snippet ---")
    print(resp.text[:800])
    print("\n----------------------------------\n")
    
    html_base64 = base64.b64encode(resp.content).decode()
    # ===== END BASE64 EXTRACTION =====

    # Cloudflare cf_clearance is solved only with your proxy
    turnstile_request = TurnstileRequest(
        websiteURL=URL,
        websiteKey="xxxxx",
        cloudflareTaskType="cf_clearance",
        htmlPageBase64=html_base64,
        userAgent=UA,
        proxy=proxy
    )

    # Optionally check balance
    balance = await cap_monster_client.get_balance()
    print("Balance:", balance)

    result = await cap_monster_client.solve_captcha(turnstile_request)
    print("Result:", result)
    
    # Extract cf_clearance from result
    cf_clearance_cookie = result.get("gRecaptchaResponse") or result.get("cf_clearance")
    print("cf_clearance:", cf_clearance_cookie)
    
    # Set cf_clearance cookie in session
    session.cookies.set("cf_clearance", cf_clearance_cookie)
    
    # Second request with cookies set
    resp2 = session.get(URL, verify=True, timeout=30)
    print("Final status:", resp2.status_code)
    print("\n--- Final page snippet ---")
    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"; // Replace with your CapMonster Cloud API key

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

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

        // ===================== PROXY SETUP =====================
        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 CLIENT =====================
        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";
        // Set required headers
        http.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
        http.DefaultRequestHeaders.Accept.ParseAdd(
            "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
        );

        // ===================== 1. INITIAL REQUEST =====================
        var response = await http.GetAsync(URL);

        Console.WriteLine($"Initial status: {(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 SOLUTION =====================
        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("Token not received");
            return;
        }

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

        // ===================== 3. REQUEST WITH COOKIE =====================
        var finalResponse = await http.GetAsync(URL);

        Console.WriteLine($"Final status: {(int)finalResponse.StatusCode} {finalResponse.StatusCode}");

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

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

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

// Import required dependencies
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 settings
  const options = new Options();
  // options.addArguments("--headless=new");

  // Create and launch ChromeDriver
  const driver = await new Builder()
    .forBrowser("chrome")
    .setChromeOptions(options) // Set Chrome options
    .build();

  const pageUrl =
    "https://www.example.com/amazon-captcha-page"; // Replace with Amazon captcha page URL

  try {
    // ===== 1. OPEN PAGE =====
    await driver.get(pageUrl);

    // ===== 2. GET AWS WAF CAPTCHA PARAMETERS =====
    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("CAPTCHA parameters:");
    console.dir(captchaParams, { depth: null });

    // ===== 3. CREATE CAPMONSTER CLOUD CLIENT =====
    const cmcClient = CapMonsterCloudClientFactory.Create(
      new ClientOptions({
        clientKey: "YOUR_CAPMONSTER_API_KEY", // Replace with your CapMonster API key
      }),
    );

    // ===== 4. CREATE AWS WAF CAPTCHA SOLUTION REQUEST =====
    const request = new AmazonRequest({
      websiteURL: pageUrl,
      challengeScript: captchaParams.challengeScriptUrl,
      captchaScript: captchaParams.captchaScriptUrl,
      websiteKey: captchaParams.websiteKey,
      context: captchaParams.context,
      iv: captchaParams.iv,
      cookieSolution: true,
    });

    // ===== 5. SEND REQUEST TO CAPMONSTER CLOUD =====
    const response = await cmcClient.Solve(request);

    console.log("Full response:");
    console.dir(response, { depth: null });

    if (!response?.solution) {
      throw new Error("CapMonster Cloud returned empty solution");
    }

    const solution = response.solution;

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

    if (!wafToken) {
      throw new Error(
        `AWS WAF token not found:\n${JSON.stringify(solution, null, 2)}`,
      );
    }

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

    // ==========================
    // COOKIE SETTING
    // ==========================
    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 after setting:");
    console.dir(cookies, { depth: null });

    // ===== 6. REFRESH PAGE =====
    console.log("Refreshing page...");
    await driver.navigate().refresh();

    // Allow time for page to load after refresh
    await driver.sleep(3000);

    console.log("Current URL:");
    console.log(await driver.getCurrentUrl());
  } catch (err) {
    console.error("ERROR:");
    console.error(err);
  } finally {
    // await driver.quit();
  }
})()
  .then(() => {
    console.log("DONE");
    process.exit(0);
  })
  .catch((err) => {
    console.error(err);
    process.exit(1);
  });

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

# Import required dependencies
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"  # Specify the target URL

# ===== CHROMEDRIVER SETUP =====
chrome_options = Options()
# chrome_options.add_argument('--headless')  # Uncomment to run in headless mode
driver = webdriver.Chrome(options=chrome_options)

# ===== FUNCTION TO GET CAPTCHA PARAMETERS =====
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 SETTINGS =====
client_options = ClientOptions(api_key="YOUR_API_KEY")  # Replace with your API key
cap_monster_client = CapMonsterClient(options=client_options)

async def solve_captcha(captcha_params):

    # ===== Create request for CapMonsterCloud and send CAPTCHA solving task =====
    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. GET AWS WAF CAPTCHA PARAMETERS =====
        captcha_params = get_captcha_params()
        print("CAPTCHA parameters:", captcha_params)

        # ===== 2. SEND REQUEST TO CAPMONSTER CLOUD =====
        response = await solve_captcha(captcha_params)
        print("CAPTCHA solving result:", response)

        if not response or "cookies" not in response:
            raise Exception("CapMonster returned empty solution")

        solution = response

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

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

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

        # ==========================
        # COOKIE SETTING
        # ==========================

        # Remove old cookies
        driver.delete_cookie("aws-waf-token")

        # Add new cookies
        driver.add_cookie({
            "name": "aws-waf-token",
            "value": waf_token,
            "path": "/",
            "secure": True
        })

        # Check cookies
        cookies = driver.get_cookies()
        print("Cookies after insertion:")
        print(cookies)

        # ===== 3. REFRESH PAGE =====
        print("Refreshing page...")
        driver.refresh()

        # Wait for page load
        await asyncio.sleep(3)

        print("Current URL:")
        print(driver.current_url)

    except Exception as e:
        print("An error occurred:", 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"; // CAPTCHA URL

        // ===== CHROMEDRIVER SETUP =====
        var chromeOptions = new ChromeOptions();
        // chromeOptions.AddArgument("--headless"); // optional
        using var driver = new ChromeDriver(chromeOptions);

        try
        {
            // ===== 1. GET AWS WAF CAPTCHA PARAMETERS =====
            var captchaParams = GetCaptchaParams(driver, CAPTCHA_URL);

            // ===== 2. CREATE CAPMONSTER CLOUD CLIENT =====
            var clientOptions = new ClientOptions
            {
                ClientKey = "YOUR_API_KEY" // Replace with your API key
            };

            var cmCloudClient = CapMonsterCloudClientFactory.Create(clientOptions);

            // ===== 3. CREATE AWS WAF CAPTCHA SOLUTION REQUEST =====
            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. SEND REQUEST TO CAPMONSTER CLOUD =====
            var solveResult = await cmCloudClient.SolveAsync(amazonWafRequest);

            Console.WriteLine("Full response:");
            Console.WriteLine(solveResult);

            if (solveResult?.Solution?.Cookies == null)
                throw new Exception("CapMonster returned empty solution");

            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 not found");

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

            // ==========================
            // COOKIE SETUP
            // ==========================

            // delete old cookie
            try
            {
                driver.Manage().Cookies.DeleteCookieNamed("aws-waf-token");
            }
            catch { }

            // get domain
            var uri = new Uri(CAPTCHA_URL);
            var domain = uri.Host;

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

            // cookie check
            var cookies = driver.Manage().Cookies.AllCookies;

            Console.WriteLine("Cookies after insertion:");
            foreach (var cookie in cookies)
            {
                Console.WriteLine($"{cookie.Name} = {cookie.Value}");
            }

            // ===== 5. REFRESH PAGE =====
            Console.WriteLine("Refreshing page...");
            driver.Navigate().Refresh();

            Thread.Sleep(3000);

            Console.WriteLine("Current URL:");
            Console.WriteLine(driver.Url);
        }
        catch (Exception ex)
        {
            Console.WriteLine("ERROR:");
            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"
        );
    }
}