Explication du paramètre reCAPTCHA Data-S (guide complet)

Le paramètre data-s est un jeton spécifique à la session qui apparaît dans certaines implémentations de reCAPTCHA, principalement sur les propriétés appartenant à Google telles que la recherche Google, YouTube et Google Play. Lorsqu'il est présent, il doit être inclus dans votre requête API de solveur - son omission entraîne des échecs de résolution ou des jetons invalides. Ce guide explique ce qu'est data-s, où il apparaît, comment l'extraire et comment le transmettre à CaptchaAI.

Quel est le paramètre data-s ?

Le paramètre data-s est un jeton de session généré par le serveur et intégré dans le widget HTML reCAPTCHA. Il lie le défi CAPTCHA à une session de serveur spécifique, empêchant la réutilisation des jetons entre différentes sessions.

Où il apparaît

<!-- reCAPTCHA widget with data-s parameter -->
<div class="g-recaptcha"
     data-sitekey="6LcR_RsTAAAAAN_r0GEkGBfq3L7KmU5JbPHJtwNp"
     data-s="AB2grfE8_kyMp3XYRuJo5c..."
     data-callback="onCaptchaSolved">
</div>

L'attribut data-s se trouve à côté de l'attribut data-sitekey standard sur l'élément reCAPTCHA <div>.

Caractéristiques clés

Propriété	Valeur
Format	Chaîne codée en base64, 200 à 500 caractères
À vie	À usage unique, lié au chargement de la page en cours
Portée	Spécifique à la session, ne peut pas être réutilisé lors des chargements de pages
Obligatoire	Oui, lorsqu'il est présent – la résolution échoue sans cela
Actualisation	Nouvelle valeur sur chaque page load/refresh

Lorsque data-s est présent

Le paramètre data-s n'est PAS présent sur la plupart des implémentations de reCAPTCHA. Il apparaît principalement sur :

Site	Présence	Remarques
Recherche Google (désolé, trafic /unusual)	Toujours	Requis pour la résolution des CAPTCHA de la recherche Google
YouTube	Parfois	Apparaît sur certains flux de vérification
Google Play	Parfois	Vérification de la liste des applications
Google Formulaires	Rarement	Implémentations limitées
Sites tiers utilisant reCAPTCHA	Presque jamais	Les intégrations standard n'utilisent pas de données

Si vous ne travaillez PAS avec des propriétés appartenant à Google, vous n'avez probablement pas à vous soucier de data-s. Si votre solveur renvoie des jetons non valides pour un CAPTCHA de recherche Google, un data-s manquant en est probablement la cause.

Comment fonctionne techniquement Data-S

User triggers CAPTCHA (e.g., Google flags unusual search traffic)
    ↓
Google serves a CAPTCHA page with:

  - data-sitekey (site key, same for all Google search CAPTCHAs)
  - data-s (session token, unique per page load)
    ↓
reCAPTCHA widget initializes with both parameters
    ↓
Challenge completion generates a g-recaptcha-response token
    ↓
Token is submitted alongside the session reference
    ↓
Google validates token + session binding
    ↓
If data-s was not used during solving: "invalid-input-response" or silent failure

Le paramètre data-s agit essentiellement comme une valeur occasionnelle : il lie le défi CAPTCHA à une session spécifique côté serveur. Le solveur doit utiliser cette valeur lors de la génération du jeton afin que le jeton résultant corresponde à la session attendue.

Extraire les données de la page

Extraction Python

import requests
from bs4 import BeautifulSoup
import re

def extract_recaptcha_params(url):
    """Extract reCAPTCHA parameters including data-s from a page."""
    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 = requests.get(url, headers=headers, timeout=15)
    soup = BeautifulSoup(response.text, "html.parser")

    # Find reCAPTCHA widget div
    widget = soup.find("div", class_="g-recaptcha")
    if not widget:
        # Try finding by data-sitekey attribute
        widget = soup.find(attrs={"data-sitekey": True})

    if not widget:
        return {"error": "No reCAPTCHA widget found"}

    params = {
        "sitekey": widget.get("data-sitekey"),
        "data_s": widget.get("data-s"),
        "callback": widget.get("data-callback"),
        "size": widget.get("data-size"),
        "has_data_s": widget.get("data-s") is not None,
    }

    return params

