reCAPTCHA Data-S-Parameter erklärt

Der Parameter data-s ist ein sitzungsspezifisches Token, das in einigen reCAPTCHA-Implementierungen vorkommt, hauptsächlich auf Google-eigenen Websites wie der Google-Suche, YouTube und Google Play. Wenn es vorhanden ist, muss es in Ihrer Solver-API-Anfrage enthalten sein – das Weglassen führt zu Lösungsfehlern oder ungültigen Token. In diesem Handbuch wird erklärt, was data-s ist, wo es erscheint, wie man es extrahiert und wie man es an CaptchaAI übergibt.

Was ist der data-s-Parameter?

Der Parameter data-s ist ein vom Server generiertes Sitzungstoken, das in den HTML-Code des reCAPTCHA-Widgets eingebettet ist. Es bindet die CAPTCHA-Herausforderung an eine bestimmte Serversitzung und verhindert so die Wiederverwendung von Token über verschiedene Sitzungen hinweg.

Wo es erscheint

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

Das data-s-Attribut befindet sich neben dem Standard-data-sitekey im reCAPTCHA-Element <div>.

Hauptmerkmale

Wenn Daten vorhanden sind

Der Parameter data-s ist in den meisten reCAPTCHA-Implementierungen NICHT vorhanden. Es erscheint hauptsächlich auf:

Wenn Sie NICHT mit Google-eigenen Eigenschaften arbeiten, müssen Sie sich um data-s wahrscheinlich keine Sorgen machen. Wenn Ihr Solver ungültige Token für ein CAPTCHA der Google-Suche zurückgibt, ist ein fehlendes data-s die wahrscheinliche Ursache.

Wie data-s technisch funktioniert

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

Der Parameter data-s fungiert im Wesentlichen als Nonce – er bindet die CAPTCHA-Aufforderung an eine bestimmte serverseitige Sitzung. Der Solver muss diesen Wert beim Generieren des Tokens verwenden, damit das resultierende Token mit der erwarteten Sitzung übereinstimmt.

Extrahieren von Daten aus der Seite

Python-Extraktion

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
# }

Node.js-Extraktion

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

Selenextraktion (für dynamische Seiten)

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"}

Lösen mit Daten mithilfe von CaptchaAI

Wenn data-s vorhanden ist, fügen Sie es in Ihre CaptchaAI-API-Anfrage ein:

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

Node.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");
}

Häufige Datenfehler

Hilfsprogramm zur Datenextraktion

Ein wiederverwendbares Dienstprogramm, das sowohl Daten- als auch Nicht-Daten-reCAPTCHA-Seiten verarbeitet:

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

Häufig gestellte Fragen

Benötige ich für die reCAPTCHA-Lösung immer Daten?

Nein. Der Parameter data-s erscheint nur in einer kleinen Teilmenge der reCAPTCHA-Implementierungen, hauptsächlich bei Google-eigenen Eigenschaften. Für Standard-Websites von Drittanbietern, die reCAPTCHA verwenden, benötigen Sie nur sitekey und pageurl. Überprüfen Sie immer, ob data-s im Widget vorhanden ist, bevor Sie entscheiden, ob es hinzugefügt werden soll.

Was passiert, wenn ich Daten einbeziehe, obwohl diese nicht benötigt werden?

Einige Löser ignorieren den zusätzlichen Parameter möglicherweise. Andere geben möglicherweise einen Fehler zurück. Es empfiehlt sich, data-s nur dann einzuschließen, wenn es tatsächlich im reCAPTCHA-Widget der Zielseite vorhanden ist.

Kann ich Daten über mehrere Lösungen hinweg zwischenspeichern?

Nein. Der data-s-Wert ist sitzungsspezifisch und an den Ladevorgang einer einzelnen Seite gebunden. Jedes Mal, wenn Sie die CAPTCHA-Seite laden, wird ein neuer data-s-Wert generiert. Sie müssen vor jeder Lösungsanforderung einen neuen Wert extrahieren.

Warum schlägt die CAPTCHA-Lösung für die Google-Suche trotz korrektem Sitekey fehl?

Wenn Sie ein Google-Such-CAPTCHA „Ungewöhnlicher Datenverkehr“ lösen, ist die häufigste Fehlerursache ein fehlender data-s-Parameter. CAPTCHAs der Google-Suche enthalten immer data-s und die Lösung schlägt ohne dieses fehl. Extrahieren Sie das data-s-Attribut aus dem <div>-Element des reCAPTCHA-Widgets.

Zusammenfassung

Der Parameter data-s ist ein Sitzungsbindungstoken, das in ausgewählten reCAPTCHA-Implementierungen zu finden ist, hauptsächlich in Google-eigenen Eigenschaften. Wenn vorhanden, müssen Sie es aus dem HTML-Code des reCAPTCHA-Widgets extrahieren und in Ihr einfügenCaptchaAIAPI-Anfrage. Überprüfen Sie vor dem Absenden immer, ob data-s vorhanden ist – fügen Sie es ein, wenn es vorhanden ist, und lassen Sie es weg, wenn es nicht vorhanden ist. Insbesondere für CAPTCHAs der Google-Suche ist data-s immer erforderlich.

Verwandte Leitfäden

• reCAPTCHA v2 Callback lösen
• reCAPTCHA v2 und Turnstile: Gleiche Seite
• Recaptcha-Token-Lebenszyklus erklärt