
Adélia Cruz
Neural Network Developer

A Cloudflare oferece medidas de proteção robustas, incluindo o Cloudflare Challenge e o Turnstile CAPTCHA, para proteger sites contra bots maliciosos e raspadores automatizados. Compreender e superar esses desafios pode ser crucial para aqueles que precisam de acesso além dessas barreiras de proteção para fins legítimos.
A Cloudflare utiliza várias técnicas para detectar e mitigar tráfego indesejado. Entre elas estão o Cloudflare Challenge, que frequentemente envolve desafios de JavaScript ou testes de CAPTCHA, e o Turnstile, um CAPTCHA mais amigável ao usuário que minimiza a interação do usuário. Esses sistemas são projetados para distinguir entre usuários humanos e bots automatizados de forma eficaz.
Navegadores Automatizados:
puppeteer-extra-plugin-stealth podem ser usados para passar pelo Cloudflare Challenge, simulando o comportamento de um navegador natural.Proxies de Alta Qualidade:
Serviços de Resolução de CAPTCHA:
Primeiro, vamos dar uma olhada em como o Cloudflare Challenge parece:

Às vezes, esta página pode ter turnstile

Resgate seu código de bônus do CapSolver
Não perca a oportunidade de otimizar ainda mais suas operações! Use o código de bônus CAPN ao recarregar sua conta do CapSolver e receba um bônus adicional de 5% em cada recarga, sem limites. Acesse o Painel do CapSolver para resgatar seu bônus agora!
Se você tiver uma página semelhante onde deve esperar até que a verificação seja concluída e geralmente tenha verificações adicionais com turnstile, então é um desafio da Cloudflare.
Existem alguns requisitos para resolver este tipo de desafio:
Token retornado na resposta do método getTaskResult é o valor do cookie cf_clearance que você precisará criar.# -*- coding: utf-8 -*-
import time
import requests
import tls_client
API_KEY = "" # TODO: sua chave de API
page_url = '' # TODO: sua URL da página 'https://example.com
proxy = "" # TODO: seu proxy
def call_capsolver():
data = {
"clientKey": API_KEY,
"task": {
"type": 'AntiCloudflareTask',
"websiteURL": page_url,
"proxy": proxy,
}
}
uri = 'https://api.capsolver.com/createTask'
res = requests.post(uri, json=data)
resp = res.json()
task_id = resp.get('taskId')
if not task_id:
print("não foi possível obter taskId:", res.text)
return
print('taskId criado:', task_id)
while True:
time.sleep(1)
data = {
"clientKey": API_KEY,
"taskId": task_id
}
response = requests.post('https://api.capsolver.com/getTaskResult', json=data)
resp = response.json()
status = resp.get('status', '')
if status == "ready":
print("sucesso => ", response.text)
return resp.get('solution')
if status == "failed" or resp.get("errorId"):
print("falha! => ", response.text)
return
def request_site(solution):
# TODO se quiser usar tls_client
session = tls_client.Session(
client_identifier="chrome_120",
random_tls_extension_order=True
)
return session.get(
page_url,
headers=solution.get('headers'),
cookies=solution.get('cookies'),
proxy=proxy,
allow_redirects=True,
)
def main():
# primeira requisição:
res = request_site({})
print('1. código de status da resposta:', res.status_code)
if res.status_code != 403:
print("seu proxy está bom e não recebeu o desafio da Cloudflare")
return
elif 'window._cf_chl_opt' not in res.text:
print('==== proxy bloqueado ==== ')
return
# chamar o CapSolver:
solution = call_capsolver()
if not solution:
return
# segunda requisição (verificar solução):
res = request_site(solution)
print('2. código de status da resposta:', res.status_code)
if res.status_code == 200:
##print("2. texto da resposta:\n", res.text)
print("sucesso ao passar pelo desafio da Cloudflare")
if __name__ == '__main__':
main()
A Cloudflare oferece 3 tipos de CAPTCHA Cloudflare Turnstile
Desafio gerenciado

Desafio não interativo

