Como trabalhar com parâmetros dinâmicos de CAPTCHA: guia completo
Aprenda o que são parâmetros dinâmicos de CAPTCHA, como identificá-los e extraí-los, bem como como resolver CAPTCHAs com dados variáveis.

Captcha e outros métodos de proteção de sites
Hoje em dia já é difícil imaginar recursos web modernos sem o uso de alguns mecanismos de proteção, por exemplo, a captcha – uma verificação de que o visitante é um ser humano real e não um bot que pode representar uma ameaça potencial. Antigamente, eram principalmente captchas de texto, onde era necessário digitar símbolos de uma imagem em um campo especial ou responder a perguntas simples. Com o tempo, os sistemas de verificação de usuários e proteção de sites estão se tornando cada vez mais complexos para serem contornados por programas automatizados. Por outro lado, para visitantes reais, os desenvolvedores tentam minimizar possíveis inconvenientes – muitas vezes nem é possível perceber a presença dessa proteção, já que a verificação ocorre em segundo plano sem a participação do usuário.
Atualmente, a verificação não se baseia tanto na execução de um teste específico, mas sim na análise de um conjunto de fatores: comportamento do usuário, características do navegador, requisições de rede e muito mais. O site pode verificar cookies, fingerprint do dispositivo, execução de JavaScript e, adicionalmente, exibir uma captcha em caso de atividade suspeita.
O que são parâmetros dinâmicos de CAPTCHA
Outro nível de proteção é adicionado pelos chamados parâmetros dinâmicos. Esses parâmetros são criados e alterados a cada requisição de CAPTCHA. Eles servem como identificadores únicos para cada sessão de verificação e, ao contrário dos parâmetros estáticos (por exemplo, sitekey), que permanecem inalterados, os parâmetros dinâmicos são atualizados a cada requisição. Isso significa que um sistema automatizado não pode simplesmente reutilizar valores obtidos anteriormente para passar na verificação com sucesso.
Como essas medidas protegem contra bots
Sempre que um usuário solicita um CAPTCHA, o servidor gera um novo conjunto de dados (por exemplo, challenge, context, token e outros), único para aquela sessão.
Esses parâmetros impedem a reutilização de respostas e podem incluir informações sobre o usuário, sessão e timestamps. Mesmo que um bot consiga resolver um CAPTCHA, repetir o mesmo processo com outros parâmetros dinâmicos será difícil e exigirá recursos computacionais significativos.
Com base na análise de dados de sessão e comportamento, o site pode identificar atividade de bots e bloquear temporariamente dispositivos suspeitos, mesmo sem exibir um CAPTCHA.
Esses métodos são projetados para garantir que apenas usuários reais consigam passar pelo “turnstile”, enquanto bots são bloqueados ou têm suas tentativas de bypass dificultadas.
Quais são os tipos de parâmetros dinâmicos
Os parâmetros variáveis de CAPTCHA diferem dependendo da solução utilizada, do fornecedor e do tipo específico de sistema de proteção. Eles são gerados durante a sessão ou após sua conclusão. Vamos conhecer os principais tipos:
- Challenge (desafio) – é, essencialmente, o próprio elemento de CAPTCHA que o usuário deve resolver para confirmar sua identidade. Ele pode assumir diferentes formas, incluindo tarefas de texto, seleção de imagens ou execução de determinadas ações. O challenge é criado pelo servidor ao carregar a página e representa uma tarefa única para cada requisição. O usuário resolve o challenge, após isso o servidor verifica a resposta e, se estiver correta, permite que o usuário continue interagindo com o site.
- Token é usado para verificar a sessão do usuário e confirmar que a requisição vem de um usuário real e não de um bot. Os tokens podem ser gerados no lado do servidor e enviados ao cliente para uso durante o processo de resolução do CAPTCHA. O token geralmente é gerado no início da sessão ou a cada requisição ao CAPTCHA e, após a resolução bem-sucedida, é enviado de volta ao servidor para validação.
Além de challenge e token, existem parâmetros adicionais que podem ser específicos para diferentes tipos de CAPTCHA. Alguns deles são:
context (usado, por exemplo, em AWS WAF) – contém valores únicos vinculados à sessão atual do usuário. É gerado no script window.gokuProps:
window.gokuProps = { "key":"", "iv":"", "context":"" };geetest_challenge ou challenge (usado em GeeTest v.3) – identificador do CAPTCHA que vincula a requisição do usuário a uma sessão específica de verificação. É gerado em uma URL semelhante à seguinte (observe que este link contém um timestamp para evitar cache da requisição):
https://example.com/api/v1/gee-test/init-params?t=1730640766594
No GeeTest v.3 também são usados os seguintes parâmetros:
- geetest_validate – código que confirma que o CAPTCHA foi resolvido corretamente. É gerado após a resolução bem-sucedida e confirma que a verificação foi concluída;
- geetest_seccode – código adicional de segurança que confirma a resolução bem-sucedida.
- dataDome cookie (usado em DataDome) – cookies gerados pelo sistema DataDome para rastrear e verificar o usuário quanto a ações automatizadas, sendo atualizados com base no comportamento do usuário.
- g-recaptcha-response (usado em reCAPTCHA) – token obtido após a resolução bem-sucedida do CAPTCHA, necessário para envio posterior ao servidor.
- cf_clearance (usado em verificações do Cloudflare) – cookie gerado após a resolução do CAPTCHA para permitir acesso bem-sucedido ao recurso.
Também vale mencionar parâmetros como:
- s (ou sentinel/motionData) – pode conter dados sobre movimentos do mouse e interação com o CAPTCHA.
- v (versão) – indica a versão do CAPTCHA, que pode ser atualizada no servidor e exige um valor atualizado para cada sessão.
Os exemplos apresentados refletem apenas parte dos parâmetros que mudam a cada sessão; na realidade, existem muitos outros e eles variam conforme o tipo de verificação (CAPTCHA). Conhecer sua existência é importante para análise e resolução bem-sucedida do CAPTCHA.
Pesquisa de parâmetros dinâmicos, trabalho com Ferramentas de Desenvolvedor
| Importante: as informações abaixo são fornecidas exclusivamente para fins de ознакомimento, testes e automação dos seus próprios sites, aplicações ou recursos aos quais você tenha acesso autorizado. |
Se você utiliza serviços de resolução automática de CAPTCHA, por exemplo, CapMonster Cloud, na documentação desses serviços, nas seções dedicadas aos tipos de CAPTCHA, geralmente são indicados quais parâmetros são dinâmicos e onde exatamente no código eles são gerados. Tudo isso é necessário para extrair os valores e posteriormente utilizá-los para resolver o CAPTCHA com o serviço. Também é útil ter conhecimentos básicos de uso das Ferramentas de Desenvolvedor para encontrar rapidamente os valores dos parâmetros necessários.
Para começar, vamos identificar os principais métodos de geração desses parâmetros:
1. Usando JavaScript (lado do cliente)
Quando você abre uma página com CAPTCHA, um script é carregado que monitora suas ações – movimentos do mouse, cliques, pressionamentos de teclas. O JavaScript gera parâmetros – alguns elementos e formulários, janelas intermediárias de verificação (como no caso do Cloudflare Challenge), números aleatórios, dados de interação e informações do dispositivo. Em seguida, esses dados são criptografados ou processados e enviados ao servidor.
2. Usando API (lado do servidor)
Durante o processamento da requisição do CAPTCHA, o servidor pode adicionar parâmetros úteis, como identificadores de sessão ou valores hash. Além disso, a API pode retornar parâmetros necessários para criar uma nova sessão de CAPTCHA – eles são atualizados automaticamente no servidor para cada tentativa.
Para melhor compreensão, vamos analisar ambos os métodos. Como exemplo, usaremos o CAPTCHA da Amazon com geração de context via JavaScript e o GeeTest v.3 com geração da chave challenge via API:
Amazon (AWS WAF)
Neste tipo de CAPTCHA, parâmetros importantes (incluindo o variável context) são carregados através de um script especial de proteção no lado do cliente:

