reCAPTCHA v3 Enterprise vs. Standard: der Praxisvergleich

Kurz gesagt: Für Ihre Integration über CaptchaAI trennt reCAPTCHA v3 Standard und Enterprise genau ein Parameter – enterprise=1. Alles Weitere, was Google unter dem Enterprise-Label bündelt, betrifft den Seitenbetreiber, nicht Ihren Lösungsaufruf. Das Wichtigste vorab:

• Lösungscode: identisch, bis auf das Flag enterprise=1.
• Scoring: Enterprise kann pro Aktion strengere Schwellenwerte ansetzen.
• Diagnose: Ursachencodes erklären, warum ein gültiges Token trotzdem abgelehnt wird.

Warum sich der genaue Blick lohnt: Die Unterschiede zeigen, worauf Sie beim action-Parameter achten müssen und wie Sie die Version zuverlässig aus dem Quelltext erkennen.

Was sich ändert – und was nicht

Beim Wechsel von Standard auf Enterprise bleibt Ihr Integrationsweg fast gleich. Diese drei Ebenen sollten Sie auseinanderhalten:

• Gleich bleibt: die Methode userrecaptcha, version=v3, googlekey, action, pageurl und das Polling über res.php.
• Neu bei Enterprise: das Flag enterprise=1, Ursachencodes im Backend, Schwellenwerte pro Aktion, Account Defender und die Abrechnung pro Bewertung.
• Für Sie entscheidend: vor allem der action-Parameter – er beeinflusst unter Enterprise mit, ob ein Token akzeptiert oder abgelehnt wird.

Funktionsvergleich: Standard v3 vs. Enterprise v3

Beide laufen unsichtbar und geben einen Score von 0,0 (Bot) bis 1,0 (Mensch) zurück. Enterprise legt darüber eine Schicht aus Betrugssignalen und Verwaltungsfunktionen.

Scoring: warum Enterprise v3 strenger sein kann

Standard v3 nutzt ein einziges globales Bewertungsmodell. Enterprise ergänzt es um seitenspezifische Signale – mit spürbaren Folgen fürs Scoring:

• Basis-Modell: Standard nutzt Googles globales Modell; Enterprise ergänzt eigene Signale der jeweiligen Seite.
• Schwellenwerte: Standard prüft alle Aktionen gegen einen Wert; Enterprise setzt eigene Werte je Aktion (Login = 0,7, Checkout = 0,9).
• Adaptives Lernen: Enterprise lernt aus dem Traffic-Muster der Seite und stuft Signale feiner ab.
• False Positives: Standard erfordert manuelles Nachjustieren; Enterprise wertet Ursachencodes automatisch aus.

Ein Beispiel aus dem DACH-E-Commerce: Ein Shop auf Shopware- oder JTL-Basis kann für die Login-Aktion 0,7 ansetzen, für den Checkout aber 0,9 verlangen. Der korrekte action-Parameter ist unter Enterprise deshalb entscheidend – ein für login gelöstes Token kann für checkout zu niedrig ausfallen.

Ursachencodes von Enterprise v3 verstehen

Enterprise-Antworten enthalten Ursachencodes, die begründen, wie ein Score zustande kam. Wer sie kennt, versteht besser, warum eine Automatisierung auffällt:

• AUTOMATION – automatisiertes Verhalten erkannt: realistisches Browser-Verhalten und plausible Signalprofile verwenden.
• UNEXPECTED_ENVIRONMENT – ungewöhnliche Browserumgebung: Headless-Erkennung prüfen.
• TOO_MUCH_TRAFFIC – hohes Anfragevolumen aus einer Quelle: Rate-Limiting und Proxy-Rotation einsetzen.
• UNEXPECTED_USAGE_PATTERNS – auffällige Interaktionsmuster: realistische Verzögerungen zwischen Aktionen einbauen.
• LOW_CONFIDENCE_SCORE – zu wenig Daten für ein belastbares Scoring: mehr Verhaltenssignale liefern.
• SUSPECTED_CARDING / SUSPECTED_CHARGEBACK – Muster von Karten- und Rückbuchungsbetrug: für die meisten Automatisierungen irrelevant.

Hinweis: Über CaptchaAI sehen Sie diese Codes nicht. Sie gehen bei der Token-Verifizierung an das Backend der jeweiligen Website zurück – sie zu kennen hilft aber, abgelehnte Token gezielter zu diagnostizieren. Wer für TOO_MUCH_TRAFFIC Proxys rotiert, verarbeitet zudem IP-Adressen, die in der EU als personenbezogene Daten gelten; prüfen Sie Rechtsgrundlage und Datenflüsse nach DSGVO, bevor Proxy-Pools produktiv laufen.

