Como contornar sistemas antibot: Impressão digital TLS & tratamento de CAPTCHA

Sistemas antibot modernos, como Cloudflare, DataDome e Imperva, não dependem apenas de CAPTCHA — eles também inspecionam impressões digitais TLS, comportamento HTTP e consistência do navegador para detectar tráfego não humano.

Isso significa que, hoje, contornar um WAF (Web Application Firewall) geralmente exige mais do que um cliente HTTP padrão: você precisa de impressões digitais TLS compatíveis com navegadores, cabeçalhos alinhados e uma camada confiável de tratamento de CAPTCHA.

Neste guia, você aprenderá como a impressão digital TLS funciona, por que JA3 e JA4 são importantes para a detecção de bots e como ferramentas como tls-client e CapMonster Cloud se encaixam em uma pilha moderna para contornar sistemas antibot.

Entendendo a impressão digital TLS: JA3, JA4 e detecção por WAF

Quando seu código faz uma requisição HTTPS, o handshake TLS revela detalhes sobre o cliente — conjuntos de cifras compatíveis, extensões, curvas elípticas e sua ordenação. Essa combinação forma uma impressão digital TLS, comumente capturada como um hash JA3 (com base nos campos de ClientHello) ou uma impressão digital JA4 (um formato mais novo e mais estruturado — não simplesmente uma alternativa intercambiável ao JA3).

Sistemas antibot comparam essa impressão digital com perfis conhecidos. Bibliotecas HTTP padrão, como requests do Python, o axios do Node ou o net/http do Go, produzem impressões digitais que podem servir como um forte sinal de tráfego que não vem de navegador — potencialmente acionando um desafio ou bloqueio na borda/camada WAF antes que sua requisição chegue à camada da aplicação. Observe que fornecedores de soluções antibot normalmente combinam a impressão digital TLS com uma série de outros sinais técnicos, estatísticos e comportamentais, em vez de depender dela como critério único.

Importante: a impressão digital TLS costuma ser uma camada em um pipeline de detecção de múltiplas etapas (o conjunto exato de camadas depende do provedor de proteção específico e da configuração do site). Depois que uma requisição passa pela inspeção TLS, sistemas antibot ainda podem desafiar o cliente com desafios baseados em JavaScript ou CAPTCHA — exigindo uma pilha completa para contornar a proteção, e não apenas spoofing de impressão digital.

Como Cloudflare e DataDome usam handshakes TLS para bloquear bots

Clientes HTTP padrão são previsíveis. Uma sessão de requests do Python sempre negocia os mesmos conjuntos de cifras na mesma ordem — tornando isso um sinal confiável para sistemas como Cloudflare, DataDome e Imperva distinguirem bots de navegadores reais como parte de seu pipeline de análise com múltiplos sinais.

Isso faz da impressão digital TLS um primeiro filtro eficiente e de baixo custo: ela pode bloquear a maioria das automações ingênuas antes de incorrer no custo computacional de uma análise comportamental mais profunda.

Contornando WAF com clientes TLS compatíveis com navegadores

Para passar pela inspeção TLS, você precisa de um cliente que replique os parâmetros exatos de handshake de um navegador real. Duas opções que vale a pena avaliar:

• tls-client (bogdanfinn) — biblioteca em Go com perfis pré-construídos para Chrome, Firefox, Safari e Opera. Disponível como biblioteca compartilhada que pode ser usada em Python, Node e outras linguagens.
• azuretls-client — uma alternativa baseada em Go com suporte a perfis de navegador e correspondência de impressão digital HTTP/2. Verifique o conjunto atual de recursos e o status de manutenção na documentação do repositório antes de usar.

Ambas as bibliotecas buscam aproximar perfis TLS de navegador no nível de socket, mas a paridade exata com uma sessão de navegador real não é garantida — até a documentação oficial do tls-client observa que os perfis internos nem sempre correspondem a um navegador em execução com 100% de fidelidade.

Implementação em Python: configurando seu cliente TLS para discrição

Ao inicializar seu cliente TLS, use um perfil moderno do Chrome e habilite a randomização da ordem das extensões. O identificador exato em string de cada perfil pode variar entre versões da biblioteca — sempre verifique na lista oficial de perfis antes de colocar em produção.

import tls_client
try:
    session = tls_client.Session(
        client_identifier="chrome_133",  # verifique o identificador na versão da sua biblioteca
        random_tls_extension_order=True
    )
    
    response = session.get(
        "https://target-site.com",
        timeout_seconds=30,
        headers={
            "User-Agent": (
                "Mozilla/5.0 (Windows NT 10.0; Win64; x64) "
                "AppleWebKit/537.36 (KHTML, like Gecko) "
                "Chrome/146.0.0.0 Safari/537.36"
            ),
            "Accept-Language": "en-US,en;q=0.9,ru;q=0.8",
            "Accept-Encoding": "gzip, deflate, br, zstd",
        }
    )
    
    print(response.status_code)
    
