Lidando com reCAPTCHA v2 e v3 na mesma página

Alguns sites travam a automação sem motivo aparente: o g-recaptcha-response chega correto, mas o formulário rejeita o envio ou surge um novo desafio. A causa costuma ser um site que combina reCAPTCHA v2 e v3 — a v3 roda em segundo plano e, se a pontuação fica baixa, a v2 aparece como desafio visível. Automatizar isso exige tratar dois tipos de CAPTCHA, com sitekeys e resolução diferentes.

Resposta direta: resolva a v3 primeiro. Só chame a v2 se a resposta do servidor indicar que o fallback foi acionado.

Por que sites combinam reCAPTCHA v2 e v3

O objetivo é reduzir atrito sem abrir mão de segurança. A v3 avalia o comportamento do visitante e devolve uma pontuação entre 0 e 1; o backend decide se ela basta para liberar a ação ou se é preciso uma verificação extra.

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

O padrão entrega o melhor dos dois:

Por isso a detecção precisa vir antes da resolução: o mesmo fluxo termina de duas formas conforme o comportamento da v3.

Padrões comuns de implementação dupla

Padrão 1: pontuação da v3 primeiro, fallback da v2 quando necessário

O widget v2 fica oculto (display:none) até a v3 retornar pontuação abaixo do limite.

<!-- 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: sitekeys diferentes para cada ação do site

Alguns sites reservam a v3 para monitoramento passivo e usam a v2 só nas ações de maior risco:

Homepage → v3 only (passive score)
Login page → v3 assessment, v2 fallback
Checkout → v2 always (high security)
Contact form → v3 only

Padrão 3: um único script cobrindo os dois modos

O Google permite carregar um único script que atende v2 e v3 ao mesmo tempo, cada versão com sua sitekey:

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

Como detectar a implementação dupla antes de automatizar

Rode a checagem em ambiente próprio, como um clone de staging do fluxo alvo, nunca direto em produção; trate a resposta capturada como dado de teste, alinhado à LGPD quando o formulário original coleta dados reais. Confirme a implementação dupla em três passos:

1. Abra o HTML da página sem executar JavaScript.
2. Procure render= na URL do script — é a sitekey da v3.
3. Procure data-sitekey no widget — se for diferente da v3, há fallback v2.

Detecção em Python

A função sinaliza dual: true quando as duas chaves aparecem e são diferentes:

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 em Node.js

A mesma lógica em Node.js, útil quando o pipeline já roda em JavaScript:

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

Estratégias para resolver v2 e v3 juntos

Estratégia 1: resolva a v3 primeiro e só chame a v2 se o fallback disparar

Espelha o fluxo do site: resolve a v3, envia o token e só chama a v2 se o desafio for acionado.

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 quando o padrão do site já é conhecido

Se o tráfego automatizado sempre recebe pontuação baixa nesse site, resolver a v3 antes só soma tempo e custo. Vá direto para a v2:

# If you consistently fail v3 assessment, just solve v2 directly
token = solve_v2(v2_site_key, page_url)
submit_form(token)

Estratégia 3: deixe o navegador decidir qual versão está ativa

Para fallback mais complexo, use um navegador real e cheque qual widget está visível — mais confiável do que prever pelo HTML estático:

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 que travam a automação

Toda página com reCAPTCHA duplo tem DUAS sitekeys: a da v3 na URL do script (?render=CHAVE) e em grecaptcha.execute('CHAVE', ...); a da v2 em data-sitekey="CHAVE". A chave errada não gera erro explícito — só um token inválido, mais difícil de depurar. Dois outros casos merecem atenção:

reCAPTCHA Enterprise com fallback para v2

Algumas implementações Enterprise usam a v3 Enterprise para a pontuação e a v2 comum para o desafio. Verifique recaptcha/enterprise.js para decidir o parâmetro:

# 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 na mesma página

Se a página tem mais de um formulário — login e cadastro — cada um pode ter sua própria instância do widget. Extraia a sitekey do formulário alvo, não da página inteira:

# 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

Como sei se um site combina reCAPTCHA v2 e v3 antes de escrever o script?

Veja os três passos de detecção acima: se render= e data-sitekey aparecerem com chaves diferentes, há implementação dupla.

Preciso pagar por duas chamadas de API sempre que o site tem v2 e v3?

Não. Os planos da CaptchaAI cobram por thread simultânea, não por CAPTCHA — o token da v3 e, se necessário, o da v2 usam a mesma thread em sequência.

Qual sitekey uso para cada versão?

A da v3 está na URL do script (render=CHAVE_V3); a da v2, no widget (data-sitekey="CHAVE_V2"). Usar a errada é a causa mais comum de token inválido.

Resumo

Implementações duplas usam a v3 para pré-avaliação invisível e a v2 como desafio visível quando a pontuação fica baixa. Detecte as duas versões checando render= (v3) e data-sitekey (v2) antes de automatizar. A estratégia mais estável é resolver a v3 com a CaptchaAI, enviar o token e só resolver a v2 se o fallback for acionado.

Artigos relacionados

• reCAPTCHA em aplicações de página única (SPA)
• Como resolver o callback do reCAPTCHA v2 pela API
• reCAPTCHA v2 e Cloudflare Turnstile no mesmo site