Version erkennen und Token lösen

Der Integrationscode ist für beide Varianten nahezu identisch: erst die Version erkennen, dann mit dem passenden Parametersatz lösen.

Enterprise oder Standard? Version im Quelltext erkennen

Enterprise lädt enterprise.js, Standard lädt recaptcha/api.js mit render-Parameter. Der Sitekey steckt bei beiden im render-Wert, nicht in data-sitekey.

import requests
import re

def detect_v3_version(url):
    html = requests.get(url).text

    if "enterprise.js" in html:
        version = "enterprise"
    elif "recaptcha/api.js" in html and "render=" in html:
        version = "standard"
    else:
        return None

    # Extract sitekey
    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
    action_match = re.search(r'action["\']?\s*[:=]\s*["\'](\w+)', html)
    action = action_match.group(1) if action_match else None

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

Dieselbe Erkennung in Node.js

In JavaScript liest die Variante mit axios denselben Quelltext aus und wertet die Skript-Tags nach demselben Muster aus.

const axios = require("axios");

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

  const version = html.includes("enterprise.js")
    ? "enterprise"
    : html.includes("recaptcha/api.js") && html.includes("render=")
      ? "standard"
      : 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],
    action: actionMatch?.[1],
  };
}

Standard v3 über die API lösen

Sitekey und Aktion an in.php übermitteln, dann das Ergebnis über res.php abfragen, bis ein Token vorliegt.

import requests
import time

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]

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 lösen – nur enterprise=1 ergänzen

Derselbe Aufruf, ein zusätzlicher Parameter – mehr braucht es auf der Lösungsseite nicht.

import requests
import time

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

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

Erkennung und Lösung in einer Klasse

Praktischer ist es, Erkennung und Lösung zu kombinieren – so setzt Ihre Automatisierung enterprise=1 bei jeder Anfrage selbst, statt die Version fest zu verdrahten.

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

    def solve(self, page_url, action=None):
        import re
        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")

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

        params = {
            "key": self.api_key,
            "method": "userrecaptcha",
            "version": "v3",
            "googlekey": key_match.group(1),
            "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 error: {result.text}")
        raise Exception("Timed out")

Fehlerbehebung

Die häufigsten Stolpersteine bei Enterprise lassen sich schnell eingrenzen:

• Token auf Enterprise-Seite abgelehnt: enterprise=1 fehlt – auf enterprise.js prüfen und das Flag ergänzen.
• Niedriger Score auf Enterprise: falscher action-Parameter – die exakte Aktion aus dem Aufruf grecaptcha.enterprise.execute() übernehmen.
• Token besteht den Test, scheitert in Produktion: adaptives Lernen hat Ihr Muster erkannt – IPs rotieren, Verzögerungen ergänzen, Anfragemuster variieren.
• ERROR_WRONG_GOOGLEKEY: der Sitekey stammt aus dem render-Parameter, nicht aus data-sitekey – in der Skript-URL nach render=KEY suchen.

Häufige Fragen

Muss ich für Enterprise v3 einen anderen API-Aufruf schreiben als für Standard?

Nein. Der einzige Unterschied ist der Parameter enterprise=1 in der Anfrage an in.php. Methode (userrecaptcha), version=v3, googlekey, action und pageurl bleiben gleich – ebenso das Polling über res.php.

Kann CaptchaAI reCAPTCHA v3 Enterprise lösen?

Ja. reCAPTCHA v3 und v3 Enterprise gehören zu den unterstützten Typen und teilen sich die Methode userrecaptcha. Enterprise wird über das zusätzliche Flag enterprise=1 angesteuert.

Warum lehnt eine Enterprise-Seite mein Token trotz gültiger Lösung ab?

Meist passt der action-Parameter nicht zur geprüften Aktion. Da Enterprise Schwellenwerte pro Aktion erlaubt, kann ein für login gelöstes Token für checkout zu niedrig bewertet werden. Übernehmen Sie die Aktion exakt aus dem grecaptcha.enterprise.execute()-Aufruf.

Was ändert sich für meine Automatisierung, wenn eine Seite auf Enterprise migriert?

Am Code fast nichts – nur enterprise=1. In der Sache kann das adaptive Lernen von Enterprise auffällige Muster aber schneller erkennen. Prüfen Sie die Version deshalb dynamisch bei jeder Anfrage, statt sie fest zu codieren, und sorgen Sie für realistisches Browser-Verhalten.

Verwandte Leitfäden

• Standard vs. Enterprise bei reCAPTCHA v3 im Überblick
• reCAPTCHA Enterprise vs. Standard – der vollständige Vergleich
• reCAPTCHA v3 Enterprise per API lösen