Como resolver o desafio do Cloudflare com Python

TL;DR

O desafio de 5 segundos do Cloudflare pode interromper fluxos automatizados em Python bloqueando as solicitações iniciais. Este guia demonstra como lidar programaticamente com o Desafio Cloudflare usando Python e o CapSolver. Combinando um proxy bem configurado, fingerprinting TLS e a tarefa AntiCloudflareTask do CapSolver, você pode obter os cabeçalhos e cookies necessários para acessar páginas protegidas de forma confiável.

Introdução

Os mecanismos de proteção do Cloudflare são amplamente usados para mitigar tráfego abusivo e acesso automatizado. Um mecanismo comum é o desafio de 5 segundos do Cloudflare, que valida o comportamento do navegador antes de conceder acesso a um site. Para desenvolvedores que constroem fluxos de coleta de dados, monitoramento ou automação em Python, esse desafio pode resultar em respostas 403 repetidas e fluxos de trabalho interrompidos.

Neste artigo, percorremos uma abordagem prática em Python para lidar com o desafio do Cloudflare. Usando a API do CapSolver junto com um cliente HTTP consciente de TLS, você aprenderá a detectar o desafio, solicitar uma solução e completar com sucesso uma solicitação de follow-up verificada.

⚙️ Pré-requisitos

• Um proxy funcional
• Python instalado
• Chave de API do CapSolver

🤖 Etapa 1: Instalar os Pacotes Necessários

Redeeme seu código de bônus do CapSolver

Aumente seu orçamento de automação instantaneamente!
Use o código de bônus CAPN ao recarregar sua conta do CapSolver para obter um bônus extra de 5% em cada recarga — sem limites.
Redeeme-o agora no seu Painel do CapSolver
.
Execute os seguintes comandos para instalar os pacotes necessários:

pip install capsolver
pip install os
pip install requests

👨‍💻 Etapa 2: Código Python para resolver o desafio Cloudflare de 5 segundos

Aqui está um script de exemplo em Python para realizar a tarefa:

# -*- coding: utf-8 -*-
import requests
import time
import tls_client

# TODO: Sua chave de API
API_KEY = ""
proxy = ""

# TODO: Sua URL do site alvo:
page_url = ""


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):
    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,
    )


def main():
    solution = {
        "headers": {
            "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.7",
            "upgrade-insecure-requests": "1",
            "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
            "sec-fetch-site": "none",
            "sec-fetch-mode": "navigate",
            "sec-fetch-user": "?1",
            "sec-fetch-dest": "document",
            "accept-encoding": "gzip, deflate, br",
            "accept-language": "en-US,en;q=0.9",
        }
    }
    # Primeira solicitação (verifique seu proxy):
    res = request_site(solution)
    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 do 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 solicitação (verificar a solução):
    res = request_site(solution)
    print('2. código de status da resposta:', res.status_code)


if __name__ == '__main__':
    main()

⚠️ Altere estas variáveis

• PROXY: Atualize com os detalhes do seu proxy. O formato deve ser http://username:password@ip:port.
• capsolver.api_key: Obtenha sua chave de API no Painel do CapSolver.
• URL_DA_PÁGINA: Substitua pela URL do site para o qual deseja resolver o desafio do CloudFlare.

Como o Desafio CloudFlare se parece

Ao mesmo tempo, se quiser testar seus scripts para características de robô, a ferramenta de Detecção de Bots da BrowserScan pode ajudá-lo a identificar e aprimorar o comportamento semelhante a um robô em seus scripts.

Conclusão

Lidar com desafios do Cloudflare em Python exige mais do que uma solicitação HTTP padrão. Ao integrar o CapSolver com um cliente com capacidade TLS e um proxy estável, os desenvolvedores podem completar programaticamente o passo de verificação do Cloudflare e continuar com os fluxos de solicitação normais.

Este método é especialmente útil para aplicações que dependem de acesso consistente a recursos protegidos pelo Cloudflare, como ferramentas de monitoramento, serviços de agregação de dados e fluxos de teste automatizado. Com configuração adequada e tratamento de erros, o processo pode ser automatizado de ponta a ponta, mantendo-se estável e escalável.

Perguntas Frequentes

1. O que é o desafio de 5 segundos do Cloudflare?

O desafio de 5 segundos do Cloudflare é uma etapa de verificação de navegador que verifica se um visitante se comporta como um navegador real antes de permitir o acesso. Ele geralmente aparece como uma página intersticial temporária e pode retornar respostas HTTP 403 para scripts automatizados.

2. Por que um cliente com capacidade TLS é necessário?

O Cloudflare avalia os fingerprints TLS, a ordem dos cabeçalhos e o comportamento semelhante a um navegador. Bibliotecas como tls_client ajudam a emular as características TLS de um navegador real, o que é crítico para passar na solicitação inicial e validar a solução retornada pelo CapSolver.

3. Eu sempre preciso de um proxy?

Um proxy é fortemente recomendado. Proxies limpos e consistentes reduzem a probabilidade de bloqueio imediato e garantem que a solicitação para resolver o desafio e a solicitação de verificação venham da mesma endereço IP.

4. O que o CapSolver retorna após resolver o desafio?

O CapSolver fornece uma solução contendo cabeçalhos e cookies que representam uma sessão de navegador verificada. Esses devem ser reutilizados em solicitações subsequentes para acessar com sucesso a página de destino.

5. Este método pode ser estendido para automação em larga escala?

Sim. O mesmo fluxo pode ser integrado a sistemas Python maiores adicionando filas de tarefas, lógica de repetição e rotação de proxies, tornando-o adequado para cenários de automação e acesso a dados em larga escala.