Cookies do reCAPTCHA e sessão: o que muda na resolução automática

Resposta direta: na maioria dos sites, resolver o reCAPTCHA pela API não exige cookie nenhum do navegador — a CaptchaAI gera o token no próprio ambiente. O caso à parte é a fatia de sites de alta segurança que conferem se quem envia o token é a mesma sessão que carregou o widget. Este guia mapeia os cookies do reCAPTCHA, como eles pesam na pontuação e quando sua integração realmente precisa geri-los.

Quais cookies o reCAPTCHA usa e para quê

Cookies específicos do reCAPTCHA

• _GRECAPTCHA (.google.com, 6 meses) — estado do reCAPTCHA entre sites.
• rc::a (site de destino, sessão) — análise de risco: canvas e hash de comportamento do mouse.
• rc::b (site de destino, sessão) — análise de risco: sinais comportamentais.
• rc::c (site de destino, sessão) — análise de risco: tempo.
• rc::d-15# (site de destino, sessão) — persistência do estado do desafio.

Cookies da conta Google que pesam na pontuação

• SID (.google.com) — ID de sessão do Google; soma de +0,1 a +0,3 na pontuação.
• HSID (.google.com) — ID de sessão somente HTTP; entra na confiança de sessão.
• SSID (.google.com) — ID de sessão seguro; também compõe a confiança de sessão.
• NID (.google.com) — preferência/sessão do Google; soma de +0,05 a +0,1.
• 1P_JAR (.google.com) — personalização de anúncios do Google; sinal de confiança menor.

Cookies de terceiros usados pelo reCAPTCHA

• CONSENT (.google.com) — estado de consentimento de cookies.
• AEC (.google.com) — cookie de anúncio criptografado.
• SOCS (.google.com) — configurações de consentimento de cookies.

Como a sessão muda a pontuação do reCAPTCHA

Sessão nova, 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 recorrente, 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)

Na prática, sessão zerada empurra o v3 para uma pontuação mais baixa e aumenta a chance de o v2 exibir o desafio de imagem — por isso testes em janela anônima ou troca de perfil a cada execução costumam piorar o resultado, não é o site que está mais rígido.

Como gerenciar cookies em automação com navegador

Já vimos que sessão zerada derruba a pontuação. Como manter cookies vivos entre execuções quando a automação passa por navegador? Três abordagens cobrem a maioria dos stacks.

Estratégia 1: cookie jar persistente

Mantenha os cookies entre requisições para construir confiança de 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())

Detalhe que passa batido: se cookies.pkl guarda SID/HSID de contas reais, trate-o como dado sensível na política de retenção — a LGPD cobre qualquer identificador que reconheça uma pessoa.

Estratégia 2: repasse 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: repasse 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();
})();

A região do servidor não devolve pontuação sozinha, mas afeta a latência: workers em sa-east-1 (São Paulo) carregam o reCAPTCHA de sites brasileiros mais rápido do que instâncias fora do país — o ganho de confiança continua vindo dos cookies, não da região.

Quando você realmente precisa de cookies para resolver

As três estratégias acima resolvem o problema para quem automatiza pelo navegador. Mas nem toda integração exige esse trabalho: ao usar a CaptchaAI, o solver gera o token no próprio ambiente e o site de destino valida esse token sem checar os cookies do seu navegador. Vale confirmar em qual dos dois grupos abaixo o seu caso está antes de manter esse gerenciamento de cookies só por precaução.

Resolução padrão: sitekey e pageurl bastam

Não é preciso repassar nenhum cookie. A 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,
})

Sites que validam a cadeia de cookies

Alguns sites de alta segurança conferem se a sessão que envia o token é a mesma que carregou o widget do reCAPTCHA. Nesses casos, o fluxo muda:

1. Carregue a página em um navegador real para estabelecer os cookies
2. Extraia a sitekey da página carregada
3. Envie o par sitekey/pageurl à CaptchaAI
4. Injete o token retornado na mesma sessão do navegador
5. Envie o formulário a partir 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()

O fim dos cookies de terceiros no Chrome muda alguma coisa?

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

Problemas comuns com cookies e como resolver

reCAPTCHA v2 sempre mostra desafio de imagem

Causa: sem cookies de sessão, a confiança começa baixa. Persista cookies entre requisições.

Pontuação do reCAPTCHA v3 sempre abaixo de 0,3

Causa: sessão nova a cada execução. Mantenha um cookie jar entre chamadas.

Token funciona uma vez e falha na nova tentativa

Causa: o cookie de sessão não bate entre a página que gerou o widget e a que recebeu o token. Use a mesma sessão para carregar e enviar.

"Falha na validação de cookie/sessão"

Causa: o site confere a cadeia de cookies. Injete o token pelo navegador, na mesma sessão que carregou o widget.

Widget do reCAPTCHA não carrega

Causa: cookies de terceiros bloqueados. Libere cookies de google.com no perfil da automação.

Perguntas frequentes

Rodar a automação em VPS sem histórico de navegação reduz a pontuação do reCAPTCHA v3?

Sim. Uma instância nova, sem cookies e sem histórico naquele domínio, começa com a pontuação de risco na faixa baixa (0,3 a 0,5) — não é bug do provedor, é o comportamento esperado diante de qualquer sessão sem histórico.

Preciso enviar cookies do navegador para a CaptchaAI resolver o reCAPTCHA?

Não, na grande maioria dos sites. A CaptchaAI gera o token em seu próprio ambiente e não depende dos cookies do seu navegador — basta enviar sitekey e pageurl. O token gerado é válido para envio a partir de qualquer cliente.

Vale a pena manter um cookie jar se eu resolvo tudo via API, sem abrir navegador?

Depende do site. No fluxo padrão (sitekey + pageurl), não — o token nem passa pela sua sessão de navegador. Se o site checa a cadeia de cookies, sim: sem cookie jar, o token injetado não vai bater com a sessão que carregou o widget.

O que é o cookie _GRECAPTCHA e por que ele pesa na pontuação?

O Google usa esse cookie para lembrar que o navegador já resolveu um reCAPTCHA antes, válido por 6 meses em .google.com. Sem ele, a pontuação de risco parte de uma base mais baixa e sessões limpas recebem mais desafios.

O reCAPTCHA v2 e o v3 usam os mesmos cookies de sessão?

Sim. _GRECAPTCHA, os cookies rc:: e os da conta Google alimentam o mesmo modelo de confiança nas duas versões — o v2 usa esse sinal para decidir se mostra o desafio de imagem, e o v3 traduz o mesmo sinal em pontuação.

Resumo

O reCAPTCHA usa cookies para rastrear sessão (rc::), manter confiança entre sites (_GRECAPTCHA) e vincular contas do Google (SID, HSID). Sessões novas produzem pontuações mais baixas e desafios mais difíceis. Para resolução via API com a CaptchaAI, cookies não são obrigatórios — o solver gera tokens válidos com apenas a sitekey e a URL da página. Para implementações que checam a cadeia de cookies, o caminho é o fluxo via navegador: carregar a página, resolver, injetar o token e enviar na mesma sessão.

Artigos relacionados

• Como resolver o callback do reCAPTCHA v2 pela API
• Turnstile e reCAPTCHA v2 no mesmo site
• Como funciona o mecanismo de callback do reCAPTCHA v2