Desafio invisível
não visível, você pode verificar na rede / scripts carregados e ver se o turnstile está sendo usado
O CAPTCHA Turnstile é a substituição do CAPTCHA tradicional da Cloudflare, focando na experiência do usuário e na segurança. Aqui está como abordar a resolução dele:
Entender o Desafio:
Integração de APIs de Resolução de CAPTCHA:
Manter a Consistência do Navegador:
Adaptar-se a Desafios de JavaScript:
import time
from curl_cffi import requests
CAPSOLVER_API_KEY = "SUA CHAVE DE API CAPSOLVER.COM"
PAGE_URL = ""
WEBSITE_KEY = ""
def solvecf(metadata_action=None, metadata_cdata=None):
url = "https://api.capsolver.com/createTask"
task = {
"type": "AntiTurnstileTaskProxyLess",
"websiteURL": PAGE_URL,
"websiteKey": WEBSITE_KEY,
}
if metadata_action or metadata_cdata:
task["metadata"] = {}
if metadata_action:
task["metadata"]["action"] = metadata_action
if metadata_cdata:
task["metadata"]["cdata"] = metadata_cdata
data = {
"clientKey": CAPSOLVER_API_KEY,
"task": task
}
response_data = requests.post(url, json=data).json()
print(response_data)
return response_data['taskId']
def solutionGet(taskId):
url = "https://api.capsolver.com/getTaskResult"
status = ""
while status != "ready":
data = {"clientKey": CAPSOLVER_API_KEY, "taskId": taskId}
response_data = requests.post(url, json=data).json()
print(response_data)
status = response_data.get('status', '')
print(status)
if status == "ready":
return response_data['solution']
time.sleep(2)
def main():
start_time = time.time()
taskId = solvecf()
solution = solutionGet(taskId)
if solution:
user_agent = solution['userAgent']
token = solution['token']
print("User_Agent:", user_agent)
print("CAPTCHA Turnstile resolvido, token:", token)
end_time = time.time()
elapsed_time = end_time - start_time
print(f"Tempo para resolver o CAPTCHA: {elapsed_time} segundos")
if __name__ == "__main__":
main()
const axios = require('axios');
const CAPSOLVER_API_KEY = "";
const PAGE_URL = "";
const WEBSITE_KEY = "";
async function solvecf(metadata_action = null, metadata_cdata = null) {
const url = "https://api.capsolver.com/createTask";
const task = {
type: "AntiTurnstileTaskProxyLess",
websiteURL: PAGE_URL,
websiteKey: WEBSITE_KEY,
};
if (metadata_action || metadata_cdata) {
task.metadata = {};
if (metadata_action) {
task.metadata.action = metadata_action;
}
if (metadata_cdata) {
task.metadata.cdata = metadata_cdata;
}
}
const data = {
clientKey: CAPSOLVER_API_KEY,
task: task
};
const response = await axios.post(url, data);
console.log(response.data);
return response.data.taskId;
}
async function solutionGet(taskId) {
const url = "https://api.capsolver.com/getTaskResult";
let status = "";
while (status !== "ready") {
const data = { clientKey: CAPSOLVER_API_KEY, taskId: taskId };
const response = await axios.post(url, data);
console.log(response.data);
status = response.data.status;
console.log(status);
if (status === "ready") {
return response.data.solution;
}
await new Promise(resolve => setTimeout(resolve, 2000));
}
}
async function main() {
const start_time = Date.now();
const taskId = await solvecf();
const solution = await solutionGet(taskId);
if (solution) {
const user_agent = solution.userAgent;
const token = solution.token;
console.log("User_Agent:", user_agent);
console.log("CAPTCHA Turnstile resolvido, token:", token);
}
const end_time = Date.now();
const elapsed_time = (end_time - start_time) / 1000;
console.log(`Tempo para resolver o CAPTCHA: ${elapsed_time} segundos`);
}
main().catch(console.error);
As medidas de segurança da Cloudflare, incluindo o Challenge e o CAPTCHA Turnstile, são projetadas para proteger sites contra acesso automatizado, enquanto minimiza a fricção para usuários legítimos. Para desenvolvedores, testadores ou empresas que necessitam de acesso automatizado para fins legítimos, compreender esses desafios e usar soluções robustas é essencial.
Ao combinar proxies de alta qualidade, automação de navegador com técnicas de stealth e serviços dedicados de resolução de CAPTCHA como o CapSolver , você pode contornar com confiabilidade as proteções da Cloudflare. Os exemplos fornecidos em Python e Node.js demonstram como integrar o CapSolver para lidar com os desafios tradicionais da Cloudflare e os CAPTCHAs Turnstile de forma eficiente.
Com uma implementação adequada, fluxos de automação podem alcançar altas taxas de sucesso, mantendo conformidade e minimizando a detecção.
Q1: Qual é a diferença entre o Cloudflare Challenge e o CAPTCHA Turnstile?
A1: O Cloudflare Challenge geralmente envolve verificações de JavaScript ou CAPTCHAs visíveis para verificar humanos. O Turnstile é o novo CAPTCHA amigável ao usuário da Cloudflare que pode funcionar invisivelmente em segundo plano, reduzindo a interação do usuário, mas ainda verificando a autenticidade.
Q2: O CAPTCHA Turnstile pode ser resolvido programaticamente?
A2: Sim. Serviços como o CapSolver analisam o tráfego da rede e as interações do usuário para resolver desafios do Turnstile, seja em forma visível ou invisível.
Q3: Preciso rotacionar proxies ao resolver CAPTCHAs da Cloudflare?
A3: Usar proxies residenciais ou de alta qualidade com rotação de IPs é altamente recomendado. A Cloudflare rastreia o comportamento do IP, então o uso consistente de um IP reduz o risco de bloqueios.
Q4: Posso usar a mesma sessão do navegador para vários desafios?
A4: É melhor manter a consistência do navegador por sessão, usando o mesmo user-agent, cookies, headers e versão TLS, pois discrepâncias podem disparar a segurança da Cloudflare.
Q5: Quão rápido o CapSolver resolve o CAPTCHA Turnstile da Cloudflare?
A5: O CapSolver normalmente resolve a maioria dos desafios da Cloudflare em alguns segundos (geralmente ~5s), dependendo das condições da rede, qualidade do proxy e complexidade da tarefa.
Q6: Existem bibliotecas oficiais/exemplos para integrar o CapSolver?
A6: Sim, o CapSolver fornece exemplos oficiais para Python e Node.js, como mostrado no artigo, abrangendo tanto o Cloudflare Challenge quanto o CAPTCHA Turnstile.
Entenda as principais diferenças entre Cloudflare Challenge vs Turnstile e aprenda a identificá-los para automação web bem-sucedida. Obtenha dicas de especialistas e um solucionador recomendado.

Aprenda a corrigir o Erro 1005 do Cloudflare acesso negado durante o web scraping. Descubra soluções como proxies residenciais, fingerprinting de navegador e CapSolver para CAPTCHA. Otimize sua extração de dados.

Descubra como lidar efetivamente com o Cloudflare Turnstile em fluxos de trabalho de IA usando técnicas de disfarce do Playwright e o CapSolver para resolução confiável de captchas. Aprenda estratégias práticas de integração e melhores práticas para automação contínua.

Aprenda como resolver a proteção do Cloudflare ao fazer scraping na web. Descubra métodos comprovados como rotação de IP, fingerprinting TLS e CapSolver para lidar com desafios.