# Example: Google "unusual traffic" page
params = extract_recaptcha_params("https://www.google.com/sorry/index")
print(params)
# {
#   "sitekey": "6LfwuyUT...",
#   "data_s": "AB2grfE8_kyMp3...",
#   "has_data_s": True
# }

Extraction Node.js

const axios = require("axios");
const cheerio = require("cheerio");

async function extractRecaptchaParams(url) {
    const { data: html } = await axios.get(url, {
        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",
        },
        timeout: 15000,
    });

    const $ = cheerio.load(html);
    const widget = $(".g-recaptcha, [data-sitekey]").first();

    if (widget.length === 0) {
        return { error: "No reCAPTCHA widget found" };
    }

    return {
        sitekey: widget.attr("data-sitekey"),
        dataS: widget.attr("data-s") || null,
        callback: widget.attr("data-callback") || null,
        hasDataS: !!widget.attr("data-s"),
    };
}

extractRecaptchaParams("https://www.google.com/sorry/index")
    .then(console.log);

Extraction de sélénium (pour les pages dynamiques)

from selenium import webdriver
from selenium.webdriver.common.by import By

def extract_data_s_selenium(driver, url):
    """Extract data-s from a dynamically loaded reCAPTCHA page."""
    driver.get(url)

    # Wait for reCAPTCHA widget to load
    import time
    time.sleep(3)

    try:
        widget = driver.find_element(By.CSS_SELECTOR, ".g-recaptcha, [data-sitekey]")
        return {
            "sitekey": widget.get_attribute("data-sitekey"),
            "data_s": widget.get_attribute("data-s"),
        }
    except Exception:
        return {"error": "Widget not found"}

Résolution avec des données en utilisant CaptchaAI

Lorsque data-s est présent, incluez-le dans votre requête API CaptchaAI :

Python

import requests
import time

API_KEY = "YOUR_API_KEY"

# Step 1: Extract parameters from the CAPTCHA page
sitekey = "6LfwuyUTAAAAAOAmoS0fdqijC2PbbdH4kjq62Y1b"
data_s = "AB2grfE8_kyMp3XYRuJo5c..."  # Extracted from data-s attribute
page_url = "https://www.google.com/sorry/index?continue=..."

# Step 2: Submit to CaptchaAI WITH data-s
submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": page_url,
    "data-s": data_s,  # Include data-s parameter
    "json": 1,
})

task_id = submit.json()["request"]

# Step 3: Poll for result
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"]
        print(f"Token: {token[:60]}...")
        # Submit this token to the Google CAPTCHA form
        break

Noeud.js

const axios = require("axios");

async function solveWithDataS(sitekey, dataS, pageUrl) {
    const API_KEY = "YOUR_API_KEY";

    // Submit with data-s
    const { data: submit } = await axios.post(
        "https://ocr.captchaai.com/in.php",
        new URLSearchParams({
            key: API_KEY,
            method: "userrecaptcha",
            googlekey: sitekey,
            pageurl: pageUrl,
            "data-s": dataS,
            json: 1,
        })
    );

    const taskId = submit.request;

    // Poll
    for (let i = 0; i < 60; i++) {
        await new Promise((r) => setTimeout(r, 5000));
        const { data: result } = await axios.get(
            "https://ocr.captchaai.com/res.php",
            {
                params: {
                    key: API_KEY,
                    action: "get",
                    id: taskId,
                    json: 1,
                },
            }
        );

        if (result.status === 1) {
            return result.request;
        }
    }

    throw new Error("Timeout");
}

Erreurs de données courantes

