Conditions requises pour les cookies et les sessions reCAPTCHA pour la résolution

reCAPTCHA s'appuie sur des cookies pour le suivi des sessions, l'évaluation des risques et la gestion de l'état des défis. Les cookies manquants ou mal gérés entraînent des échecs de résolution, des scores faibles et des défis répétés. Ce guide couvre tous les cookies utilisés par reCAPTCHA, la façon dont les sessions affectent la notation et la gestion pratique des cookies pour l'automatisation.

Cookies définis et utilisés par reCAPTCHA

Cookies spécifiques à reCAPTCHA

Cookies du compte Google (affectent le score)

Cookies tiers utilisés par reCAPTCHA

Comment les cookies affectent le score reCAPTCHA

Nouvelle session (pas de 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)

Session de retour (avec 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)

Gestion des cookies en automatisation

Stratégie 1 : pot à cookies persistant

Conservez les cookies dans toutes les requêtes pour établir la confiance de la session :

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://example.com/login")  # Build cookies
print(cm.get_recaptcha_cookies())

Stratégie 2 : transfert de cookies dans 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

Stratégie 3 : transfert de cookies dans 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://example.com/login");

    // ... solve CAPTCHA ...

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

Exigences de session pour la résolution basée sur l'API

Lors de l'utilisation de CaptchaAI, le solveur génère des jetons dans son propre environnement. Le site Web cible valide le token sans vérifier les cookies de votre navigateur. Cependant, certaines implémentations ajoutent une validation supplémentaire :

reCAPTCHA standard (la plupart des sites)

Aucun transfert de cookie n'est nécessaire. CaptchaAI génère un jeton valide en utilisant uniquement sitekey et 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://example.com/login",
    "json": 1,
})

Implémentations dépendantes des cookies

Certains sites de haute sécurité valident que la session soumettant le jeton correspond à la session qui a chargé le widget reCAPTCHA. Dans ces cas :

1. Charger la page dans un vrai navigateur pour établir des cookies
2. Extraire la clé du site de la page chargée
3. Soumettre à CaptchaAI avec sitekey et pageurl
4. Injectez le jeton renvoyé dans la même session de navigateur
5. Soumettre le formulaire depuis le navigateur (en maintenant la chaîne 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()

Impact du blocage des cookies tiers

Abandon des cookies tiers de Chrome

Chrome supprime progressivement les cookies tiers. Cela affecte reCAPTCHA car _GRECAPTCHA est défini sur .google.com et lu à partir d'un contexte tiers.

Réponse de Google :

• reCAPTCHA v3 et Enterprise utilisent une exécution JavaScript propriétaire
• Les cookies sont en cours de transition vers le stockage Partitioned (CHIPS)
• Les cookies rc:: sont déjà propriétaires (définis sur le domaine du site cible)

Impact sur l'automatisation :

• Minime. La résolution basée sur l'API n'est pas affectée car CaptchaAI génère des jetons côté serveur.
• L'automatisation basée sur le navigateur peut entraîner des changements mineurs dans les scores à mesure que Google ajuste sa stratégie en matière de cookies.

Dépannage des cookies

Questions fréquemment posées

Dois-je transmettre des cookies à CaptchaAI ?

Non. CaptchaAI génère des jetons dans son propre environnement optimisé et n'a pas besoin des cookies de votre navigateur. Il vous suffit de fournir sitekey et pageurl. Le jeton généré est valide pour la soumission à partir de n'importe quel client.

Les cookies expirent-ils et nécessitent-ils une actualisation ?

Oui. _GRECAPTCHA dure 6 mois mais les cookies de session rc:: expirent à la fermeture du navigateur. Les cookies du compte Google (SID, HSID) durent 2 ans mais peuvent être invalidés par Google. Pour l'automatisation, conservez les cookies sur le disque et actualisez-les périodiquement en visitant le site cible.

Puis-je utiliser des cookies d’un navigateur à un autre ?

Oui, avec des limites. Les cookies peuvent être exportés (au format JSON ou Netscape) et importés dans des requêtes, des sessions Selenium ou Puppeteer. Cependant, l'empreinte digitale du navigateur sera différente, ce que reCAPTCHA peut détecter. Les cookies offrent un bonus de confiance, mais le nouvel environnement du navigateur peut le compenser.

Pourquoi la suppression des cookies rend-elle reCAPTCHA plus difficile ?

La suppression des cookies supprime le cookie de confiance _GRECAPTCHA et les cookies d'historique comportemental rc::. reCAPTCHA vous traite comme un tout nouveau visiteur sans historique, commençant le score de risque à un niveau de base inférieur. C'est pourquoi la navigation incognito/private déclenche souvent davantage de défis CAPTCHA.

Résumé

reCAPTCHA utilise des cookies pour le suivi de session (cookies rc::), la confiance entre sites (_GRECAPTCHA) et la liaison de compte Google (SID, HSID). De nouvelles sessions sans cookies produisent des scores inférieurs et des défis plus difficiles. Pour une résolution basée sur API avecCaptchaAI, les cookies ne sont pas requis — le solveur génère des jetons valides en utilisant uniquement la clé du site et l'URL de la page. Pour les implémentations dépendantes des cookies, utilisez une approche basée sur le navigateur : chargez la page (établissement des cookies), résolvez via CaptchaAI, injectez le jeton et soumettez à partir de la même session de navigateur.

Articles connexes

• Comment résoudre le rappel Recaptcha V2 à l'aide de l'API
• Gestion du tourniquet Recaptcha V2 sur le même site
• Mécanisme de rappel Recaptcha V2