Ele pode ser encontrado usando as Ferramentas de Desenvolvedor entre os elementos na página alvo.
GeeTest v.3
Aqui a geração dos parâmetros do CAPTCHA ocorre via API. O URL necessário pode ser rastreado nas requisições na aba Network:

Lá também é gerado um timestamp para que a requisição seja vinculada a um tempo específico.
Como descobrir quais parâmetros são dinâmicos?
É possível identificar os parâmetros necessários analisando as requisições e respostas entre o navegador e o servidor. Veja abaixo os principais métodos e uma abordagem passo a passo:
- Ferramentas de Desenvolvedor:
- Abra a página com o CAPTCHA;
- Pressione F12 e vá para a aba Network;
- Encontre as requisições relacionadas ao CAPTCHA (geralmente são chamadas para servidores de CAPTCHA, por exemplo, api.geetest.com etc.);
- Verifique os parâmetros enviados nessas requisições, por exemplo: ?t=123456789123;
- Compare várias requisições;
- Atualize a página várias vezes;
- Compare os parâmetros. Se os valores mudarem entre as requisições, eles são dinâmicos;
- Encontre chamadas JavaScript
- Procure em DevTools nas abas Source ou Elements. Verifique quais scripts estão sendo carregados;
- Encontre a geração de parâmetros como timestamp, context, challenge etc.;
- Procure palavras-chave: no código JavaScript, frequentemente são usadas funções para gerar parâmetros dinâmicos;
- Analise as requisições ao servidor. Alguns parâmetros são gerados no servidor. Esses dados precisam ser armazenados e usados na próxima requisição. Se a sequência de requisições for quebrada (por exemplo, cookies expirados), o servidor pode rejeitar a verificação.
- Sniffers e proxies para análise
Essas ferramentas (por exemplo, Charles Proxy) permitem analisar requisições, encontrar parâmetros dinâmicos e testar alterações, ajudando a entender sua lógica e verificar como o servidor processa requisições modificadas.
O funcionamento dessas ferramentas inclui:
- As ferramentas capturam requisições para o servidor de CAPTCHA (por exemplo, com parâmetros t, challenge, context).
- São analisados headers, parâmetros de URL, corpo das requisições e cookies para identificar valores-chave.
- Os parâmetros são alterados (por exemplo, tokens) para testar seu impacto na resposta do servidor.
- É testado como o servidor reage a dados modificados.
Instruções resumidas para usar o Charles Proxy na análise de parâmetros de CAPTCHA:
- Baixe e instale o Charles Proxy.
- Ative o SSL Proxying via Proxy → SSL Proxying Settings. Adicione o domínio do CAPTCHA.
- Inicie o Charles e o navegador com a página onde o CAPTCHA é carregado.
- Acesse a página para iniciar a gravação das requisições.
- Na aba Structure, encontre as requisições para serviços de CAPTCHA (por exemplo, www.google.com/recaptcha/api.js).
- Abra as requisições/respostas e analise os parâmetros enviados (token, sitekey, challenge, cookies etc.).

