Behandlung von reCAPTCHA v2 und v3 auf derselben Seite

Einige Websites implementieren sowohl reCAPTCHA v2 als auch v3 auf derselben Seite. Das typische Muster ist: v3 läuft unsichtbar im Hintergrund, und wenn die Punktzahl zu niedrig ist, erscheint v2 als sichtbare Fallback-Herausforderung. Diese duale Implementierung führt zu Verwirrung bei der Automatisierung, da Sie zwei verschiedene CAPTCHA-Typen mit unterschiedlichen Lösungsmethoden verarbeiten müssen. Dieser Leitfaden behandelt Erkennung, Lösungsstrategien und häufige Randfälle.

Warum Websites sowohl v2 als auch v3 zusammen verwenden

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

Dieses Muster bietet das Beste aus beiden Welten:

• Die meisten Benutzer (hoher v3-Score) sehen kein CAPTCHA → mit geringer Reibung
• Verdächtige Benutzer (niedriger v3-Score) siehe v2-Herausforderung →-Sicherheits-Fallback
• Website-Betreiber kontrolliert die Grenze zwischen unsichtbar und sichtbar

Duale Implementierungsmuster

Muster 1: v3-Vorbewertung + v2-Fallback

Das häufigste Muster. v3 wird zuerst ausgeführt und v2 wird nur bei Bedarf angezeigt.

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

Muster 2: Unterschiedliche Site-Schlüssel für unterschiedliche Aktionen

Einige Websites verwenden Version 3 für die passive Überwachung und Version 2 für bestimmte Aktionen mit hohem Risiko:

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

Muster 3: Einzelskript, Dualmodus

Google unterstützt das Laden eines einzelnen reCAPTCHA-Skripts, das sowohl v2 als auch v3 verarbeitet:

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

Erkennen einer dualen Implementierung

Python-Erkennung

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://example.com/login")
print(detection)

Node.js-Erkennung

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://example.com/login").then(console.log);

Lösungsstrategien für duales reCAPTCHA

Strategie 1: Lösen Sie zuerst Version 3 und dann bei Bedarf Version 2

Die optimale Strategie spiegelt den eigenen Ablauf der Site wider:

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,
        "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://example.com/login",
)
print(f"Solved with {result['version']}")

Strategie 2: V3 überspringen, V2 direkt lösen

Wenn Sie wissen, dass auf der Website immer Version 2 für automatisierten Datenverkehr angezeigt wird (der Wert für Version 3 ist niedrig), überspringen Sie Version 3 und lösen Sie Version 2 sofort:

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

Dies spart Zeit und Kosten einer v3-Lösung, die den Schwellenwert möglicherweise nicht überschreitet.

Strategie 3: Browserbasierte Handhabung

Verwenden Sie bei komplexen Implementierungen einen Browser, um den Fallback-Ablauf zu verwalten:

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

driver = webdriver.Chrome()
driver.get("https://example.com/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()

Randfälle

Zwei verschiedene Site-Schlüssel auf derselben Seite

Websites, die Dual-reCAPTCHA verwenden, verfügen über ZWEI verschiedene Website-Schlüssel – einen für Version 3 und einen für Version 2. Der v3-Schlüssel erscheint in der Skript-URL ?render=KEY und in grecaptcha.execute('KEY', ...). Der v2-Schlüssel erscheint in data-sitekey="KEY" im Widget-Div. Die Verwendung des falschen Schlüssels für die falsche Version führt zu ungültigen Token.

reCAPTCHA Enterprise mit v2-Fallback

Einige Enterprise-Implementierungen verwenden v3 Enterprise für die Bewertung und v2 für Herausforderungen:

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

Mehrere Formulare auf einer Seite

Wenn eine Seite über mehrere Formulare verfügt (Anmeldung + Registrierung), kann jedes über eine eigene reCAPTCHA-Instanz verfügen. Extrahieren Sie den Site-Schlüssel aus dem spezifischen Formular, auf das Sie abzielen:

# 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"]

Häufig gestellte Fragen

Muss ich sowohl Version 2 als auch Version 3 auf derselben Seite lösen?

Nein. Normalerweise lösen Sie zuerst Version 3 (es wird automatisch ausgeführt). Wenn der v3-Score den Schwellenwert der Site überschreitet, wird keine v2-Herausforderung angezeigt und Sie sind fertig. Sie müssen v2 nur lösen, wenn der v3-Score den Fallback auslöst.

Kann ich einen einzelnen CaptchaAI-API-Aufruf für duales reCAPTCHA verwenden?

Nein. v2 und v3 sind separate CAPTCHA-Typen mit unterschiedlichen Site-Schlüsseln und Lösungsmethoden. Jeder erfordert seinen eigenen API-Aufruf an CaptchaAI. Sie müssen jedoch nur einen Anruf tätigen, wenn v3 erfolgreich ist, ohne v2 auszulösen.

Woher weiß ich, ob ein v2-Fallback ausgelöst wurde?

Überprüfen Sie die Serverantwort nach der Übermittlung des v3-Tokens. Wenn die Antwort v2-Widget-HTML enthält oder eine v2-Challenge auslöst (Umleitung oder AJAX-Antwort mit CAPTCHA-HTML), wurde der Fallback ausgelöst. Überprüfen Sie in einem Browser, ob der v2-Container nach der v3-Übermittlung sichtbar wird.

Welchen Site-Schlüssel verwende ich für jede Version?

Der v3-Site-Schlüssel befindet sich in der Skript-URL: api.js?render=V3_KEY. Der v2-Site-Schlüssel befindet sich im Widget-HTML: data-sitekey="V2_KEY". Es sind immer unterschiedliche Schlüssel.

Zusammenfassung

Duale reCAPTCHA-Implementierungen verwenden v3 für eine unsichtbare Vorabbewertung und v2 als sichtbaren Fallback, wenn der v3-Score zu niedrig ist. Erkennen Sie beide Versionen, indem Sie nach dem Renderparameter (v3) und dem Widget-Daten-Sitekey (v2) suchen. Die optimale Automatisierungsstrategie lautet: Zuerst v3 lösen mit CaptchaAI, übermitteln Sie das Token und lösen Sie v2 nur, wenn der Fallback ausgelöst wird. Jede Version erfordert einen separaten API-Aufruf mit einem eigenen Site-Schlüssel.

Verwandte Artikel

• Recaptcha Single Page Application Dynamic
• So lösen Sie Recaptcha V2-Rückrufe mithilfe der API
• reCAPTCHA v2 Turnstile: gleiche Seite bewältigen