Cookies reCAPTCHA e requisitos de sessão para solução

O reCAPTCHA depende de cookies para rastreamento de sessão, pontuação de risco e gerenciamento de estado de desafio. Cookies ausentes ou manipulados incorretamente causam falhas na resolução, pontuações baixas e desafios repetidos. Este guia aborda todos os cookies usados ​​pelo reCAPTCHA, como as sessões afetam a pontuação e o gerenciamento prático de cookies para automação.

Cookies que o reCAPTCHA define e usa

Cookies específicos do reCAPTCHA

Cookies da conta Google (pontuação de impacto)

Cookies de terceiros usados pelo reCAPTCHA

Como os cookies afetam a pontuação do reCAPTCHA

Sessão recente (sem cookies)

New browser session, all cookies cleared
    ↓
reCAPTCHA JavaScript loads
    ↓
No _GRECAPTCHA → First-time visitor signal
No SID/HSID → No Google account trust
No rc:: cookies → No behavioral history
    ↓
Starting risk score: lower baseline (0.3-0.5 for v3)
    ↓
Behavioral analysis must compensate for lack of history
    ↓
Result: More likely to receive visible challenge (v2)
         Lower score (v3)

Sessão de retorno (com cookies)

Existing browser session with cookies
    ↓
reCAPTCHA JavaScript loads
    ↓
_GRECAPTCHA found → Returning visitor
SID/HSID found → Google account trust
rc:: cookies found → Previous behavioral data
    ↓
Starting risk score: higher baseline (0.5-0.7 for v3)
    ↓
Behavioral analysis reinforces cookie-based trust
    ↓
Result: More likely to auto-pass (v2)
         Higher score (v3)

Gerenciamento de cookies em automação

Estratégia 1: pote de biscoitos persistente

Mantenha cookies em todas as solicitações para criar confiança na sessão:

import requests
import pickle
import os

class CookieManager:
    """Manage cookies for reCAPTCHA sessions."""

    def __init__(self, cookie_file="cookies.pkl"):
        self.cookie_file = cookie_file
        self.session = requests.Session()
        self.load_cookies()

    def load_cookies(self):
        """Load cookies from disk if they exist."""
        if os.path.exists(self.cookie_file):
            with open(self.cookie_file, "rb") as f:
                self.session.cookies = pickle.load(f)

    def save_cookies(self):
        """Save cookies to disk for next session."""
        with open(self.cookie_file, "wb") as f:
            pickle.dump(self.session.cookies, f)

    def visit_page(self, url):
        """Visit a page to collect cookies."""
        headers = {
            "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",
        }
        response = self.session.get(url, headers=headers, timeout=15)
        self.save_cookies()
        return response

    def get_recaptcha_cookies(self):
        """Get cookies relevant to reCAPTCHA."""
        relevant = {}
        for cookie in self.session.cookies:
            if cookie.name in ["_GRECAPTCHA", "SID", "HSID", "SSID", "NID"]:
                relevant[cookie.name] = {
                    "value": cookie.value[:20] + "...",
                    "domain": cookie.domain,
                    "expires": cookie.expires,
                }
            if cookie.name.startswith("rc::"):
                relevant[cookie.name] = {
                    "value": cookie.value[:20] + "...",
                    "domain": cookie.domain,
                }
        return relevant


# Usage
cm = CookieManager("recaptcha_session.pkl")
cm.visit_page("https://staging.example.com/qa-login")  # Build cookies
print(cm.get_recaptcha_cookies())

Estratégia 2: Encaminhamento de cookies no Selenium

from selenium import webdriver
import json

def setup_cookies(driver, cookie_file="selenium_cookies.json"):
    """Load and apply saved cookies to a Selenium session."""
    if not os.path.exists(cookie_file):
        return

    with open(cookie_file, "r") as f:
        cookies = json.load(f)

    for cookie in cookies:
        # Selenium requires the domain to match current page
        try:
            driver.add_cookie(cookie)
        except Exception:
            pass  # Skip cookies for different domains

def save_cookies(driver, cookie_file="selenium_cookies.json"):
    """Save current cookies for future sessions."""
    cookies = driver.get_cookies()
    with open(cookie_file, "w") as f:
        json.dump(cookies, f)

# Usage
driver = webdriver.Chrome()
driver.get("https://example.com")
setup_cookies(driver)  # Apply saved cookies
driver.refresh()       # Reload with cookies

# After CAPTCHA solving...
save_cookies(driver)   # Save for next run

Estratégia 3: Encaminhamento de cookies no Puppeteer

const puppeteer = require("puppeteer");
const fs = require("fs");

async function manageCookies(page, cookieFile = "cookies.json") {
    // Load cookies if file exists
    if (fs.existsSync(cookieFile)) {
        const cookies = JSON.parse(fs.readFileSync(cookieFile));
        await page.setCookie(...cookies);
    }

    // Save cookies after page interaction
    const saveCookies = async () => {
        const cookies = await page.cookies();
        fs.writeFileSync(cookieFile, JSON.stringify(cookies, null, 2));
    };

    return { saveCookies };
}

(async () => {
    const browser = await puppeteer.launch({ headless: false });
    const page = await browser.newPage();

    const { saveCookies } = await manageCookies(page);

    await page.goto("https://staging.example.com/qa-login");

    // ... solve CAPTCHA ...

    await saveCookies();
    await browser.close();
})();

