Como trabalhar com parâmetros dinâmicos de CAPTCHA: guia completo

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

// Importamos as dependências necessárias

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

async function run() {
// Criamos o cliente do CapMonster Cloud
  const cmcClient = CapMonsterCloudClientFactory.Create(new ClientOptions({
    clientKey: 'your_api_key', // Substitua pela sua chave de API do CapMonster Cloud
  }));

  // Obtemos os parâmetros da captcha através da API
  const t = new Date().getTime();
  const response = await fetch(`https://example.com/api/v1/gee-test/init-params?t=${t}`);  // Obtemos os parâmetros dinâmicos da captcha GeeTest através da API. Certifique-se de utilizar o URL correto para o seu caso
  const data = await response.json();
  
  const { challenge, gt } = data;

  const geeTestProxylessRequest = new GeeTestRequest({
    websiteURL: "https://example.com", // URL da página com a captcha
    gt: gt, // Parâmetro gt obtido através da API
    challenge: challenge, // Parâmetro challenge obtido através da API
  });

  const solutionResponse = await cmcClient.Solve(geeTestProxylessRequest);

  if (!solutionResponse || !solutionResponse.solution) {
    throw new Error('Captcha não resolvida.');
  }

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

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

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

# Importamos as dependências necessárias

import requests
import asyncio
import time
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import GeetestRequest

async def run():
    # Criamos o cliente do CapMonster Cloud
    client_options = ClientOptions(api_key='your_api_key')  # Substitua pela sua chave de API do CapMonster Cloud
    cmc_client = CapMonsterClient(options=client_options)

    # Obtemos os parâmetros da captcha através da API
    t = int(time.time() * 1000)  # Obtemos o timestamp atual em milissegundos
    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('Não foi possível obter os parâmetros da captcha.')

    # Criamos uma solicitação para resolver a captcha
    gee_test_proxyless_request = GeetestRequest(
        websiteUrl='https://example.com',  # URL da página com a captcha
        gt=gt,
        challenge=challenge
    )

    # Enviamos a solicitação para resolver a captcha
    solution_response = await cmc_client.solve_captcha(gee_test_proxyless_request)

    if not solution_response or not solution_response:
        raise ValueError('Captcha não resolvida.')

    print('Captcha resolvida:', solution_response)

asyncio.run(run())
                                

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


// Importamos a biblioteca CapMonster Cloud e as dependências necessárias

using Zennolab.CapMonsterCloud.Requests;
using Zennolab.CapMonsterCloud;
using Newtonsoft.Json;

class Program
{
    static async Task Main(string[] args)
    {
        // Configuração do cliente com a sua chave de API do CapMonster Cloud
        var clientOptions = new ClientOptions
        {
            ClientKey = "your_api_key" // Substitua pela sua chave de API do CapMonster Cloud
        };

        // Criação do cliente CapMonster Cloud utilizando as configurações fornecidas
        var cmCloudClient = CapMonsterCloudClientFactory.Create(clientOptions);

        // Criação do cliente HTTP para envio de requisições
        using var httpClient = new HttpClient();

        // Obtemos o timestamp atual para a requisição
        var timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

        // Construímos a URL para obter os parâmetros dinâmicos da captcha GeeTest
        var requestUrl = $"https://example.com/api/v1/captcha/gee-test/init-params?t={timestamp}";

        // Enviamos a requisição e recebemos a resposta como string
        var response = await httpClient.GetStringAsync(requestUrl);
        dynamic data = JsonConvert.DeserializeObject(response);

        // Criamos uma solicitação para resolver a captcha GeeTest com os parâmetros obtidos
        var geetestRequest = new GeeTestRequest
        {
            WebsiteUrl = "https://example.com/demo/geetest", // URL da página com a captcha
            Gt = data.gt, // Parâmetro gt obtido da resposta
            Challenge = data.challenge // Parâmetro challenge obtido da resposta
        };

        // Envio da solicitação para resolver a captcha e obtenção do resultado
        var geetestResult = await cmCloudClient.SolveAsync(geetestRequest);

        Console.WriteLine($"Solução da captcha:\nChallenge: {geetestResult.Solution.Challenge}\nValidate:  {geetestResult.Solution.Validate}\nSecCode:   {geetestResult.Solution.SecCode}");
    }
}

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

// Importamos a biblioteca 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() {
  // Criação do objeto de configurações para o Chrome
  const options = new Options();

  // Criação e inicialização do driver para o navegador Chrome
  const driver = await new Builder()
    .forBrowser("chrome")
    .setChromeOptions(options) // Definimos as configurações do Chrome
    .build();

  let params = null; // Variável para armazenar os parâmetros da captcha

  try {
    while (!params) {
      // Abertura da página com a captcha
      await driver.get(
        "https://example.com/challenge-page",
      ); // URL da página com a captcha

      // Execução de JavaScript na página para capturar os parâmetros da captcha
      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];
          }
        });
      `);

      // Obtenção dos parâmetros da variável global window.params
      params = await driver.executeAsyncScript(`
        const callback = arguments[arguments.length - 1]; // Obtém o callback para finalizar
        setTimeout(() => {
          callback(window.params); // Passa os parâmetros através do callback
        }, 5000);
      `);

      if (!params) {
        console.log("Parâmetros não encontrados, recarregando a página...");
        await driver.sleep(3000);
      }
    }

    console.log("Parâmetros:", params); // Exibimos os parâmetros obtidos

    // Criação do cliente CapMonster Cloud usando a API key
    const cmcClient = CapMonsterCloudClientFactory.Create(
      new ClientOptions({
        clientKey: "YOUR_API_KEY", // Substitua pela sua chave de API do CapMonster Cloud
      }),
    );

    // Criação da requisição para resolver a captcha Turnstile com os parâmetros obtidos
    const turnstileRequest = new TurnstileRequest({
      websiteURL: params.websiteURL,
      websiteKey: params.websiteKey,
      data: params.data,
      action: params.action,
      cloudflareTaskType: "token",
      pageAction: "managed",
      pageData: params.pagedata,
    });

    // Envio da requisição para resolver a captcha
    const response = await cmcClient.Solve(turnstileRequest);

    // Verificação se a captcha foi resolvida
    if (!response || !response.solution) {
      throw new Error("Captcha não resolvida.");
    }

    console.log("Captcha resolvida:", response.solution); // Exibimos a solução da captcha

    // Execução de JavaScript na página para enviar o token obtido para a função callback
    await driver.executeScript(`
      window.turnstileCallback('${response.solution.token}'); // Envia o token da solução da captcha para a função callback
    `);
  } catch (err) {
    console.error("Erro:", err);
  } finally {
    await driver.quit();
  }
})();

# https://github.com/CapMonsterCloud/capmonstercloud-client-python

# Importamos as dependências necessárias
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

# Configuração do CapMonsterCloud utilizando a chave de API
client_options = ClientOptions(api_key="your_api_key")  # Substitua pela sua chave de API do CapMonsterCloud
cap_monster_client = CapMonsterClient(options=client_options)

# Função para obter os parâmetros da captcha
async def get_turnstile_params(driver):
    params = None  # Variável para armazenar os parâmetros da captcha
    while not params: 
        driver.get("https://example.com")  # Abrimos a página web com a captcha

        # Executamos código JavaScript para interceptar a função render e extrair os parâmetros
        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];
                }
            });
        """)

        # Extraímos os parâmetros da variável global `window.params` usando execute_async_script
        params = driver.execute_async_script("""
            const callback = arguments[arguments.length - 1];
            setTimeout(() => {
                callback(window.params);
            }, 5000); 
        """)

        if not params:
            print("Parâmetros não encontrados, recarregando a página...")
            await asyncio.sleep(3) 

    return params  # Retornamos os parâmetros obtidos

async def solve_turnstile(params):
    # Criamos uma requisição para resolver a captcha usando 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"] 
    )
    # Enviamos a requisição para resolver a captcha e obtemos o 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:
        # Obtemos os parâmetros da captcha
        params = await get_turnstile_params(driver)
        print("Parâmetros obtidos:", params)

        # Resolvemos a captcha e obtemos o token
        token = await solve_turnstile(params)
        print("Captcha resolvida. Token:", token)

        # Executamos JavaScript para passar o token para a função callback
        driver.execute_script(f"window.turnstileCallback('{token}');")

    except Exception as e:
        # Tratamento de erros, caso ocorram
        print(f"Erro: {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)
    {
        // Configurações do CapMonster Cloud utilizando a chave de API
        var clientOptions = new ClientOptions
        {
            ClientKey = "your_api_key" // Substitua pela sua chave de API do CapMonster Cloud
        };

        // Criamos o cliente para trabalhar com o CapMonster Cloud
        var cmCloudClient = CapMonsterCloudClientFactory.Create(clientOptions);

        // Configurações do ChromeDriver
        var chromeOptions = new ChromeOptions();

        // Inicialização do driver do Chrome
        using var driver = new ChromeDriver(chromeOptions);

        // Obtenção dos parâmetros da captcha
        var paramsObtained = await GetTurnstileParams(driver);
        Console.WriteLine("Parâmetros obtidos: " + string.Join(", ", paramsObtained));

        // Criação da requisição para resolver a captcha
        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()
        };

        // Resolução da captcha usando o CapMonster Cloud
        var turnstileResult = await cmCloudClient.SolveAsync(turnstileRequest);
        Console.WriteLine("Captcha resolvida. Token: " + turnstileResult.Solution.Value);

        // Envio do token para a função callback na página
        ((IJavaScriptExecutor)driver).ExecuteScript($"window.turnstileCallback('{turnstileResult.Solution.Value}');");

        await Task.Delay(5000);
    }

    // Função para obter os parâmetros da captcha
    static async Task<Dictionary<string, object>> GetTurnstileParams(IWebDriver driver)
    {
        Dictionary<string, object> paramsObtained = null; // Variável para armazenar os parâmetros

        while (paramsObtained == null) // Repetimos até os parâmetros serem obtidos
        {
            driver.Navigate().GoToUrl("https://example.com"); // Abrimos a página com a captcha

            // Executamos JavaScript para interceptar os parâmetros da captcha
            ((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]; 
                    }
                });
            ");

            // Extraímos os parâmetros da variável global `window.params` usando ExecuteAsyncScript
            paramsObtained = await Task.Run(() =>
            {
                return (Dictionary<string, object>)((IJavaScriptExecutor)driver).ExecuteAsyncScript(@"
                    const callback = arguments[arguments.length - 1]; // Callback para finalizar a execução
                    setTimeout(() => {
                        callback(window.params); // Passamos os parâmetros através do callback
                    }, 5000); 
                ");
            });

            // Se os parâmetros não forem obtidos, aguardamos antes de tentar novamente
            if (paramsObtained == null)
            {
                Console.WriteLine("Parâmetros não encontrados, recarregando a página...");
                await Task.Delay(3000);
            }
        }

        return paramsObtained; // Retornamos os parâmetros obtidos
    }
}

// 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/"; // Substitua pelo URL desejado

  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. OBTER HTML =====
  const res = await fetch(URL, {
    dispatcher,
    headers: {
      // Defina os cabeçalhos necessários
      "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. REQUISIÇÃO AO 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);

  // ==========================
  // DEFINIÇÃO DE COOKIE
  // ==========================
  const cookieHeader = `cf_clearance=${cookie}`;

  // ===== 3. NOVA REQUISIÇÃO COM COOKIE =====
  const res2 = await fetch(URL, {
    dispatcher,
    headers: {
      // Defina os cabeçalhos necessários
      "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("Status final:", res2.status);
  console.log("Fragmento do HTML final:\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  # Utilizamos ProxyInfo

API_KEY = "YOUR_API_KEY_HERE"  # Insira a sua chave de API do CapMonster Cloud

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

    # Exemplo de configuração de proxy
    proxy = ProxyInfo(
        proxyType="http",
        proxyAddress="PROXY_ADDRESS_HERE",
        proxyPort=1234,
        proxyLogin="PROXY_LOGIN_HERE",
        proxyPassword="PROXY_PASSWORD_HERE" 
    )

    # ===== OBTER A PÁGINA HTML E CONVERTER PARA 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)
    # Defina os cabeçalhos necessários
    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"'
    })
    
    # Primeira requisição para obter a página com captcha
    resp = session.get(URL, verify=True, timeout=30)
    print("Status inicial:", resp.status_code)
    print("\n--- Fragmento da página inicial ---")
    print(resp.text[:800])
    print("\n----------------------------------\n")
    
    html_base64 = base64.b64encode(resp.content).decode()
    # ===== FIM DA EXTRAÇÃO BASE64 =====

    # Cloudflare cf_clearance é resolvido apenas com o seu proxy
    turnstile_request = TurnstileRequest(
        websiteURL=URL,
        websiteKey="xxxxx",
        cloudflareTaskType="cf_clearance",
        htmlPageBase64=html_base64,
        userAgent=UA,
        proxy=proxy
    )

    # Se necessário, pode verificar o saldo
    balance = await cap_monster_client.get_balance()
    print("Saldo:", balance)

    result = await cap_monster_client.solve_captcha(turnstile_request)
    print("Solução:", result)
    
    # Obtemos o cf_clearance do resultado
    cf_clearance_cookie = result.get("gRecaptchaResponse") or result.get("cf_clearance")
    print("cf_clearance:", cf_clearance_cookie)
    
    # Definimos o cookie cf_clearance na sessão
    session.cookies.set("cf_clearance", cf_clearance_cookie)
    
    # Segunda requisição com o cookie definido
    resp2 = session.get(URL, verify=True, timeout=30)
    print("Status final:", resp2.status_code)
    print("\n--- Fragmento da página final ---")
    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"; // Substitua pela sua chave de API do CapMonster Cloud

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

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

        // ===================== CONFIGURAÇÃO DO PROXY =====================
        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";
        // Defina os cabeçalhos necessários
        http.DefaultRequestHeaders.UserAgent.ParseAdd(userAgent);
        http.DefaultRequestHeaders.Accept.ParseAdd(
            "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"
        );

        // ===================== 1. REQUISIÇÃO INICIAL =====================
        var response = await http.GetAsync(URL);

        Console.WriteLine($"Status inicial: {(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. RESOLUÇÃO DO 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("\nCookie cf_clearance:");
        Console.WriteLine(cookie);

        if (string.IsNullOrEmpty(cookie))
        {
            Console.WriteLine("Token não obtido");
            return;
        }

        // ===================== DEFINIÇÃO DO COOKIE =====================
        handler.CookieContainer.Add(
            new Uri(URL),
            new Cookie("cf_clearance", cookie)
        );

        // ===================== 3. REQUISIÇÃO COM COOKIE =====================
        var finalResponse = await http.GetAsync(URL);

        Console.WriteLine($"Status final: {(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

// Importamos as dependências necessárias
import { Builder } from "selenium-webdriver";
import { Options } from "selenium-webdriver/chrome.js";
import {
  CapMonsterCloudClientFactory,
  ClientOptions,
  AmazonRequest,
} from "@zennolab_com/capmonstercloud-client";

(async function run() {
  // Configurações do Chrome
  const options = new Options();
  // options.addArguments("--headless=new");

  // Criamos e iniciamos o ChromeDriver
  const driver = await new Builder()
    .forBrowser("chrome")
    .setChromeOptions(options)
    .build();

  const pageUrl =
    "https://www.example.com/amazon-captcha-page"; // Substitua pelo URL da página com a captcha Amazon

  try {
    // ===== 1. ABRIMOS A PÁGINA =====
    await driver.get(pageUrl);

    // ===== 2. OBTEMOS OS PARÂMETROS DA CAPTCHA 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("Parâmetros da CAPTCHA:");
    console.dir(captchaParams, { depth: null });

    // ===== 3. CRIAMOS O CLIENTE CAPMONSTER CLOUD =====
    const cmcClient = CapMonsterCloudClientFactory.Create(
      new ClientOptions({
        clientKey: "YOUR_CAPMONSTER_API_KEY", // Substitua pela sua chave de API do CapMonster
      }),
    );

    // ===== 4. CRIAMOS A REQUISIÇÃO PARA RESOLVER A CAPTCHA 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. ENVIAMOS A REQUISIÇÃO PARA O CAPMONSTER CLOUD =====
    const response = await cmcClient.Solve(request);

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

    if (!response?.solution) {
      throw new Error("CapMonster Cloud retornou uma solução vazia");
    }

    const solution = response.solution;

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

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

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

    // ==========================
    // DEFINIÇÃO DE 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 após a configuração:");
    console.dir(cookies, { depth: null });

    // ===== 6. ATUALIZAMOS A PÁGINA =====
    console.log("Atualizando a página...");
    await driver.navigate().refresh();

    // Aguardamos o carregamento da página após a atualização
    await driver.sleep(3000);

    console.log("URL atual:");
    console.log(await driver.getCurrentUrl());
  } catch (err) {
    console.error("ERRO:");
    console.error(err);
  } finally {
    // await driver.quit();
  }
})()
  .then(() => {
    console.log("CONCLUÍDO");
    process.exit(0);
  })
  .catch((err) => {
    console.error(err);
    process.exit(1);
  });
                                

# https://github.com/CapMonsterCloud/capmonstercloud-client-python

# Importação das dependências necessárias
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"  # Indique a URL desejada

# ===== CONFIGURAÇÃO DO CHROMEDRIVER =====
chrome_options = Options()
# chrome_options.add_argument('--headless')  # Descomente para executar em segundo plano
driver = webdriver.Chrome(options=chrome_options)

# ===== FUNÇÃO PARA OBTER PARÂMETROS DA CAPTCHA =====
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

# ===== CONFIGURAÇÕES DO CAPMONSTER CLOUD =====
client_options = ClientOptions(api_key="YOUR_API_KEY")  # Substitua pela sua API key
cap_monster_client = CapMonsterClient(options=client_options)

async def solve_captcha(captcha_params):

    # ===== Criamos a requisição para o CapMonsterCloud e enviamos para resolução da captcha =====
    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. OBTER PARÂMETROS DA CAPTCHA AWS WAF =====
        captcha_params = get_captcha_params()
        print("Parâmetros da CAPTCHA:", captcha_params)

        # ===== 2. ENVIAR REQUISIÇÃO AO CAPMONSTER CLOUD =====
        response = await solve_captcha(captcha_params)
        print("Resultado da resolução da CAPTCHA:", response)

        if not response or "cookies" not in response:
            raise Exception("CapMonster retornou uma solução vazia")

        solution = response

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

        if not waf_token:
            raise Exception(f"Token AWS WAF não encontrado:\n{solution}")

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

        # ==========================
        # DEFINIÇÃO DE COOKIE
        # ==========================

        # Removemos cookies antigos
        driver.delete_cookie("aws-waf-token")

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

        # Verificamos cookies
        cookies = driver.get_cookies()
        print("Cookies após inserção:")
        print(cookies)

        # ===== 3. ATUALIZAMOS A PÁGINA =====
        print("Atualizando a página...")
        driver.refresh()

        # Aguardamos o carregamento
        await asyncio.sleep(3)

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

    except Exception as e:
        print("Ocorreu um erro:", 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 com CAPTCHA

        // ===== CONFIGURAÇÃO DO CHROMEDRIVER =====
        var chromeOptions = new ChromeOptions();
        // chromeOptions.AddArgument("--headless"); // se necessário
        using var driver = new ChromeDriver(chromeOptions);

        try
        {
            // ===== 1. OBTER PARÂMETROS DA AWS WAF CAPTCHA =====
            var captchaParams = GetCaptchaParams(driver, CAPTCHA_URL);

            // ===== 2. CRIAR CLIENTE CAPMONSTER CLOUD =====
            var clientOptions = new ClientOptions
            {
                ClientKey = "YOUR_API_KEY" // Substitua pela sua API key
            };

            var cmCloudClient = CapMonsterCloudClientFactory.Create(clientOptions);

            // ===== 3. CRIAR REQUISIÇÃO PARA RESOLVER AWS WAF CAPTCHA =====
            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. ENVIAR REQUISIÇÃO AO CAPMONSTER CLOUD =====
            var solveResult = await cmCloudClient.SolveAsync(amazonWafRequest);

            Console.WriteLine("Resposta completa:");
            Console.WriteLine(solveResult);

            if (solveResult?.Solution?.Cookies == null)
                throw new Exception("CapMonster retornou uma solução vazia");

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

            if (string.IsNullOrEmpty(wafToken))
                throw new Exception("Token AWS WAF não encontrado");

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

            // ==========================
            // DEFINIÇÃO DE COOKIE
            // ==========================

            // removemos o cookie antigo
            try
            {
                driver.Manage().Cookies.DeleteCookieNamed("aws-waf-token");
            }
            catch { }

            // obtemos o domínio
            var uri = new Uri(CAPTCHA_URL);
            var domain = uri.Host;

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

            // verificação de cookies
            var cookies = driver.Manage().Cookies.AllCookies;

            Console.WriteLine("Cookies após inserção:");
            foreach (var cookie in cookies)
            {
                Console.WriteLine($"{cookie.Name} = {cookie.Value}");
            }

            // ===== 5. ATUALIZAMOS A PÁGINA =====
            Console.WriteLine("Atualizando a página...");
            driver.Navigate().Refresh();

            Thread.Sleep(3000);

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