Erreur	Symptôme	Corriger
Omettre les données lorsqu'elles sont présentes	La validation du jeton échoue silencieusement	Vérifiez toujours l'attribut data-s avant de soumettre
Y compris les données lorsqu'elles ne sont pas présentes	Résoudre une erreur ou une demande rejetée	N'incluez les données que si l'attribut existe sur le widget
Réutilisation des données lors des chargements de pages	Jeton invalide	Extraire de nouvelles données pour chaque chargement de page
Les données d'encodage d'URL sont incorrectes	Paramètre mal formé	Transmettez la valeur brute base64 sans encodage supplémentaire
Utilisation de données obsolètes (page chargée il y a quelques minutes)	Inadéquation des jetons	Extraire les données immédiatement avant de les soumettre au solveur

Assistant d'extraction de données

Un utilitaire réutilisable qui gère les pages reCAPTCHA avec et sans données :

import requests
from bs4 import BeautifulSoup

class RecaptchaExtractor:
    """Extract reCAPTCHA parameters from any page."""

    def __init__(self, url, session=None):
        self.url = url
        self.session = session or requests.Session()
        self.params = None

    def extract(self):
        """Extract sitekey, data-s, and other parameters."""
        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(self.url, headers=headers, timeout=15)
        soup = BeautifulSoup(response.text, "html.parser")

        widget = soup.find(attrs={"data-sitekey": True})
        if not widget:
            raise ValueError("No reCAPTCHA widget found on page")

        self.params = {
            "sitekey": widget["data-sitekey"],
            "pageurl": self.url,
        }

        # Include data-s only if present
        data_s = widget.get("data-s")
        if data_s:
            self.params["data-s"] = data_s

        return self.params

    def build_solver_payload(self, api_key):
        """Build CaptchaAI submission payload with correct parameters."""
        if not self.params:
            self.extract()

        payload = {
            "key": api_key,
            "method": "userrecaptcha",
            "googlekey": self.params["sitekey"],
            "pageurl": self.params["pageurl"],
            "json": 1,
        }

        # Only include data-s when it exists
        if "data-s" in self.params:
            payload["data-s"] = self.params["data-s"]

        return payload


# Usage
extractor = RecaptchaExtractor("https://www.google.com/sorry/index?continue=...")
payload = extractor.build_solver_payload("YOUR_API_KEY")
# payload includes data-s only when present on the page

Questions fréquemment posées

Ai-je toujours besoin de données pour résoudre reCAPTCHA ?

Non. Le paramètre data-s n'apparaît que sur un petit sous-ensemble d'implémentations de reCAPTCHA, principalement des propriétés appartenant à Google. Pour les sites Web tiers standard utilisant reCAPTCHA, vous n'avez besoin que du sitekey et du pageurl. Vérifiez toujours la présence de data-s sur le widget avant de décider de l'inclure ou non.

Que se passe-t-il si j'inclus des données alors qu'elles ne sont pas nécessaires ?

Certains solveurs peuvent ignorer le paramètre supplémentaire. D'autres peuvent renvoyer une erreur. Il est recommandé d'inclure uniquement data-s lorsqu'il existe réellement dans le widget reCAPTCHA de la page cible.

Puis-je mettre en cache des données sur plusieurs solutions ?

Non. La valeur data-s est spécifique à la session et liée au chargement d’une seule page. Chaque fois que vous chargez la page CAPTCHA, une nouvelle valeur data-s est générée. Vous devez extraire une nouvelle valeur avant chaque requête de résolution.

Pourquoi ma résolution CAPTCHA de recherche Google échoue-t-elle même avec la clé de site correcte ?

Si vous résolvez un CAPTCHA de « trafic inhabituel » de recherche Google, la cause d’échec la plus courante est un paramètre data-s manquant. Les CAPTCHA de recherche Google incluent toujours data-s, et la résolution échouera sans cela. Extrayez l'attribut data-s de l'élément <div> du widget reCAPTCHA.

Résumé

Le paramètre data-s est un jeton de liaison de session trouvé sur certaines implémentations de reCAPTCHA, principalement des propriétés appartenant à Google. Lorsqu'il est présent, vous devez l'extraire du HTML du widget reCAPTCHA et l'inclure dans votreCaptchaAIRequête API. Vérifiez toujours data-s avant de soumettre - incluez-le lorsqu'il est présent, omettez-le lorsqu'il est absent. Pour les CAPTCHA de recherche Google en particulier, data-s est toujours requis.