Requisitos de sessão para solução baseada em API

Ao utilizar CaptchaAI, o solucionador gera tokens em seu próprio ambiente. O site de destino valida o token sem verificar os cookies do seu navegador. No entanto, algumas implementações adicionam validação extra:

ReCAPTCHA padrão (maioria dos sites)

Não é necessário encaminhamento de cookies. CaptchaAI gera um token válido usando apenas sitekey e pageurl:

import requests
import time

API_KEY = "YOUR_API_KEY"

# Standard solve — no cookies needed
submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": "SITE_KEY",
    "pageurl": "https://staging.example.com/qa-login",
    "json": 1,
})

Implementações dependentes de cookies

Alguns sites de alta segurança validam se a sessão que envia o token corresponde à sessão que carregou o widget reCAPTCHA. Nestes casos:

1. Carregue a página em um navegador real para estabelecer cookies
2. Extraia a chave do site da página carregada
3. Envie para CaptchaAI com sitekey e pageurl
4. Injete o token retornado na mesma sessão do navegador
5. Envie o formulário do navegador (mantendo a cadeia de cookies)

from selenium import webdriver
from selenium.webdriver.common.by import By
import requests
import time

API_KEY = "YOUR_API_KEY"

# Step 1: Load page in real browser (establishes cookies)
driver = webdriver.Chrome()
driver.get("https://secure-site.com/login")

# Step 2: Extract sitekey
widget = driver.find_element(By.CSS_SELECTOR, "[data-sitekey]")
sitekey = widget.get_attribute("data-sitekey")

# Step 3: Solve via CaptchaAI
submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": driver.current_url,
    "json": 1,
})
task_id = submit.json()["request"]

for _ in range(60):
    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.get("status") == 1:
        token = result["request"]
        break

# Step 4: Inject token into browser session (same cookies)
driver.execute_script(
    f'document.getElementById("g-recaptcha-response").value = "{token}";'
)

# Step 5: Submit form from same browser session
driver.find_element(By.CSS_SELECTOR, "form").submit()

Impacto do bloqueio de cookies de terceiros

Suspensão de uso de cookies de terceiros do Chrome

O Chrome está eliminando gradualmente os cookies de terceiros. Isso afeta o reCAPTCHA porque _GRECAPTCHA é definido em .google.com e lido no contexto de terceiros.

Resposta do Google:

• reCAPTCHA v3 e Enterprise usam execução de JavaScript própria
• Os cookies estão em transição para o armazenamento Partitioned (CHIPS)
• Os cookies rc:: já são primários (definidos no domínio do site de destino)

Impacto na automação:

• Mínimo. A resolução baseada em API não é afetada porque CaptchaAI gera tokens no lado do servidor.
• A automação baseada no navegador pode sofrer pequenas alterações na pontuação conforme o Google ajusta sua estratégia de cookies.

Solução de problemas de cookies

Perguntas frequentes

Preciso passar cookies para CaptchaAI?

Não. CaptchaAI gera tokens em seu próprio ambiente otimizado e não precisa dos cookies do seu navegador. Você só precisa fornecer sitekey e pageurl. O token gerado é válido para envio de qualquer cliente.

Os cookies expiram e exigem atualização?

Sim. _GRECAPTCHA dura 6 meses, mas os cookies de sessão rc:: expiram quando o navegador fecha. Os cookies da conta Google (SID, HSID) duram 2 anos, mas podem ser invalidados pelo Google. Para automação, mantenha os cookies no disco e atualize-os periodicamente visitando o site de destino.

Posso usar cookies de um navegador em outro?

Sim, com limitações. Os cookies podem ser exportados (no formato JSON ou Netscape) e importados para solicitações, sessões Selenium ou Puppeteer. No entanto, a sinal de navegador do navegador será diferente, o que o reCAPTCHA pode detectar. Os cookies fornecem um bônus de confiança, mas o novo ambiente do navegador pode compensá-lo.

Por que limpar os cookies torna o reCAPTCHA mais difícil?

A limpeza de cookies remove o cookie de confiança _GRECAPTCHA e os cookies de histórico comportamental rc::. O reCAPTCHA trata você como um visitante completamente novo, sem histórico, iniciando a pontuação de risco em uma linha de base mais baixa. É por isso que a navegação anônima /private geralmente desencadeia mais desafios CAPTCHA.

Resumo

O reCAPTCHA usa cookies para rastreamento de sessão (cookies rc::), confiança entre sites (_GRECAPTCHA) e vinculação de contas do Google (SID, HSID). Novas sessões sem cookies produzem pontuações mais baixas e desafios mais difíceis. Para solução baseada em API comCaptchaAI, os cookies não são necessários — o solucionador gera tokens válidos usando apenas a chave do site e o URL da página. Para implementações dependentes de cookies, use uma abordagem baseada em navegador: carregue a página (estabelecendo cookies), resolva via CaptchaAI, injete o token e envie a partir da mesma sessão do navegador.

Artigos relacionados

• Como resolver o retorno de chamada do Recaptcha V2 usando API
• Torniquete Recaptcha V2 no mesmo local
• Mecanismo de retorno de chamada Recaptcha V2