Standard vs. Enterprise reCAPTCHA v3 Lösungsleitfaden

Ihr Scraper lief gestern noch stabil, heute kommen plötzlich niedrige Scores und abgelehnte Tokens zurück – ohne dass sich am Login-Formular sichtbar etwas geändert hätte. Eine der häufigsten Ursachen: Die Seite ist still von reCAPTCHA v3 Standard auf Enterprise umgestiegen. Für Ihre CaptchaAI-Anfrage ändert dieser Wechsel genau einen Parameter (enterprise=1) – die eigentliche Aufgabe ist, ihn überhaupt zu bemerken, denn beide Varianten laufen unsichtbar und liefern nur einen Risiko-Score zwischen 0,0 und 1,0.

Was Enterprise anders macht als Standard v3

Aus Betriebssicht sind die beiden Varianten fast deckungsgleich: unsichtbar, score-basiert, mit Pflicht-Aktionsparameter. Die Unterschiede liegen in den Zusatzsignalen, die Google auf der Enterprise-Ebene verarbeitet, sowie im Verifizierungsendpunkt auf der Backend-Seite der Website – nicht in Ihrem Lösungsweg.

Welche Version läuft auf der Seite? So erkennen Sie es

Weil kein sichtbares Widget existiert, hilft nur ein Blick ins JavaScript. Die verlässlichste Signatur ist der Skriptname: enterprise.js steht für Enterprise, api.js?render= für Standard. Bauen Sie diese Prüfung in jeden Durchlauf ein, statt die Version fest zu verdrahten – so fällt ein späterer Umstieg sofort auf.

Erkennung in Python:

import requests
import re

def detect_v3_type(url):
    resp = requests.get(url)
    html = resp.text

    # Check for enterprise.js
    if "enterprise.js" in html:
        version = "enterprise_v3"
        execute_fn = "grecaptcha.enterprise.execute"
    elif "recaptcha/api.js" in html and "render=" in html:
        version = "standard_v3"
        execute_fn = "grecaptcha.execute"
    else:
        return None

    # Extract sitekey from render parameter
    key_match = re.search(r'render[=:]\s*["\']?([A-Za-z0-9_-]{40})', html)
    sitekey = key_match.group(1) if key_match else None

    # Extract action parameter
    action_match = re.search(r'action["\']?\s*[:=]\s*["\'](\w+)', html)
    action = action_match.group(1) if action_match else "unknown"

    return {
        "version": version,
        "sitekey": sitekey,
        "action": action,
        "execute_fn": execute_fn
    }

info = detect_v3_type("https://example.com/login")
print(info)

Erkennung in Node.js:

const axios = require("axios");

