Как работать с динамическими параметрами капчи: полное руководство

// 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', // Замените на ваш API-ключ CapMonsterCloud
  }));

  // Получаем параметры капчи через API
  const t = new Date().getTime();
  const response = await fetch(`https://example.com/api/v1/gee-test/init-params?t=${t}`);  // Получаем динамические параметры для капчи GeeTest через API. Убедитесь, что используете правильный URL для вашего случая
  const data = await response.json();
  
  const { challenge, gt } = data;

  const geeTestProxylessRequest = new GeeTestRequest({
    websiteURL: "https://example.com", // URL страницы с капчей
    gt: gt, // Параметр gt, полученный через API
    challenge: challenge, // Параметр challenge, полученный через API
  });

  const solutionResponse = await cmcClient.Solve(geeTestProxylessRequest);

  if (!solutionResponse || !solutionResponse.solution) {
    throw new Error('Капча не решена.');
  }

  console.log('Капча решена:', 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 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')  # Замените на ваш API-ключ CapMonsterCloud
    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)
    {
        // Настройка клиента с вашим API-ключом CapMonster Cloud
        var clientOptions = new ClientOptions
        {
            ClientKey = "your_api_key" // Замените на ваш API-ключ CapMonster Cloud
        };

        // Создание клиента CapMonster Cloud с использованием заданных настроек
        var cmCloudClient = CapMonsterCloudClientFactory.Create(clientOptions);

        // Создание HTTP клиента для отправки запросов
        using var httpClient = new HttpClient();

        // Получаем текущий временной штамп для запроса
        var timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds();

        // Формируем URL для получения динамических параметров капчи GeeTest
        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($"Решение капчи:\nChallenge: {geetestResult.Solution.Challenge}\nValidate:  {geetestResult.Solution.Validate}\nSecCode:   {geetestResult.Solution.SecCode}");
    }
}

// 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]; // Получаем callback для завершения
        setTimeout(() => {
          callback(window.params); // Передаем параметры через callback
        }, 5000);
      `);

      if (!params) {
        console.log("Параметры не получены, перезагружаем страницу...");
        await driver.sleep(3000);
      }
    }

    console.log("Параметры:", params); // Выводим полученные параметры

    // Создание клиента CapMonster Cloud с использованием API-ключа
    const cmcClient = CapMonsterCloudClientFactory.Create(
      new ClientOptions({
        clientKey: "YOUR_API_KEY", // Замените на ваш API-ключ CapMonster Cloud
      }),
    );

    // Создание запроса для решения капчи 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 на странице для передачи полученного токена в callback функцию
    await driver.executeScript(`
      window.turnstileCallback('${response.solution.token}'); // Передаем токен решения капчи в callback функцию
    `);
  } catch (err) {
    console.error("Ошибка:", err);
  } finally {
    await driver.quit();
  }
})();

# 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

# Настройка CapMonsterCloud с использованием API-ключа
client_options = ClientOptions(api_key="your_api_key")  # Замените на ваш API-ключ CapMonsterCloud
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];
                }
            });
        """)

        # Извлекаем параметры из глобальной переменной `window.params` через execute_async_script
        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"] 
    )
    # Отправляем запрос на решение капчи и получаем токен
    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 = await solve_turnstile(params)
        print("Капча решена. Токен:", token)

        # Выполняем JavaScript для передачи токена в 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)
    {
        // Настройки CapMonster Cloud с использованием API-ключа
        var clientOptions = new ClientOptions
        {
            ClientKey = "your_api_key" // Замените на ваш API-ключ CapMonster Cloud
        };

        // Создаем клиент для работы с 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("Капча решена. Токен: " + turnstileResult.Solution.Value);

        // Передача токена в 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 для перехвата параметров капчи
            ((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` через ExecuteAsyncScript
            paramsObtained = await Task.Run(() =>
            {
                return (Dictionary<string, object>)((IJavaScriptExecutor)driver).ExecuteAsyncScript(@"
                    const callback = arguments[arguments.length - 1]; // Callback для завершения выполнения
                    setTimeout(() => {
                        callback(window.params); // Передаем параметры через callback
                    }, 5000); 
                ");
            });

            // Если параметры не получены, ждем перед повторной попыткой
            if (paramsObtained == null)
            {
                Console.WriteLine("Параметры не получены, перезагружаем страницу...");
                await Task.Delay(3000);
            }
        }

        return paramsObtained; // Возвращаем полученные параметры
    }
}