Trabalho com parâmetros de CAPTCHA no Charles Proxy
Automação com ferramentas: uso de Selenium, Puppeteer e Playwright
Outra forma de analisar dados de CAPTCHA e, em combinação com outras ferramentas, automatizar sua manipulação é o uso de emuladores de navegador – como Selenium, Puppeteer e Playwright.
Capacidades gerais do Selenium, Puppeteer e Playwright
Automação. Todas as três ferramentas permitem controlar navegadores e executar ações típicas de usuário: cliques, entrada de texto, navegação entre páginas etc. Tudo isso pode ser automatizado.
Suporte a conteúdo dinâmico. Selenium, Puppeteer e Playwright conseguem trabalhar com JavaScript, o que permite processar elementos carregados dinamicamente na página.
Testes. São amplamente usados para automação de testes em diferentes aplicações web.
Como os emuladores de navegador ajudam a identificar conteúdo dinâmico?
Espera de elementos. É possível configurar a espera pelo carregamento de elementos – isso permite capturar dados após o carregamento completo da página.
Análise de respostas. Permitem interceptar requisições de rede para visualizar mudanças nos dados vindos da API.
Acesso via scripts. Com ferramentas integradas (por exemplo, no Puppeteer), é possível executar JavaScript para extrair informações de elementos carregados dinamicamente.
Métodos e parâmetros para trabalhar com conteúdo dinâmico:
Selenium
Interceptação de elementos DOM
Use os métodos find_element_by_xpath ou find_element_by_css_selector para acessar valores relacionados ao CAPTCHA.
Scripts JavaScript
Execute JavaScript diretamente usando driver.execute_script().
Log de requisições via proxy
Integração com BrowserMob Proxy para análise de tráfego de rede.
Você pode extrair dados de headers, corpo das requisições, tokens e parâmetros de CAPTCHA.
Puppeteer
Interceptação de requisições e respostas
Use page.on('request') e page.on('response') para capturar tráfego de rede.
Valores dinâmicos do DOM
Com métodos como page.evaluate(), analise parâmetros no nível da página.
Cookies e localStorage
Use page.cookies() ou page.evaluate() para analisar armazenamentos.
Playwright
Requisições de rede
page.on('request') e page.on('response') para monitoramento de dados de rede.
Análise do DOM
page.locator() para extrair dados de elementos.
Execução de JavaScript
Use page.evaluate() para analisar e extrair parâmetros de scripts.
Uso do CapMonster Cloud
Depois de analisar e encontrar todos os parâmetros necessários do CAPTCHA, o próximo passo é usar o CapMonster Cloud para criar e enviar uma tarefa ao servidor e resolver automaticamente o CAPTCHA. Integrar essa ferramenta ao seu código é muito simples. O serviço suporta linguagens de programação como Python, JavaScript e C#. Tudo o que você precisa fazer é escolher a linguagem adequada e instalar a biblioteca oficial para utilizá-la.
Exemplo de integração do CapMonster Cloud em código Python:
- Primeiro, registre-se no CapMonster Cloud e obtenha uma chave de API para acessar o serviço.
- Instale a biblioteca
Para Python, instale a biblioteca oficial via pip:
pip install capmonstercloudclient- No seu código, crie uma tarefa para resolver o CAPTCHA e obtenha a solução. Exemplo de resolução de reCAPTCHA v2 em Python:
# https://github.com/CapMonsterCloud/capmonstercloud-client-python
import asyncio
from capmonstercloudclient import CapMonsterClient, ClientOptions
from capmonstercloudclient.requests import RecaptchaV2Request
# from capmonstercloudclient.requests.baseRequestWithProxy import ProxyInfo # Descomente se pretende utilizar um proxy
API_KEY = "YOUR_API_KEY" # Insira a sua chave de API do CapMonster Cloud
async def solve_recaptcha_v2():
client_options = ClientOptions(api_key=API_KEY)
cap_monster_client = CapMonsterClient(options=client_options)
# Exemplo básico sem proxy
# O CapMonster Cloud utiliza automaticamente os seus próprios proxies
recaptcha2_request = RecaptchaV2Request(
websiteUrl="https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=high",
websiteKey="6Lcg7CMUAAAAANphynKgn9YAgA4tQ2KI_iqRyTwd"
)
# Exemplo de utilização do seu próprio proxy
# Descomente este bloco se desejar utilizar um proxy personalizado
# proxy = ProxyInfo(
# proxyType="http",
# proxyAddress="123.45.67.89",
# proxyPort=8080,
# proxyLogin="username",
# proxyPassword="password"
# )
# recaptcha2_request = RecaptchaV2Request(
# websiteUrl="https://lessons.zennolab.com/captchas/recaptcha/v2_simple.php?level=high",
# websiteKey="6Lcg7CMUAAAAANphynKgn9YAgA4tQ2KI_iqRyTwd",
# proxy=proxy,
# userAgent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/148.0.0.0 Safari/537.36"
# )
# Se necessário, pode verificar o saldo da conta
balance = await cap_monster_client.get_balance()
print("Saldo:", balance)
result = await cap_monster_client.solve_captcha(recaptcha2_request)
print("Solução:", result)
asyncio.run(solve_recaptcha_v2())| Para informações detalhadas sobre os tipos de CAPTCHA e os parâmetros necessários para criar tarefas de resolução, consulte a documentação. |
- Após obter a solução, envie-a para a página web no formulário onde a verificação é necessária.
Exemplos de extração de parâmetros dinâmicos e resolução de CAPTCHA
Esta seção apresenta exemplos de extração de parâmetros dinâmicos e resolução de diferentes tipos de CAPTCHA usando JavaScript (Node.js), Python e C#.
Para automação, são utilizados Selenium ou requisições HTTP nativas, dependendo do tipo de verificação.
Importante: antes de começar, consulte a lista de todos os parâmetros necessários na documentação do CapMonster Cloud: |
GeeTest v3 (com obtenção de parâmetros dinâmicos via API):
Este tipo de CAPTCHA contém os parâmetros dinâmicos necessários para criar a requisição ao servidor do CapMonster Cloud. Os parâmetros são gerados via API usando uma URL no seguinte formato: https://example.com/api/v1/gee-test/init-params?t=${t}. Nesse caso, ferramentas adicionais de automação de navegador não são necessárias – é possível usar o Fetch nativo (para Node.js), Requests (para Python) e Newtonsoft.Json (para C#).
Node.js
Mostrar código
// 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);
});Python
Mostrar código
# 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())
C#
Mostrar código
// 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}");
}
}
Cloudflare Challenge
Ao trabalhar com o CapMonster Cloud, você pode escolher entre dois métodos para obter o resultado: um token ou o cookie cf_clearance, que podem ser usados em requisições subsequentes à página alvo ou para injeção em uma sessão de navegador.
No exemplo abaixo, mostraremos como usar o Selenium para obter os parâmetros e gerar a solução para obter o token, e para obter o cookie cf_clearance utilizaremos requisições HTTP.
Método 1. Token
Node.js
Mostrar código
// 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();
}
})();Python
Mostrar código
# 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())C#
Mostrar código
// 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
}
}
Método 2. Cookie cf_clearance
Node.js
Mostrar código
// 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);
Python
Mostrar código
# 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())
C#
Mostrar código
// 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)));
}
}
AWS WAF:
Para o Amazon AWS WAF, o Selenium é usado para extrair parâmetros e, em seguida, obter a solução através do CapMonster Cloud.
Node.js
Mostrar código
// 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);
});
Python
Mostrar código
# 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())C#
Mostrar código
// 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"
);
}
}
Dicas para testes estáveis e redução do risco de bloqueios
Trabalhar com parâmetros dinâmicos e testes automatizados frequentemente envolve dificuldades como limitação de requisições, verificações adicionais ou elementos da página que mudam dinamicamente. Abaixo estão recomendações práticas que ajudam a tornar os testes mais estáveis e previsíveis.
1. Use Undetected ChromeDriver
Alguns sites podem detectar sinais padrão do WebDriver do Selenium e ativar verificações adicionais.
Para testes mais realistas do comportamento do site, você pode usar o undetected_chromedriver, que ajuda a aproximar o navegador de um ambiente de usuário comum.
pip install undetected-chromedriver
Exemplo de uso:
import undetected_chromedriver.v2 as uc
options = uc.ChromeOptions()
options.add_argument("--headless") # Execução em segundo plano
options.add_argument("--disable-blink-features=AutomationControlled")
driver = uc.Chrome(options=options)
driver.get("https://example.com")
print(driver.page_source)
driver.quit()
2. Emulação de ações do usuário
Durante os testes, é útil simular interações normais do usuário com o site. Não execute ações muito rapidamente em sequência. Adicione intervalos aleatórios entre as ações:
import time
import random
time.sleep(random.uniform(1, 3)) # Atraso de 1 a 3 segundosRolagem da página. Alguns elementos só carregam após o scroll:
driver.execute_script("window.scrollTo(0, document.body.scrollHeight);")Movimento do mouse: simule ações do mouse usando bibliotecas como pyautogui ou selenium-wire
3. Uso de servidores proxy
Proxies ajudam a evitar bloqueios por endereço IP:
Use rotação de proxies. Observe a geolocalização dos proxies para corresponder à região do site:
from selenium.webdriver.common.proxy import Proxy, ProxyType
proxy = Proxy()
proxy.proxy_type = ProxyType.MANUAL
proxy.http_proxy = "http://username:password@proxy_ip:port"
capabilities = webdriver.DesiredCapabilities.CHROME
proxy.add_to_capabilities(capabilities)
driver = webdriver.Chrome(desired_capabilities=capabilities)
4. Atualize o user-agent e os cabeçalhos
options.add_argument("user-agent=Seu User-Agent")
Portanto, dicas para funcionamento de longo prazo sem bloqueios:
- Evite uma frequência de requisições muito agressiva.
- Monitore a carga no recurso testado.
- Use atrasos realistas e cenários de interação.
- Teste o funcionamento tanto em modo normal quanto em headless.
- Atualize regularmente o navegador e as bibliotecas de automação utilizadas.
Conclusão
Trabalhar com parâmetros dinâmicos de CAPTCHA é um processo interessante que ajuda a entender melhor como funcionam os mecanismos de proteção web. Neste artigo, abordamos os principais pontos: desde como identificar e analisar parâmetros dinâmicos até como extraí-los e resolver CAPTCHAs de
Perguntas frequentes
NB: Por favor, observe que o produto é destinado à automação de testes exclusivamente em seus próprios sites e em recursos para os quais você possui autorização legal de acesso.






