Requisitos de sesión y cookies reCAPTCHA para resolver

¿Necesitas conservar cookies para resolver reCAPTCHA? Depende de cómo resuelvas. Si generas el token con la API de CaptchaAI, no: basta con sitekey y pageurl, porque el token se produce en un entorno propio y el sitio lo valida sin mirar tu navegador. Si automatizas un navegador real, las cookies sí importan, porque reCAPTCHA las usa para reconocer sesiones de confianza y calcular la puntuación de riesgo. Este artículo separa esos dos caminos: qué cookies intervienen, cómo la sesión mueve la puntuación y cómo gestionarlas en producción.

Qué cookies usa reCAPTCHA y para qué sirven

No hay una sola cookie decisiva: intervienen tres familias con pesos distintos. Las propias del sitio guardan el historial de comportamiento; las de Google aportan una confianza que viaja entre sitios.

Cookies propias de reCAPTCHA

Cookies de la cuenta de Google (influyen en la puntuación)

Cookies de terceros que reCAPTCHA aprovecha

El fin de las cookies de terceros en Chrome y qué cambia

Chrome lleva tiempo restringiendo las cookies de terceros, y eso toca a reCAPTCHA porque _GRECAPTCHA se define en .google.com y se lee desde un contexto de tercero. Google ya adaptó reCAPTCHA a ese escenario: v3 y Enterprise ejecutan JavaScript de primera parte, las cookies migran al almacenamiento Partitioned (CHIPS) y las cookies rc:: ya son de primera parte, definidas en el dominio del sitio de destino.

El efecto depende de cómo resuelvas. La resolución por API apenas se ve afectada, porque CaptchaAI genera los tokens del lado del servidor. La automatización por navegador puede sufrir variaciones menores de puntuación: cuanto más dependas del navegador para la confianza, más te expones a estos cambios.

Cómo la sesión mueve la puntuación de riesgo

reCAPTCHA arranca desde una línea base de riesgo que sube o baja según lo que sepa de la sesión: una con historial parte con ventaja; una recién creada debe ganarse la confianza desde cero.

Sesión nueva, sin 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)

Sesión recurrente, con 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)

Esto explica un caso común en la región: una agencia en Madrid o Ciudad de México monta un flujo de QA para su propio portal de acceso (por ejemplo, un login con cita previa) y lo ejecuta headless en un datacenter. Cada corrida abre un navegador limpio, sin historial, así que reCAPTCHA la trata como un visitante nuevo: más desafíos de imagen en v2 y puntuaciones más bajas en v3. No es un fallo del sitio, es la sesión partiendo desde la base más baja.

Gestión de cookies en flujos de automatización

Para aprovechar esa confianza, conserva las cookies entre ejecuciones en lugar de empezar de cero. Cubren los casos más habituales.

Estrategia 1: tarro de cookies persistente

Mantén las cookies en todas las solicitudes para acumular confianza de sesión:

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())

Estrategia 2: reenvío de cookies en Selenium

Selenium solo acepta una cookie cuando el dominio actual coincide con el suyo, por eso el ejemplo carga la página antes de aplicar las cookies guardadas.

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

Estrategia 3: reenvío de cookies en 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 sesión al resolver con la API de CaptchaAI

Aquí muchos equipos se complican de más. Con CaptchaAI el servicio genera el token en su propio entorno y el sitio lo valida sin mirar tus cookies. Aun así, algunas implementaciones añaden una comprobación extra.

reCAPTCHA estándar (la mayoría de los sitios)

No hace falta reenviar cookies. CaptchaAI produce un token válido con solo sitekey y 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,
})

Implementaciones que atan el token a la sesión

Algunos sitios de alta seguridad comprueban que la sesión que envía el token sea la misma que cargó el widget. En esos casos el flujo mantiene la cadena de cookies dentro del navegador:

1. Carga la página en un navegador real para establecer las cookies
2. Extrae el sitekey de la página ya cargada
3. Envía a CaptchaAI con sitekey y pageurl
4. Inyecta el token devuelto en la misma sesión del navegador
5. Envía el formulario desde el navegador, conservando la cadena 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()

En resumen: si el sitio no ata el token a la sesión, resuelve por API y olvídate de las cookies; si lo ata, devuelve el token al mismo navegador que abrió el widget.

Diagnóstico de problemas de cookies y sesión

Casi siempre el fallo es una de estas cinco situaciones:

Preguntas frecuentes

¿Tengo que reenviar mis cookies cuando resuelvo con CaptchaAI?

No en el caso habitual. CaptchaAI genera el token en su propio entorno y solo necesita sitekey y pageurl. Solo reenvías cookies cuando el sitio ata el token a la sesión que cargó el widget.

¿Por qué reCAPTCHA v3 me da una puntuación baja en cada corrida?

Casi siempre porque cada ejecución arranca con una sesión limpia. Sin _GRECAPTCHA ni cookies rc::, reCAPTCHA te ve como un visitante sin historial y parte de la base más baja. Persistir las cookies entre corridas eleva ese punto de partida.

¿El fin de las cookies de terceros en Chrome rompe la resolución por API?

No. Como CaptchaAI produce el token del lado del servidor, el bloqueo de cookies de terceros no afecta a la vía por API. Lo que puede variar levemente es la puntuación en flujos que dependen del navegador, mientras Google mueve las cookies a almacenamiento particionado (CHIPS).

¿Qué cookies conviene conservar como mínimo?

_GRECAPTCHA es la más valiosa porque dura seis meses y marca al visitante como recurrente; las cookies rc:: aportan el historial de comportamiento. Si usas una cuenta de Google, SID y HSID suman confianza.

¿Por qué el modo incógnito dispara más desafíos?

Porque descarta la cookie de confianza _GRECAPTCHA y el historial rc::. reCAPTCHA te trata como un visitante nuevo y empieza la puntuación en una base más baja, así que aparecen más desafíos.

Resumen

reCAPTCHA usa cookies para el seguimiento de sesión (rc::), la confianza entre sitios (_GRECAPTCHA) y la cuenta de Google (SID, HSID); las sesiones nuevas parten de una puntuación más baja y reciben desafíos más duros. Con la resolución por API de CaptchaAI no necesitas cookies: el servicio genera el token con solo el sitekey y la URL. Y si el sitio ata el token a la sesión, carga la página en el navegador, resuelve con CaptchaAI, inyecta el token y envía desde la misma sesión.

Artículos relacionados

• Cómo resolver el callback de reCAPTCHA v2 con la API
• Manejo de reCAPTCHA v2 y Turnstile en el mismo sitio
• El mecanismo de callback de reCAPTCHA v2