Cookie de verificação do desafio Cloudflare: como funciona e como resolver

Um navegador que passa pelo desafio da Cloudflare recebe um cookie de verificação — é ele, não a resposta do CAPTCHA em si, que libera as próximas requisições. Este guia mostra primeiro como resolver o desafio pela API da CaptchaAI e, na sequência, do que esse cookie depende e como reaproveitá-lo sem quebrar a sessão.

Resumo rápido: a Cloudflare libera o cookie de verificação depois que o navegador passa por checagens de risco e, quando necessário, resolve um widget Cloudflare Turnstile. Sem esse cookie, cada requisição nova volta a cair no desafio.

Como resolver com a CaptchaAI

O fluxo pela API é o mesmo dos outros tipos suportados: enviar a tarefa, consultar o resultado e usar o token retornado. Comece pelo envio e pela consulta — em Python e em JavaScript:

import requests
import time

API_KEY = "YOUR_API_KEY"
TARGET_URL = "https://example.com/protected-page"

# Submit Cloudflare Turnstile em staging task
resp = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "turnstile",
    "sitekey": "0x0000000000000000000000",  # may be generic for CF challenge
    "pageurl": TARGET_URL,
    "json": "1",
}).json()

if resp["status"] != 1:
    raise Exception(f"Submit error: {resp['request']}")

task_id = resp["request"]
print(f"Task ID: {task_id}")

# Poll for result
for _ in range(30):
    time.sleep(5)
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": API_KEY, "action": "get", "id": task_id, "json": "1"
    }).json()

    if result["status"] == 1:
        token = result["request"]
        print(f"Token received: {token[:50]}...")
        break
    if result["request"] != "CAPCHA_NOT_READY":
        raise Exception(f"Error: {result['request']}")

O mesmo fluxo em Node.js, usando axios:

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const TARGET_URL = 'https://example.com/protected-page';

const submit = await axios.post('https://ocr.captchaai.com/in.php', null, {
  params: {
    key: API_KEY,
    method: 'turnstile',
    sitekey: '0x0000000000000000000000',
    pageurl: TARGET_URL,
    json: 1,
  }
});
const taskId = submit.data.request;

// Poll
let token = null;
for (let i = 0; i < 30; i++) {
  await new Promise(r => setTimeout(r, 5000));
  const poll = await axios.get('https://ocr.captchaai.com/res.php', {
    params: { key: API_KEY, action: 'get', id: taskId, json: 1 }
  });
  if (poll.data.status === 1) {
    token = poll.data.request;
    break;
  }
}
console.log(`Token: ${token.substring(0, 50)}...`);

Com o token em mãos, injete-o no campo do widget na página de desafio para que a Cloudflare emita o cookie_qa_validacao:

# With Selenium
from selenium import webdriver

driver = webdriver.Chrome()
driver.get(TARGET_URL)  # Load the challenge page

# Inject token into Turnstile response field
driver.execute_script("""
    const input = document.querySelector('input[name="cf-turnstile-response"]');
    if (input) input.value = arguments[0];

    // Trigger form submit or callback
    const form = document.querySelector('form');
    if (form) form.submit();
""", token)

# Wait for redirect and extract cookies
import time
time.sleep(3)
cookies = driver.get_cookies()
cookie_qa_validacao = next(
    (c for c in cookies if c['name'] == 'cookie_qa_validacao'), None
)
if cookie_qa_validacao:
    print(f"cookie_qa_validacao: {cookie_qa_validacao['value'][:30]}...")

Um cookie válido evita repetir o desafio a cada requisição — guarde-o na sessão HTTP e reutilize enquanto durar:

session = requests.Session()
session.cookies.set("cookie_qa_validacao", cookie_qa_validacao["value"], domain=".example.com")
session.headers.update({
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
})

# Now access protected pages
resp = session.get("https://example.com/api/data")
print(resp.status_code)  # 200

Se o fluxo captura e reaproveita esse cookie fora do seu próprio ambiente de testes, trate isso como dado sob a LGPD (ou o RGPD, em Portugal): documente a base legal e mantenha a coleta em ambiente de QA autorizado antes de levar qualquer coisa para produção.

O cookie_qa_validacao expira, então planeje a renovação em vez de descobrir isso em produção:

import datetime

def is_cookie_valid(cookie):
    if not cookie:
        return False
    expiry = cookie.get("expiry", 0)
    return datetime.datetime.now().timestamp() < expiry - 60  # 60s buffer

def get_or_refresh_clearance(driver, target_url, solve_func):
    cookies = driver.get_cookies()
    cf = next((c for c in cookies if c["name"] == "cookie_qa_validacao"), None)
    if is_cookie_valid(cf):
        return cf["value"]

    # Re-solve
    token = solve_func(target_url)
    # ... inject and extract new cookie

Do que o cookie depende

Ele também fica amarrado a três fatores da sessão que o resolveu, e quebrar qualquer um deles costuma invalidá-lo:

Por que a Cloudflare pediu o desafio

Tudo começa quando o visitante pede uma página protegida. A Cloudflare avalia sinais de risco — reputação do IP, cabeçalhos da requisição e a configuração do handshake TLS — e, se o risco for considerado alto, responde com 403 ou 503 junto de uma página de desafio em JavaScript. Essa página roda verificações no navegador e pode carregar um widget Cloudflare Turnstile; ao concluir com sucesso, a Cloudflare grava o cookie e redireciona de volta para a URL original. Nem todo desafio é igual — o nível varia conforme o risco calculado:

A CaptchaAI resolve os três com o mesmo solucionador Cloudflare Turnstile, pelo fluxo de API mostrado acima.

Solução de problemas

Perguntas frequentes

O desafio aparece em toda página do site protegido?

Não necessariamente. Depende de regras específicas — WAF, pontuação de bot, rota acessada. Um site pode liberar a maior parte das páginas e reservar o desafio só para rotas sensíveis, como login ou checkout.

Preciso de um navegador completo para obter o cookie?

Sim, na prática. O desafio roda JavaScript e pode carregar o widget Turnstile, então um navegador real ou headless (Selenium, Puppeteer) é necessário para injetar o token e capturar o cookie depois.

Dá para usar o cookie fora do navegador, direto em requisições HTTP?

Sim. Depois de extraído, basta anexá-lo à sessão requests/axios usada nas próximas chamadas, mantendo o mesmo IP e User-Agent que resolveram o desafio originalmente.

Qual a diferença entre o desafio gerenciado e o interativo?

O gerenciado deixa a Cloudflare decidir: pode liberar em silêncio, mostrar o Turnstile ou pedir o desafio JS. O interativo sempre exibe o widget Turnstile, sem margem para passar batido.

O que fazer quando a Cloudflare pede novo desafio mesmo com o cookie salvo?

Confira primeiro o campo expiry: se o cookie ainda é válido, o problema costuma ser IP ou User-Agent divergentes entre a sessão que resolveu e a que está fazendo a requisição atual.

Resolva o desafio da Cloudflare com a CaptchaAI

Obtenha sua chave de API em captchaai.com e comece a resolver pelo mesmo endpoint usado nos exemplos acima.

Guias relacionados

• Como extrair a sitekey do Cloudflare Turnstile
• Cloudflare Turnstile vs hCaptcha vs reCAPTCHA: qual escolher
• Cookies e taxa de resolução: o que realmente importa