O parâmetro data-s é um token específico de sessão que aparece em algumas implementações de reCAPTCHA, principalmente em propriedades de propriedade do Google, como Pesquisa Google, YouTube e Google Play. Quando presente, deve ser incluído na solicitação da API do solucionador - omiti-lo causa falhas de resolução ou tokens inválidos. Este guia explica o que é data-s, onde aparece, como extraí-lo e como passá-lo para CaptchaAI.
Qual é o parâmetro data-s?
O parâmetro data-s é um token de sessão gerado pelo servidor incorporado no HTML do widget reCAPTCHA. Ele vincula o desafio CAPTCHA a uma sessão específica do servidor, evitando a reutilização de tokens em sessões diferentes.
Onde aparece
<!-- reCAPTCHA widget with data-s parameter -->
<div class="g-recaptcha"
data-sitekey="6LcR_RsTAAAAAN_r0GEkGBfq3L7KmU5JbPHJtwNp"
data-s="AB2grfE8_kyMp3XYRuJo5c..."
data-callback="onCaptchaSolved">
</div>
O atributo data-s fica ao lado do data-sitekey padrão no elemento reCAPTCHA <div>.
Características principais
| Propriedade | Valor |
|---|---|
| Formato | String codificada em Base64, 200-500 caracteres |
| Vitalício | Uso único, vinculado ao carregamento atual da página |
| Escopo | Específico da sessão, não pode ser reutilizado em carregamentos de página |
| Obrigatório | Sim, quando presente – a solução falha sem ele |
| Atualizações | Novo valor em cada página load/refresh |
Quando os dados estão presentes
O parâmetro data-s NÃO está presente na maioria das implementações de reCAPTCHA. Aparece principalmente em:
| Local | Presença | Notas |
|---|---|---|
| Pesquisa Google (desculpe, tráfego /unusual) | Sempre | Obrigatório para resolução de CAPTCHA da Pesquisa Google |
| YouTube | Às vezes | Aparece em determinados fluxos de verificação |
| Google Play | Às vezes | Verificação da listagem de aplicativos |
| Formulários Google | Raramente | Implementações limitadas |
| Sites de terceiros que usam reCAPTCHA | Quase nunca | Integrações padrão não usam dados |
Se você NÃO trabalha com propriedades de propriedade do Google, provavelmente não precisa se preocupar com data-s. Se o seu solucionador retornar tokens inválidos para um CAPTCHA da Pesquisa Google, um data-s ausente será a causa provável.
Como os dados funcionam tecnicamente
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
O parâmetro data-s atua essencialmente como um nonce - vincula o desafio CAPTCHA a uma sessão específica do lado do servidor. O solucionador deve usar esse valor ao gerar o token para que o token resultante corresponda à sessão esperada.
Extraindo dados da página
Extração de 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
# }
Extração de 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);
Extração de selênio (para páginas dinâmicas)
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"}
Resolvendo com dados usando CaptchaAI
Quando data-s estiver presente, inclua-o em sua solicitação de API CaptchaAI:
Pitão
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");
}
Erros comuns de dados
| Erro | Sintoma | Correção |
|---|---|---|
| Omitindo dados quando presentes | A validação do token falha silenciosamente | Sempre verifique o atributo data-s antes de enviar |
| Incluindo dados quando não estão presentes | Resolver erro ou solicitação rejeitada | Incluir data-s apenas se o atributo existir no widget |
| Reutilizando dados em carregamentos de página | Token inválido | Extraia novos dados para cada carregamento de página |
| Dados de codificação de URL incorretamente | Parâmetro malformado | Passe o valor base64 bruto sem codificação adicional |
| Usando dados obsoletos (página carregada minutos atrás) | Incompatibilidade de token | Extraia os dados imediatamente antes de enviar ao solucionador |
Auxiliar de extração de dados
Um utilitário reutilizável que lida com páginas reCAPTCHA com e sem dados:
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
Perguntas frequentes
Eu sempre preciso de dados para resolver o reCAPTCHA?
Não. O parâmetro data-s aparece apenas em um pequeno subconjunto de implementações de reCAPTCHA, principalmente propriedades de propriedade do Google. Para sites padrão de terceiros que usam reCAPTCHA, você só precisa de sitekey e pageurl. Sempre verifique a presença de data-s no widget antes de decidir se deseja incluí-lo.
O que acontece se eu incluir dados quando não forem necessários?
Alguns solucionadores podem ignorar o parâmetro extra. Outros podem retornar um erro. É uma prática recomendada incluir data-s apenas quando ele realmente existir no widget reCAPTCHA da página de destino.
Posso armazenar dados em cache em várias soluções?
Não. O valor data-s é específico da sessão e está vinculado a um único carregamento de página. Cada vez que você carrega a página CAPTCHA, um novo valor data-s é gerado. Você deve extrair um novo valor antes de cada solicitação de resolução.
Por que minha solução CAPTCHA da Pesquisa Google falha mesmo com a chave do site correta?
Se você estiver resolvendo um CAPTCHA de "tráfego incomum" da Pesquisa Google, a causa de falha mais comum é a falta do parâmetro data-s. Os CAPTCHAs da Pesquisa Google sempre incluem data-s e a solução falhará sem ele. Extraia o atributo data-s do elemento <div> do widget reCAPTCHA.
Resumo
O parâmetro data-s é um token de vinculação de sessão encontrado em implementações selecionadas de reCAPTCHA, principalmente em propriedades de propriedade do Google. Quando presente, você deve extraí-lo do HTML do widget reCAPTCHA e incluí-lo em seuCaptchaAISolicitação de API. Sempre verifique data-s antes de enviar. Inclua-o quando estiver presente, omita-o quando estiver ausente. Especificamente para CAPTCHAs da Pesquisa Google, data-s é sempre obrigatório.
Artigos relacionados
- Como resolver o retorno de chamada do Recaptcha V2 usando API
- Torniquete Recaptcha V2 no mesmo local
- Ciclo de vida do token Recaptcha explicado