// 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);

# 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"  # Укажите ваш API-ключ CapMonster Cloud

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.cookies.set("cf_clearance", cf_clearance_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"; // Замените на ваш API-ключ CapMonster Cloud

        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("\nCookie cf_clearance:");
        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)));
    }
}

        

// 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"; // Замените на URL страницы с капчей Amazon

  try {
    // ===== 1. ОТКРЫВАЕМ СТРАНИЦУ =====
    await driver.get(pageUrl);

    // ===== 2. ПОЛУЧАЕМ ПАРАМЕТРЫ AWS WAF CAPTCHA =====
    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:");
    console.dir(captchaParams, { depth: null });

    // ===== 3. СОЗДАЕМ КЛИЕНТ CAPMONSTER CLOUD =====
    const cmcClient = CapMonsterCloudClientFactory.Create(
      new ClientOptions({
        clientKey: "YOUR_CAPMONSTER_API_KEY", // Замените на ваш API-ключ CapMonster
      }),
    );

    // ===== 4. СОЗДАЕМ ЗАПРОС НА РЕШЕНИЕ AWS WAF CAPTCHA =====
    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 не найден:\n${JSON.stringify(solution, null, 2)}`,
      );
    }

    console.log("Токен AWS WAF:");
    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);
  });

# 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)

# ===== ФУНКЦИЯ ДЛЯ ПОЛУЧЕНИЯ ПАРАМЕТРОВ 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

# ===== НАСТРОЙКИ 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 =====
        captcha_params = get_captcha_params()
        print("Параметры CAPTCHA:", captcha_params)

        # ===== 2. ОТПРАВЛЯЕМ ЗАПРОС В CAPMONSTER CLOUD =====
        response = await solve_captcha(captcha_params)
        print("Результат решения CAPTCHA:", 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
        # ==========================

        # Удаляем старые 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 after insertion:")
        print(cookies)

        # ===== 3. ОБНОВЛЯЕМ СТРАНИЦУ =====
        print("Refreshing page...")
        driver.refresh()

        # Ждём загрузку
        await asyncio.sleep(3)

        print("Current 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 с CAPTCHA

        // ===== НАСТРОЙКА CHROMEDRIVER =====
        var chromeOptions = new ChromeOptions();
        // chromeOptions.AddArgument("--headless"); // при необходимости
        using var driver = new ChromeDriver(chromeOptions);

        try
        {
            // ===== 1. ПОЛУЧАЕМ ПАРАМЕТРЫ AWS WAF CAPTCHA =====
            var captchaParams = GetCaptchaParams(driver, CAPTCHA_URL);

            // ===== 2. СОЗДАЕМ КЛИЕНТ CAPMONSTER CLOUD =====
            var clientOptions = new ClientOptions
            {
                ClientKey = "YOUR_API_KEY" // Замените на свой API-ключ
            };

            var cmCloudClient = CapMonsterCloudClientFactory.Create(clientOptions);

            // ===== 3. СОЗДАЕМ ЗАПРОС НА РЕШЕНИЕ 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. ОТПРАВЛЯЕМ ЗАПРОС В 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
            // ==========================

            // удаляем старую 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 after insertion:");
            foreach (var cookie in cookies)
            {
                Console.WriteLine($"{cookie.Name} = {cookie.Value}");
            }

            // ===== 5. ОБНОВЛЯЕМ СТРАНИЦУ =====
            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"
        );
    }
}