Requisitos de sesión y cookies reCAPTCHA para resolver

reCAPTCHA se basa en cookies para el seguimiento de sesiones, la puntuación de riesgos y la gestión del estado de desafíos. Las cookies que faltan o se manejan incorrectamente provocan fallas en la resolución, puntajes bajos y desafíos repetidos. Esta guía cubre cada cookie que utiliza reCAPTCHA, cómo las sesiones afectan la puntuación y la gestión práctica de cookies para la automatización.

Conjuntos y usos de cookies reCAPTCHA

Cookies específicas de reCAPTCHA

Cookies de la cuenta de Google (afectan a la puntuación)

Cookies de terceros utilizadas por reCAPTCHA

Cómo afectan las cookies a la puntuación reCAPTCHA

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

Gestión de cookies en la automatización

Estrategia 1: tarro de galletas persistente

Mantenga las cookies en todas las solicitudes para generar confianza en la 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

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 para la resolución basada en API

Cuando se utiliza CaptchaAI, el solucionador genera tokens en su propio entorno. El sitio web de destino valida el token sin comprobar las cookies de su navegador. Sin embargo, algunas implementaciones añaden validación adicional:

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

No se necesita reenvío de cookies. CaptchaAI genera un token válido utilizando únicamente 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 dependientes de cookies

Algunos sitios de alta seguridad validan que la sesión que envía el token coincide con la sesión que cargó el widget reCAPTCHA. En estos casos:

1. Cargue la página en un navegador real para establecer cookies
2. Extraiga la clave del sitio de la página cargada
3. Enviar a CaptchaAI con sitekey y pageurl
4. Inyecte el token devuelto en la misma sesión del navegador
5. Enviar el formulario desde el navegador (manteniendo 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()

Impacto del bloqueo de cookies de terceros

Desuso de cookies de terceros de Chrome

Chrome está eliminando progresivamente las cookies de terceros. Esto afecta a reCAPTCHA porque _GRECAPTCHA está configurado en .google.com y se lee desde un contexto de terceros.

Respuesta de Google:

• reCAPTCHA v3 y Enterprise utilizan ejecución de JavaScript propia
• Las cookies están pasando al almacenamiento Partitioned (CHIPS)
• Las cookies rc:: ya son propias (establecidas en el dominio del sitio de destino)

Impacto en la automatización:

• Mínimo. La resolución basada en API no se ve afectada porque CaptchaAI genera tokens en el lado del servidor.
• La automatización basada en el navegador puede experimentar cambios menores en la puntuación a medida que Google ajusta su estrategia de cookies.

Solución de problemas de cookies

Preguntas frecuentes

¿Necesito pasar cookies a CaptchaAI?

No. CaptchaAI genera tokens en su propio entorno optimizado y no necesita las cookies de su navegador. Sólo necesita proporcionar sitekey y pageurl. El token generado es válido para ser enviado por cualquier cliente.

¿Las cookies caducan y requieren actualización?

Sí. _GRECAPTCHA dura 6 meses pero las cookies de sesión rc:: caducan cuando se cierra el navegador. Las cookies de la cuenta de Google (SID, HSID) duran 2 años pero pueden ser invalidadas por Google. Para la automatización, guarde las cookies en el disco y actualícelas periódicamente visitando el sitio de destino.

¿Puedo utilizar cookies de un navegador en otro?

Sí, con limitaciones. Las cookies se pueden exportar (en formato JSON o Netscape) e importar a solicitudes, sesiones de Selenium o Puppeteer. Sin embargo, la señales del navegador del navegador será diferente y reCAPTCHA puede detectarla. Las cookies proporcionan una ventaja de confianza, pero el nuevo entorno del navegador puede compensarla.

¿Por qué borrar las cookies hace que reCAPTCHA sea más difícil?

Al borrar las cookies, se eliminan la cookie de confianza _GRECAPTCHA y las cookies del historial de comportamiento rc::. reCAPTCHA lo trata como un visitante completamente nuevo sin historial, comenzando la puntuación de riesgo en una base más baja. Esta es la razón por la que la navegación de incógnito/private a menudo genera más desafíos CAPTCHA.

Resumen

reCAPTCHA utiliza cookies para el seguimiento de sesiones (cookies rc::), confianza entre sitios (_GRECAPTCHA) y vinculación de cuentas de Google (SID, HSID). Las sesiones nuevas sin cookies producen puntuaciones más bajas y desafíos más difíciles. Para resolución basada en API conCaptchaAI, las cookies no son necesarias: el solucionador genera tokens válidos utilizando únicamente la clave del sitio y la URL de la página. Para implementaciones que dependen de cookies, utilice un enfoque basado en navegador: cargue la página (estableciendo cookies), resuelva mediante CaptchaAI, inyecte el token y envíe desde la misma sesión del navegador.

Artículos relacionados

• Cómo resolver la devolución de llamada de Recaptcha V2 usando Api
• Torniquete Recaptcha V2 Manejo en el mismo sitio
• Mecanismo de devolución de llamada Recaptcha V2