async function detectV3Type(url) {
  const { data: html } = await axios.get(url);

  let version, executeFn;
  if (html.includes("enterprise.js")) {
    version = "enterprise_v3";
    executeFn = "grecaptcha.enterprise.execute";
  } else if (html.includes("recaptcha/api.js") && html.includes("render=")) {
    version = "standard_v3";
    executeFn = "grecaptcha.execute";
  } else {
    return null;
  }

  const keyMatch = html.match(/render[=:]\s*['"]?([A-Za-z0-9_-]{40})/);
  const actionMatch = html.match(/action['"]?\s*[:=]\s*['"](\w+)/);

  return {
    version,
    sitekey: keyMatch?.[1] || null,
    action: actionMatch?.[1] || "unknown",
    executeFn,
  };
}

Schnelltest in der Browser-Konsole:

// Paste in DevTools console
if (document.querySelector('script[src*="enterprise.js"]')) {
  console.log("Enterprise v3");
  console.log("Execute:", typeof grecaptcha?.enterprise?.execute);
} else if (document.querySelector('script[src*="api.js"][src*="render="]')) {
  console.log("Standard v3");
  console.log("Execute:", typeof grecaptcha?.execute);
}

reCAPTCHA v3 mit CaptchaAI lösen

Der Ablauf ist bei beiden Varianten gleich: Sie übermitteln sitekey, pageurl und die action an in.php, fragen dann das Ergebnis über res.php ab. Der einzige Zusatz für Enterprise ist enterprise=1.

Standard v3

import requests
import time

# Submit
resp = requests.get("https://ocr.captchaai.com/in.php", params={
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "version": "v3",
    "googlekey": sitekey,
    "action": "login",
    "pageurl": page_url
})
task_id = resp.text.split("|")[1]

# Poll
for _ in range(60):
    time.sleep(5)
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": "YOUR_API_KEY", "action": "get", "id": task_id
    })
    if result.text.startswith("OK|"):
        token = result.text.split("|")[1]
        break

Enterprise v3

import requests
import time

# Submit — add enterprise=1
resp = requests.get("https://ocr.captchaai.com/in.php", params={
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "version": "v3",
    "enterprise": 1,  # Required for Enterprise
    "googlekey": sitekey,
    "action": "login",
    "pageurl": page_url
})
task_id = resp.text.split("|")[1]

# Polling is identical to standard
for _ in range(60):
    time.sleep(5)
    result = requests.get("https://ocr.captchaai.com/res.php", params={
        "key": "YOUR_API_KEY", "action": "get", "id": task_id
    })
    if result.text.startswith("OK|"):
        token = result.text.split("|")[1]
        break

Universeller Löser mit automatischer Erkennung

Für Produktions-Pipelines lohnt sich ein Löser, der die Variante selbst bestimmt und enterprise=1 nur dann setzt, wenn enterprise.js vorhanden ist. So bleibt derselbe Code stabil, auch wenn eine Seite ohne Vorwarnung migriert.

import requests
import time
import re

class RecaptchaV3Solver:
    def __init__(self, api_key):
        self.api_key = api_key

    def detect_and_solve(self, page_url, action=None):
        """Auto-detect standard vs enterprise and solve."""
        html = requests.get(page_url).text

        is_enterprise = "enterprise.js" in html
        key_match = re.search(r'render[=:]\s*["\']?([A-Za-z0-9_-]{40})', html)
        if not key_match:
            raise Exception("No v3 sitekey found")
        sitekey = key_match.group(1)

        if not action:
            action_match = re.search(r'action["\']?\s*[:=]\s*["\'](\w+)', html)
            action = action_match.group(1) if action_match else "verify"

        params = {
            "key": self.api_key,
            "method": "userrecaptcha",
            "version": "v3",
            "googlekey": sitekey,
            "action": action,
            "pageurl": page_url
        }
        if is_enterprise:
            params["enterprise"] = 1

        resp = requests.get("https://ocr.captchaai.com/in.php", params=params)
        if not resp.text.startswith("OK|"):
            raise Exception(f"Submit failed: {resp.text}")

        task_id = resp.text.split("|")[1]
        for _ in range(60):
            time.sleep(5)
            result = requests.get("https://ocr.captchaai.com/res.php", params={
                "key": self.api_key, "action": "get", "id": task_id
            })
            if result.text.startswith("OK|"):
                return result.text.split("|")[1]
            if result.text != "CAPCHA_NOT_READY":
                raise Exception(f"Solve failed: {result.text}")

        raise Exception("Timed out")

solver = RecaptchaV3Solver("YOUR_API_KEY")
token = solver.detect_and_solve("https://example.com/login", action="login")
print(f"Token: {token[:40]}...")

Den richtigen action-Parameter finden

Der Parameter action ist bei v3 entscheidend – für Standard wie für Enterprise. Senden Sie die falsche Aktion, fällt der Score niedrig aus und der Token wird unter Umständen abgelehnt. Ein Preismonitoring-Job, der stündlich einen Login-geschützten Bereich prüft, sollte die tatsächlich verwendete Aktion daher direkt aus dem Seiten-JavaScript ziehen, statt sie zu raten.

import re

def find_v3_actions(html):
    """Extract all action parameters from page JavaScript."""
    # Look for grecaptcha.execute(key, {action: '...'})
    pattern = r"(?:grecaptcha\.(?:enterprise\.)?execute|action)\s*[(:]\s*['\"](\w+)"
    actions = re.findall(pattern, html)
    return list(set(actions))

# Common actions: "login", "submit", "register", "checkout", "homepage"

Das gelöste Token einsetzen

Sobald der Token vorliegt, tragen Sie ihn in das Feld g-recaptcha-response ein – identisch für beide Varianten, ob per Selenium oder rein per HTTP:

# For browser-based workflows (Selenium)
driver.execute_script(
    f'document.getElementById("g-recaptcha-response").value = "{token}";'
)

# For pure HTTP workflows
requests.post(page_url, data={
    "g-recaptcha-response": token,
    "username": "user",
    "password": "pass"
})

// Puppeteer
await page.evaluate((tok) => {
  document.getElementById("g-recaptcha-response").value = tok;
}, token);

// Pure HTTP (axios)
await axios.post(pageUrl, new URLSearchParams({
  "g-recaptcha-response": token,
  username: "user",
  password: "pass",
}));

Typische Fehler bei der Integration

FAQ

Muss ich meinen Integrationscode ändern, wenn eine Seite auf Enterprise v3 wechselt?

Praktisch nur eine Zeile: Sobald enterprise.js erkannt wird, ergänzen Sie enterprise=1 in den Anfrageparametern. Submit- und Polling-Ablauf, sitekey-Extraktion und Token-Handling bleiben unverändert. Mit dem universellen Löser oben passiert diese Anpassung automatisch.

Wie prüfe ich programmatisch, ob eine Seite Enterprise v3 verwendet?

Durchsuchen Sie den Seitenquelltext nach enterprise.js. In einem Selenium-Workflow reicht dafür der bereits geladene Quelltext:

page_source = driver.page_source
is_enterprise = "enterprise.js" in page_source

Rechnet CaptchaAI für Enterprise v3 mehr ab als für Standard v3?

Nein. CaptchaAI rechnet Thread-basiert ab – Sie zahlen pro gleichzeitigem Thread, nicht pro Lösung, und es gibt keinen Aufpreis nach CAPTCHA-Typ. Enterprise v3 kostet damit genauso viel wie Standard v3; der Einstieg beginnt bei 15 $/Monat (BASIC, 5 Threads) mit unbegrenzten Lösungen pro Thread.

Warum ist mein Score niedrig, obwohl der Token gültig aussieht?

Fast immer liegt es an der falschen action. Google bewertet den Score im Kontext der erwarteten Aktion – ein login-Token auf einer checkout-Route wirkt verdächtig. Extrahieren Sie die exakte Aktionszeichenfolge aus dem Seitenskript und übergeben Sie sie unverändert.

Reicht ein einziger Solver für beide Varianten?

Ja. Ein Löser, der enterprise.js erkennt und enterprise=1 bedingt setzt, deckt Standard und Enterprise mit demselben Code ab. Das ist robuster, als die Version fest zu hinterlegen, da Websites jederzeit migrieren können.

Verwandte Leitfäden

• reCAPTCHA v3 Enterprise vs. Standard im Detail – ein alternativer Vergleichswinkel
• reCAPTCHA Enterprise vs. Standard – der vollständige Überblick
• reCAPTCHA v3 per API lösen – Tutorial für Standard v3
• reCAPTCHA v3 Enterprise per API lösen – Tutorial für Enterprise v3
• Der reCAPTCHA-v3-Aktionsparameter erklärt – Details zum action-Parameter