Como resolver o Cloudflare em 2025: Resolva o Cloudflare Turnstile e o Desafio usando o CapSolver

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.

Entendendo as Medidas de Segurança da Cloudflare

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.

Estratégias para Resolver os Desafios da Cloudflare

1. Navegadores Automatizados:

   • Ferramentas como Selenium ou Puppeteer podem simular interações de usuários reais. Para mascarar sua natureza automatizada, plugins como puppeteer-extra-plugin-stealth podem ser usados para passar pelo Cloudflare Challenge, simulando o comportamento de um navegador natural.

2. Proxies de Alta Qualidade:

   • Utilizar proxies residenciais que rotacionem endereços IP pode ajudar a imitar padrões de acesso de usuários reais, reduzindo assim a probabilidade de ser bloqueado pelos mecanismos de segurança da Cloudflare.

3. Serviços de Resolução de CAPTCHA:

   • Para desafios / CAPTCHAs que exigem resolução

Guia Detalhado para resolver o Cloudflare Challenge

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.
• Deve usar o mesmo user-agent que o método getTaskResult retorna
• Deve usar o mesmo IP de proxy usado para resolver o desafio
• Deve usar os cookies da resposta
• Deve usar os headers da resposta
• Usar TLS versão chrome 120

Exemplo de como resolver a interface Cloudflare 5s com Python

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

Guia Detalhado para resolver o CAPTCHA Cloudflare Turnstile

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:

1. Entender o Desafio:

   • O CAPTCHA Turnstile pode não sempre aparecer visivelmente; às vezes, ele opera em segundo plano, analisando as interações do usuário para verificar a autenticidade.

2. Integração de APIs de Resolução de CAPTCHA:

   • Alguns serviços de resolução de CAPTCHA já estão oferecendo soluções para Turnstile analisando o tráfego da rede e padrões de interação. Utilize essas APIs para enviar desafios do Turnstile para resolução.

3. Manter a Consistência do Navegador:

   • Certifique-se de que suas soluções automatizadas mantenham assinaturas de navegador consistentes, pois o Turnstile pode analisá-las para detectar automação.

4. Adaptar-se a Desafios de JavaScript:

   • A Cloudflare pode implantar cálculos de JavaScript para testar o ambiente do navegador. Ferramentas como Puppeteer podem ser programadas para resolver esses desafios dinamicamente executando código JavaScript como um navegador regular faria.

Exemplo de como resolver o CAPTCHA Cloudflare Turnstile com Python

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

Exemplo de como resolver o CAPTCHA Cloudflare Turnstile com Nodejs

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

Conclusão

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.

Perguntas Frequentes

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.