Alguns sites implementam reCAPTCHA v2 e v3 na mesma página. O padrão típico é: a v3 é executada de forma invisível em segundo plano e, se a pontuação for muito baixa, a v2 aparece como um desafio alternativo visível. Essa implementação dupla cria confusão para a automação porque você precisa lidar com dois tipos diferentes de CAPTCHA com métodos de resolução diferentes. Este guia cobre detecção, estratégias de resolução e casos extremos comuns.
Por que os sites usam v2 e v3 juntas
User visits page
↓
reCAPTCHA v3 runs invisibly in background
↓
Score returned to server (e.g., 0.4)
↓
Score below threshold (e.g., < 0.7)?
├─ YES → Show reCAPTCHA v2 checkbox/image challenge
└─ NO → Allow action without visible CAPTCHA
Este padrão oferece o mais adequado dos dois mundos:
- A maioria dos usuários (pontuação v3 alta) não vê CAPTCHA → baixo atrito
- Usuários suspeitos (pontuação v3 baixa) veja o desafio v2 → substituto de segurança
- Operador de site controla o limite entre invisível e visível
Padrões de implementação dupla
Padrão 1: pré-avaliação v3 + substituto v2
O padrão mais comum. v3 é executado primeiro e v2 aparece somente se necessário.
<!-- Both scripts loaded -->
<script src="https://www.google.com/recaptcha/api.js?render=V3_SITE_KEY"></script>
<script src="https://www.google.com/recaptcha/api.js?render=explicit" async defer></script>
<form id="loginForm">
<!-- v2 widget (hidden initially) -->
<div id="recaptcha-v2-container" style="display:none;">
<div class="g-recaptcha" data-sitekey="V2_SITE_KEY"></div>
</div>
<button type="submit">Login</button>
</form>
<script>
// First attempt: v3 invisible
grecaptcha.ready(function() {
grecaptcha.execute('V3_SITE_KEY', {action: 'login'}).then(function(v3Token) {
fetch('/api/verify-v3', {
method: 'POST',
body: JSON.stringify({token: v3Token})
})
.then(r => r.json())
.then(data => {
if (data.score < 0.7) {
// Score too low → show v2 fallback
document.getElementById('recaptcha-v2-container').style.display = 'block';
grecaptcha.render('recaptcha-v2-container', {sitekey: 'V2_SITE_KEY'});
} else {
// Score OK → submit form directly
document.getElementById('loginForm').submit();
}
});
});
});
</script>
Padrão 2: chaves de site diferentes para ações diferentes
Alguns sites usam v3 para monitoramento passivo e v2 para ações específicas de alto risco:
Homepage → v3 only (passive score)
Login page → v3 assessment, v2 fallback
Checkout → v2 always (high security)
Contact form → v3 only
Padrão 3: script único, modo duplo
O Google suporta o carregamento de um único script reCAPTCHA que lida com v2 e v3:
<script src="https://www.google.com/recaptcha/api.js?render=V3_SITE_KEY"></script>
<script>
// v3 execute
grecaptcha.execute('V3_SITE_KEY', {action: 'login'});
// v2 render (uses a different site key)
grecaptcha.render('v2-container', {sitekey: 'V2_SITE_KEY'});
</script>
Detectando implementação dupla
Detecção de Python
import requests
import re
def detect_dual_recaptcha(url):
"""Detect if a page uses both reCAPTCHA v2 and v3."""
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",
}
html = requests.get(url, headers=headers, timeout=15).text
result = {
"has_v3": False,
"has_v2": False,
"v3_site_key": None,
"v2_site_key": None,
"dual": False,
"pattern": None,
}
# Detect v3 (render parameter or enterprise.execute)
v3_match = re.search(r"api\.js\?render=([A-Za-z0-9_-]+)", html)
if v3_match and v3_match.group(1) != "explicit":
result["has_v3"] = True
result["v3_site_key"] = v3_match.group(1)
# Detect v3 in execute calls
v3_execute = re.search(
r"grecaptcha\.(?:enterprise\.)?execute\s*\(\s*['\"]([^'\"]+)['\"]",
html,
)
if v3_execute:
result["has_v3"] = True
if not result["v3_site_key"]:
result["v3_site_key"] = v3_execute.group(1)
# Detect v2 (g-recaptcha class or explicit render)
v2_match = re.search(r'data-sitekey="([^"]+)"', html)
if v2_match:
key = v2_match.group(1)
if key != result.get("v3_site_key"):
result["has_v2"] = True
result["v2_site_key"] = key
# Check for explicit v2 render
v2_render = re.search(
r"grecaptcha\.render\s*\([^,]+,\s*\{[^}]*sitekey:\s*['\"]([^'\"]+)",
html,
)
if v2_render:
result["has_v2"] = True
if not result["v2_site_key"]:
result["v2_site_key"] = v2_render.group(1)
result["dual"] = result["has_v3"] and result["has_v2"]
if result["dual"]:
# Determine pattern
if "display:none" in html or "display: none" in html:
result["pattern"] = "v3_pre_assessment_v2_fallback"
else:
result["pattern"] = "v2_v3_simultaneous"
return result
detection = detect_dual_recaptcha("https://staging.example.com/qa-login")
print(detection)
Detecção de Node.js
const axios = require("axios");
async function detectDualRecaptcha(url) {
const { data: html } = await axios.get(url, { timeout: 15000 });
const result = {
hasV3: false,
hasV2: false,
v3SiteKey: null,
v2SiteKey: null,
dual: false,
};
// v3 detection
const v3Match = html.match(/api\.js\?render=([A-Za-z0-9_-]+)/);
if (v3Match && v3Match[1] !== "explicit") {
result.hasV3 = true;
result.v3SiteKey = v3Match[1];
}
// v2 detection
const v2Match = html.match(/data-sitekey="([^"]+)"/);
if (v2Match && v2Match[1] !== result.v3SiteKey) {
result.hasV2 = true;
result.v2SiteKey = v2Match[1];
}
result.dual = result.hasV3 && result.hasV2;
return result;
}
detectDualRecaptcha("https://staging.example.com/qa-login").then(console.log);
Resolvendo estratégias para reCAPTCHA duplo
Estratégia 1: Resolva primeiro a v3 e depois a v2 se necessário
A estratégia ideal reflete o fluxo do próprio site:
import requests
import time
API_KEY = "YOUR_API_KEY"
def solve_v3(site_key, page_url, action="login"):
"""Solve reCAPTCHA v3 and return token."""
submit = requests.post("https://ocr.captchaai.com/in.php", data={
"key": API_KEY,
"method": "userrecaptcha",
"googlekey": site_key,
"pageurl": page_url,
"version": "v3",
"action": action,
"score_qa": "0.9",
"json": 1,
}).json()
task_id = submit["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:
return result["request"]
raise TimeoutError("v3 solve timeout")
def solve_v2(site_key, page_url):
"""Solve reCAPTCHA v2 and return token."""
submit = requests.post("https://ocr.captchaai.com/in.php", data={
"key": API_KEY,
"method": "userrecaptcha",
"googlekey": site_key,
"pageurl": page_url,
"json": 1,
}).json()
task_id = submit["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:
return result["request"]
raise TimeoutError("v2 solve timeout")
def solve_dual_recaptcha(v3_key, v2_key, page_url, action="login"):
"""Handle dual reCAPTCHA: try v3, fall back to v2."""
# Step 1: Try v3
v3_token = solve_v3(v3_key, page_url, action)
# Step 2: Submit v3 token to target
response = requests.post(f"{page_url}/verify", data={
"g-recaptcha-response": v3_token,
})
# Step 3: Check if v2 fallback is needed
if "recaptcha" in response.text.lower() and v2_key:
print("v3 score too low — v2 fallback triggered")
v2_token = solve_v2(v2_key, page_url)
return {"version": "v2", "token": v2_token}
return {"version": "v3", "token": v3_token}
result = solve_dual_recaptcha(
v3_key="6LcExample_v3_key",
v2_key="6LcExample_v2_key",
page_url="https://staging.example.com/qa-login",
)
print(f"Solved with {result['version']}")
Estratégia 2: pule a v3, resolva a v2 diretamente
Se você sabe que o site sempre mostra v2 para tráfego automatizado (a pontuação da v3 será baixa), pule a v3 e resolva a v2 imediatamente:
# If you consistently fail v3 assessment, just solve v2 directly
token = solve_v2(v2_site_key, page_url)
submit_form(token)
Isso economiza tempo e custo de uma solução v3 que pode não ultrapassar o limite.
Estratégia 3: Tratamento baseado em navegador
Para implementações complexas, use um navegador para lidar com o fluxo de fallback:
from selenium import webdriver
from selenium.webdriver.common.by import By
import time
driver = webdriver.Chrome()
driver.get("https://staging.example.com/qa-login")
time.sleep(3)
# Check if v2 widget is visible
v2_visible = driver.execute_script("""
const container = document.querySelector('.g-recaptcha');
if (!container) return false;
const style = window.getComputedStyle(container.parentElement);
return style.display !== 'none' && style.visibility !== 'hidden';
""")
if v2_visible:
# v2 is showing — solve v2
sitekey = driver.find_element(
By.CSS_SELECTOR, "[data-sitekey]"
).get_attribute("data-sitekey")
token = solve_v2(sitekey, driver.current_url)
driver.execute_script(
f'document.getElementById("g-recaptcha-response").value = "{token}";'
)
else:
# v3 only — solve v3
# Extract v3 key from page source
v3_key = driver.execute_script(
"return document.querySelector('script[src*=\"render=\"]')"
".src.match(/render=([^&]+)/)[1];"
)
token = solve_v3(v3_key, driver.current_url)
# Inject v3 token into the form
driver.execute_script(f"""
const input = document.createElement('input');
input.type = 'hidden';
input.name = 'g-recaptcha-response';
input.value = '{token}';
document.querySelector('form').appendChild(input);
""")
driver.find_element(By.CSS_SELECTOR, "form").submit()
Casos extremos
Duas chaves de site diferentes na mesma página
Sites que usam reCAPTCHA duplo terão DUAS chaves de site diferentes – uma para v3 e outra para v2. A chave v3 aparece na URL do script ?render=KEY e em grecaptcha.execute('KEY', ...). A chave v2 aparece em data-sitekey="KEY" na div do widget. Usar a chave errada para a versão errada produzirá tokens inválidos.
reCAPTCHA Enterprise com substituto v2
Algumas implementações Enterprise usam v3 Enterprise para pontuação e v2 para desafios:
# Detect and handle Enterprise + v2 combo
if "recaptcha/enterprise.js" in html:
# Use enterprise parameter for v3
v3_params = {"enterprise": 1, "version": "v3"}
else:
v3_params = {"version": "v3"}
Vários formulários em uma página
Se uma página tiver vários formulários (login + registro), cada um poderá ter sua própria instância do reCAPTCHA. Extraia a chave do site do formulário específico que você está direcionando:
# Target the login form specifically
login_form = soup.find("form", id="login-form")
widget = login_form.find(attrs={"data-sitekey": True})
sitekey = widget["data-sitekey"]
Perguntas frequentes
Preciso resolver v2 e v3 na mesma página?
Não. Normalmente, você resolve a v3 primeiro (ela é executada automaticamente). Se a pontuação da v3 ultrapassar o limite do site, nenhum desafio da v2 será exibido e pronto. Você só precisa resolver a v2 se a pontuação da v3 acionar o substituto.
Posso usar uma única chamada de API CaptchaAI para reCAPTCHA duplo?
Não. v2 e v3 são tipos separados de CAPTCHA com chaves de site e métodos de resolução diferentes. Cada um requer sua própria chamada de API para CaptchaAI. No entanto, você só precisará fazer uma chamada se a v3 passar sem acionar a v2.
Como posso saber se o fallback v2 foi acionado?
Verifique a resposta do servidor após enviar o token v3. Se a resposta contiver HTML de widget v2 ou acionar um desafio v2 (redirecionamento ou resposta AJAX com HTML CAPTCHA), o substituto foi acionado. Em um navegador, verifique se o contêiner v2 fica visível após o envio da v3.
Qual chave de site devo usar para cada versão?
A chave do site v3 está na URL do script: api.js?render=V3_KEY. A chave do site v2 está no widget HTML: data-sitekey="V2_KEY". São sempre chaves diferentes.
Resumo
As implementações duplas de reCAPTCHA usam v3 para pré-avaliação invisível e v2 como um substituto visível quando a pontuação da v3 é muito baixa. Detecte ambas as versões verificando o parâmetro de renderização (v3) e o widget data-sitekey (v2). A estratégia de automação ideal é: resolver primeiro a v3 comCaptchaAI, envie o token e resolva v2 somente se o substituto for acionado. Cada versão requer uma chamada de API separada com sua própria chave de site.
Artigos relacionados
- Aplicativo Recaptcha de página única dinâmico
- Como resolver o retorno de chamada do Recaptcha V2 usando API
- Torniquete Recaptcha V2 no mesmo local