except Exception as e:
    print(f"Request failed: {e}")

Parâmetros principais:

• client_identifier="chrome_146" — direciona para um perfil recente de impressão digital do Chrome; sempre verifique esse identificador na lista oficial de perfis da versão instalada da sua biblioteca
• random_tls_extension_order=True — reduz a previsibilidade de uma sequência fixa de extensões. Observe que algoritmos como JA4 normalizam a ordem das extensões, portanto isso, por si só, não é uma contramedida universal contra todos os métodos de fingerprinting
• Sempre combine com um User-Agent correspondente e cabeçalhos semelhantes aos de um navegador para evitar sinalizações de inconsistência na camada HTTP

Resolvendo a camada de CAPTCHA: integrando o CapMonster Cloud

Passar pela inspeção TLS é necessário, mas nem sempre suficiente. Plataformas como Cloudflare, DataDome e Imperva operam em camadas: após o TLS, elas podem apresentar um desafio em JavaScript ou um CAPTCHA para verificar se o cliente é um navegador real. Um comportamento inconsistente em qualquer camada acionará um bloqueio.

É aqui que o CapMonster Cloud entra na pilha. É um serviço em nuvem de resolução de CAPTCHA com uma API que lida com os tipos de desafio apresentados por esses sistemas antibot:

O fluxo geral de trabalho é o seguinte: seu cliente que imita TLS lida com a camada de transporte; o CapMonster Cloud resolve o token do desafio; você injeta o token na requisição subsequente. Na prática, o sucesso depende da configuração específica do WAF e de sinais adicionais além do token em si.

O exemplo abaixo cobre o Cloudflare Bot Challenge — um cenário comum em que um site protegido retorna uma página 403 "Just a moment". Ele usa TurnstileTask com o parâmetro cloudflareTaskType: "cf_clearance", que é o fluxo dedicado ao Cloudflare Challenge — distinto da tarefa Turnstile comum (usada para widgets Turnstile independentes). Consulte sempre a documentação atual do CapMonster Cloud para ver os campos obrigatórios exatos, pois o esquema da API pode mudar entre versões.

import tls_client
import base64
import time
import requests
from urllib.parse import urlparse

# ===================== CONFIGURAÇÃO =====================

API_KEY = "YOUR_CAPMONSTER_API_KEY"
TARGET_URL = "https://example.com/protected-page"
WEBSITE_KEY = "xxxxxxxxxx"

USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"

# Proxy no formato: protocol://user:pass@ip:port
PROXY = "http://proxy_login:proxy_password@proxy_ip:proxy_port"

CREATE_TASK_URL = "https://api.capmonster.cloud/createTask"
GET_RESULT_URL = "https://api.capmonster.cloud/getTaskResult"

# ===================== SESSÃO TLS =====================

session = tls_client.Session(
    client_identifier="chrome_120",
    random_tls_extension_order=True
)

session.headers.update({
    "User-Agent": USER_AGENT,
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
    "Accept-Language": "en-US,en;q=0.9",
    "Connection": "keep-alive",
})

session.proxies = {
    "http": PROXY,
    "https": PROXY
}

# ===================== PARSER DE PROXY =====================

def parse_proxy(proxy_url):
    parsed = urlparse(proxy_url)
    return {
        "proxyType": parsed.scheme,
        "proxyAddress": parsed.hostname,
        "proxyPort": parsed.port,
        "proxyLogin": parsed.username,
        "proxyPassword": parsed.password
    }

# ===================== ETAPA 1 =====================

def get_html_base64():
    try:
        resp = session.get(TARGET_URL, timeout_seconds=30)
        print(f"[INFO] Status: {resp.status_code}")

        html_base64 = base64.b64encode(resp.content).decode()
        print("[INFO] HTML Base64 recebido")
        return html_base64

    except Exception as e:
        print("[ERRO] Falha ao obter HTML:", e)
        return None

# ===================== ETAPA 2 =====================

def solve_captcha(html_base64):
    proxy_data = parse_proxy(PROXY)

    payload = {
        "clientKey": API_KEY,
        "task": {
            "type": "TurnstileTask",
            "websiteURL": TARGET_URL,
            "websiteKey": WEBSITE_KEY,
            "cloudflareTaskType": "cf_clearance",
            "htmlPageBase64": html_base64,
            "userAgent": USER_AGENT,
            "proxyType": proxy_data["proxyType"],
            "proxyAddress": proxy_data["proxyAddress"],
            "proxyPort": proxy_data["proxyPort"],
            "proxyLogin": proxy_data["proxyLogin"],
            "proxyPassword": proxy_data["proxyPassword"]
        }
    }

    create = requests.post(CREATE_TASK_URL, json=payload).json()
    print("[INFO] CreateTask:", create)

    if create.get("errorId") != 0:
        raise Exception(create.get("errorDescription"))

    task_id = create["taskId"]
    print(f"[INFO] ID da tarefa: {task_id}")

    while True:
        time.sleep(5)
        result = requests.post(GET_RESULT_URL, json={
            "clientKey": API_KEY,
            "taskId": task_id
        }).json()

        if result.get("status") == "ready":
            print("[INFO] Solução recebida")
            return result["solution"]

        print("[INFO] Aguardando...")

