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

Non : pour résoudre un reCAPTCHA via une API, vous n'avez aucun cookie à transmettre. Les cookies décident quand même de la difficulté du défi reçu — donc du temps de résolution que votre pipeline consomme. Un profil sans historique déclenche beaucoup plus de grilles d'images en v2 et démarre plus bas en v3 ; une session établie passe souvent sans friction visible.

• Résolution par API : sitekey et pageurl suffisent, aucun cookie ne circule.
• Automatisation navigateur : conserver les cookies entre les exécutions réduit les défis visuels.
• Exception : les sites qui vérifient la continuité de session imposent d'injecter le token dans le navigateur d'origine.

Quels cookies reCAPTCHA pose et relit

Trois familles cohabitent : les cookies du widget, ceux du compte Google, ceux du consentement.

La hiérarchie compte : rc:: est propriétaire et porte l'historique de la visite en cours, _GRECAPTCHA porte la réputation entre sites, les cookies Google ajoutent une confiance de compte qu'un profil neuf n'aura jamais.

Cookies tiers, CHIPS et obligations RGPD

Chrome retire progressivement les cookies tiers, et _GRECAPTCHA est précisément lu depuis un contexte tiers puisqu'il vit sur .google.com. Voici ce que Google a mis en place :

• reCAPTCHA v3 et reCAPTCHA Enterprise reposent davantage sur l'exécution JavaScript propriétaire que sur la lecture intersites.
• Les cookies migrent vers le stockage cloisonné Partitioned (CHIPS).
• Les cookies rc:: sont déjà propriétaires, donc insensibles à ce changement.

Ce que cela change pour vous :

• Résolution par API : rien. Le token est produit côté serveur, hors de votre contexte navigateur.
• Automatisation pilotée par navigateur : des variations mineures de score, le temps que Google ajuste sa stratégie de stockage.

Côté conformité : un cookie jar sérialisé contient des identifiants de session, donc des données personnelles dès qu'il vient d'un profil réel. Logique RGPD habituelle — comptes de recette, conservation courte, volume chiffré, aucune session d'utilisateur final réutilisée. Un fichier cookies.pkl oublié dans un dépôt Git est une fuite, pas un artefact de build.

Ce que change une session vierge sur le score

Session neuve, aucun cookie

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, cookies conservés

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)

L'écart est structurel : sans historique, l'analyse comportementale compense seule. C'est aussi ce qui explique la navigation privée — davantage de défis visuels, pour le même utilisateur et le même site.

Dépannage : symptôme, cause, correctif

Les trois premières lignes se règlent en persistant l'état ; les deux dernières imposent de changer d'approche.

Trois stratégies pour conserver les cookies en automatisation

Trois piles, un même principe : écrire le jar sur disque après l'interaction, le relire au démarrage suivant.

Stratégie 1 : un cookie jar persistant

Conservez les cookies d'une exécution à l'autre au lieu de repartir de zéro chaque nuit :

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

Exemple : une équipe QA à Lyon lance sa régression de connexion chaque nuit depuis un runner OVHcloud. Avec un profil vierge, elle recevait une grille d'images sur presque tous les runs ; avec un jar par environnement de recette, rejoué une fois par semaine, les défis visuels sont devenus l'exception.

Stratégie 2 : réinjection des 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

Deux pièges : Selenium refuse un cookie dont le domaine ne correspond pas à la page courante (chargez le domaine, puis injectez), et driver.refresh() reste nécessaire pour que la page soit réévaluée.

Stratégie 3 : réinjection des 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();
})();

Sauvegardez après l'interaction, jamais avant : les cookies rc:: ne s'écrivent qu'une fois le widget chargé.

Résolution par API : la session compte-t-elle vraiment ?

Avec CaptchaAI, le token est produit dans l'environnement du service, et le site cible le valide auprès de Google sans inspecter vos cookies. Deux cas se présentent.

reCAPTCHA standard : la majorité des sites

Aucun transfert de cookie n'est nécessaire. Le sitekey et le pageurl suffisent :

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 liées à la session

Certains sites vérifient que la session qui soumet le token est celle qui a chargé le widget. La séquence devient alors :

1. Charger la page dans un vrai navigateur pour établir les cookies
2. Extraire le sitekey depuis la page chargée
3. Envoyer sitekey et pageurl à CaptchaAI
4. Injecter le token renvoyé dans cette même session de navigateur
5. Soumettre le formulaire depuis le navigateur, en conservant 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()

Tant que la soumission part du navigateur qui a chargé le widget, la chaîne de cookies reste intacte. Réservez cette variante aux sites concernés : le mode API pur reste plus rapide à l'échelle.

Questions fréquentes

Faut-il envoyer les cookies de mon navigateur à l'API ?

Non. CaptchaAI produit le token dans son propre environnement à partir du sitekey et du pageurl, et ce token est valable depuis n'importe quel client.

À quelle fréquence faut-il rafraîchir un cookie jar ?

Une visite hebdomadaire du domaine cible suffit. _GRECAPTCHA vit six mois, les cookies rc:: meurent à la fermeture du navigateur, et les cookies Google peuvent être invalidés sans prévenir.

Peut-on partager un même cookie jar entre plusieurs workers ?

C'est déconseillé : une même session rejouée depuis plusieurs adresses IP en parallèle est un signal contradictoire qui fait chuter le score. Attribuez un jar par worker, ou passez à la résolution par API, qui ne dépend d'aucun état local. Le plan BASIC ($15/mois, 5 threads) suffit pour une suite de tests nocturne.

Se connecter à un compte Google améliore-t-il vraiment le score ?

Oui : SID pèse de +0,1 à +0,3 sur le score et NID de +0,05 à +0,1. Utilisez un compte dédié aux tests, jamais un compte personnel ou client.

Stocker un cookie jar pose-t-il un problème RGPD ?

Dès qu'il vient d'un profil réel, oui : un cookie de session est une donnée personnelle. Comptes de recette, conservation limitée, fichier hors du dépôt de code, finalité documentée. Ce point relève de votre politique interne, pas d'un conseil juridique.

À retenir

reCAPTCHA lit rc:: pour l'historique de la visite, _GRECAPTCHA pour la réputation intersites et SID ou HSID pour la confiance de compte. Une session sans cookies démarre plus bas et reçoit des défis plus durs : c'est un coût de temps, pas un mur. Pour une résolution par API avec CaptchaAI, le sitekey et l'URL de la page suffisent. Réservez l'approche navigateur — charger, résoudre, injecter, soumettre depuis la même session — aux sites qui vérifient réellement la continuité de session.

Articles connexes

• Résoudre un reCAPTCHA v2 à callback via l'API
• Faire cohabiter reCAPTCHA v2 et Cloudflare Turnstile sur un même site
• Le callback reCAPTCHA v2 en détail