# ===================== ETAPA 3 (APLICAR COOKIES) =====================

def apply_cookies(solution):
    """
    Aplicar cookies da solução do CapMonster
    """
    # Opção 1: lista de cookies
    if "cookies" in solution:
        for cookie in solution["cookies"]:
            session.cookies.set(
                cookie["name"],
                cookie["value"],
                domain=cookie.get("domain", ".mees.com"),
                path=cookie.get("path", "/")
            )
        print("[INFO] Cookies aplicados a partir da lista")

    # Opção 2: cf_clearance separado
    if "cf_clearance" in solution:
        session.cookies.set(
            "cf_clearance",
            solution["cf_clearance"],
            domain=".mees.com",
            path="/"
        )
        print("[INFO] cf_clearance aplicado")

# ===================== ETAPA 4 (ACESSAR PÁGINA PROTEGIDA) =====================

def access_protected_page():
    try:
        resp = session.get(TARGET_URL, timeout_seconds=30)
        print(f"[INFO] Status final: {resp.status_code}")

        if "cf-chl" in resp.text or resp.status_code in :
            print("[AVISO] Ainda bloqueado pelo Cloudflare")
        else:
            print("[SUCESSO] Contorno do Cloudflare bem-sucedido")

        return resp.text

    except Exception as e:
        print("[ERRO] Requisição final:", e)

# ===================== PRINCIPAL =====================

def main():
    html_base64 = get_html_base64()
    if not html_base64:
        return

    solution = solve_captcha(html_base64)
    print("\n=== SOLUÇÃO DO CAPTCHA ===")
    print(solution)

    apply_cookies(solution)
    access_protected_page()

if __name__ == "__main__":
    main()

Montando uma pilha completa para contornar sistemas antibot

Um pipeline de contorno de nível de produção para sites que usam proteção antibot moderna deve tratar cada camada de detecção de forma independente — embora, na prática, muitos provedores de proteção combinem e atribuam pesos a esses sinais em conjunto:

• ✅ Impressão digital TLS → tls-client ou azuretls-client com um perfil atual do Chrome e ordem aleatória de extensões
• ✅ Impressão digital HTTP/2 → os mesmos clientes são documentados para lidar com HTTP/2; verifique o suporte a HPACK e às configurações de streams no README oficial da biblioteca
• ✅ Consistência de cabeçalhos → User-Agent, Accept-Language, Sec-CH-UA e outros cabeçalhos devem corresponder ao perfil de navegador escolhido
• ✅ CAPTCHA / desafios JS → API do CapMonster Cloud — cobre Cloudflare Turnstile, Cloudflare Bot Challenge, DataDome, Imperva, reCAPTCHA e mais. Use o tipo de tarefa correto para cada desafio: Turnstile comum e Cloudflare Bot Challenge são tratados de maneira diferente
• ✅ Reputação de IP → proxies residenciais ou móveis são necessários para tarefas de Cloudflare Bot Challenge e DataDome no CapMonster Cloud; para outros tipos de desafio, verifique os requisitos de proxy na documentação atual

Tratar apenas uma camada e ignorar as demais é um motivo comum para tentativas de contorno falharem em escala. A maioria dos provedores usa múltiplos sinais — trate-os em conjunto para obter resultados confiáveis.

Checklist pré-produção para web scraping não detectável

• Identifique o provedor antibot no site-alvo (Cloudflare, DataDome, Imperva etc.)
• Inicialize o tls-client com um perfil atualizado do Chrome ou Firefox; verifique a string de identificador na lista oficial de perfis
• Ative random_tls_extension_order (observação: isso reduz a previsibilidade de uma sequência fixa, mas não é uma contramedida completa de fingerprinting por si só)
• Defina todos os cabeçalhos HTTP consistentes com o navegador (User-Agent, Accept, Sec-CH-UA etc.)
• Detecte a presença de CAPTCHA / desafio nas respostas (HTTP 403, HTML "Just a moment", redirecionamento por /cdn-cgi/)
• Integre a API do CapMonster Cloud usando o tipo de tarefa correto para cada desafio: widgets Turnstile usam TurnstileTask; Cloudflare Bot Challenge (cf_clearance) usa TurnstileTask com cloudflareTaskType: "cf_clearance" — verifique todos os campos obrigatórios na documentação atual
• Adicione verificações de errorId / errorCode em todas as respostas da API do CapMonster
• Adicione timeout a todas as chamadas HTTP de saída; trate exceções explicitamente
• Defina o cookie cf_clearance com domain e path explícitos
• Forneça proxies residenciais ou móveis — exigidos para tarefas de Cloudflare Bot Challenge e DataDome
• Teste sua impressão digital TLS com tls.peet.ws ou ja4db.com antes do uso em produção