Deep Dive zur reCAPTCHA Enterprise Assessment API

reCAPTCHA Enterprise ist der Premium-CAPTCHA-Dienst von Google, der reCAPTCHA v3 um detaillierte Risikoanalysen, Bewertungsgründe, Betrugserkennungssignale und Funktionen zur Kontoverteidigung erweitert. Im Gegensatz zur kostenlosen Standardversion, die nur eine Punktzahl und eine Aktion zurückgibt, bietet Enterprise erklärbare Bewertungen mit spezifischen Risikofaktoren. Dieser Leitfaden behandelt die Enterprise Assessment API-Architektur, die Antwortstruktur und den Umgang mit unternehmensgeschützten Websites in der Automatisierung.

Enterprise vs. Standard-reCAPTCHA

Ablauf der Enterprise Assessment API

Client-side:

  1. Load reCAPTCHA Enterprise script
  2. Call grecaptcha.enterprise.execute(SITE_KEY, {action: 'LOGIN'})
  3. Receive token
  4. Send token to your backend

Server-side:

  1. Create assessment via Enterprise API
  2. Receive detailed risk analysis
  3. Make access decision based on score + reasons
  4. Optionally annotate the assessment (report fraud/legitimate)

Clientseitige Integration

JavaScript-SDK

<script src="https://www.google.com/recaptcha/enterprise.js?render=SITE_KEY"></script>
<script>
    grecaptcha.enterprise.ready(function() {
        grecaptcha.enterprise.execute('SITE_KEY', { action: 'LOGIN' })
            .then(function(token) {
                // Send token to backend
                fetch('/api/verify', {
                    method: 'POST',
                    headers: { 'Content-Type': 'application/json' },
                    body: JSON.stringify({ token: token })
                });
            });
    });
</script>

Hauptunterschiede zum Standard-reCAPTCHA v3:

• Die Skript-URL verwendet .../recaptcha/enterprise.js anstelle von .../recaptcha/api.js
• Das API-Objekt ist grecaptcha.enterprise anstelle von grecaptcha
• execute() gibt das gleiche Tokenformat zurück

Erkennung in der Seitenquelle

import requests
import re

def detect_recaptcha_enterprise(url):
    """Detect if a page uses reCAPTCHA Enterprise."""
    html = requests.get(url, timeout=10).text

    indicators = {
        "is_enterprise": False,
        "is_standard": False,
        "site_key": None,
        "actions": [],
    }

    # Enterprise detection
    if "recaptcha/enterprise.js" in html:
        indicators["is_enterprise"] = True
        match = re.search(r"render=([A-Za-z0-9_-]+)", html)
        if match:
            indicators["site_key"] = match.group(1)

    # Standard v3 detection
    elif "recaptcha/api.js?render=" in html:
        indicators["is_standard"] = True
        match = re.search(r"render=([A-Za-z0-9_-]+)", html)
        if match:
            indicators["site_key"] = match.group(1)

    # Extract action names
    actions = re.findall(r"action:\s*['\"](\w+)['\"]", html)
    indicators["actions"] = list(set(actions))

    return indicators

print(detect_recaptcha_enterprise("https://example.com/login"))

Serverseitige Bewertungs-API

Eine Bewertung erstellen (Google Cloud API)

from google.cloud import recaptchaenterprise_v1
from google.cloud.recaptchaenterprise_v1 import Assessment

def create_assessment(project_id, site_key, token, action):
    """Create a reCAPTCHA Enterprise assessment."""
    client = recaptchaenterprise_v1.RecaptchaEnterpriseServiceClient()

    event = recaptchaenterprise_v1.Event()
    event.site_key = site_key
    event.token = token
    event.expected_action = action

    assessment = recaptchaenterprise_v1.Assessment()
    assessment.event = event

    request = recaptchaenterprise_v1.CreateAssessmentRequest()
    request.assessment = assessment
    request.parent = f"projects/{project_id}"

    response = client.create_assessment(request)
    return response

Bewertungs-Antwortstruktur

{
    "name": "projects/123456/assessments/abcdef123",
    "event": {
        "token": "...",
        "siteKey": "6Le...",
        "expectedAction": "LOGIN",
        "hashedAccountId": "abc123..."
    },
    "riskAnalysis": {
        "score": 0.9,
        "reasons": [
            "AUTOMATION",
            "TOO_MUCH_TRAFFIC"
        ],
        "extendedVerdictReasons": [
            "BROWSER_ERROR"
        ]
    },
    "tokenProperties": {
        "valid": true,
        "hostname": "example.com",
        "action": "LOGIN",
        "createTime": "2025-01-15T10:30:00Z",
        "invalidReason": ""
    },
    "accountDefenderAssessment": {
        "labels": ["PROFILE_MATCH"]
    }
}

Gründe für die Unternehmensbewertung

Unternehmen nennt konkrete Gründe, warum eine Punktzahl niedrig ist:

Erweiterte Urteilsgründe (zusätzliche Angaben)

Kontoverteidiger

Der Account Defender von Enterprise verfolgt Benutzerkonten über ihren gesamten Lebenszyklus hinweg:

{
    "accountDefenderAssessment": {
        "labels": [
            "PROFILE_MATCH",
            "SUSPICIOUS_LOGIN_ACTIVITY",
            "SUSPICIOUS_ACCOUNT_CREATION",
            "RELATED_ACCOUNTS_NUMBER_HIGH"
        ]
    }
}

WAF-Integration

reCAPTCHA Enterprise lässt sich mit WAF-Anbietern integrieren, um CAPTCHA-Herausforderungen am Netzwerkrand hinzuzufügen:

Cloudflare WAF-Integration

Request arrives at Cloudflare edge
    ↓
Cloudflare WAF rule evaluates request
    ↓
Rule triggers reCAPTCHA Enterprise challenge
    ↓
Client solves CAPTCHA → token returned
    ↓
Cloudflare validates token via Enterprise API
    ↓
If valid + score above threshold → request forwarded to origin

F5 BIG-IP-Integration

F5 iRule or policy evaluates request
    ↓
Triggers reCAPTCHA Enterprise challenge page
    ↓
Client solves → token validated server-side
    ↓
F5 forwards or blocks based on assessment score

Umgang mit Enterprise reCAPTCHA in der Automatisierung

CaptchaAI löst Enterprise auf die gleiche Weise wie Standard-reCAPTCHA

Aus API-Solver-Perspektive funktionieren reCAPTCHA Enterprise-Tokens identisch mit Standard-reCAPTCHA-Tokens:

import requests
import time

API_KEY = "YOUR_API_KEY"

# Enterprise is solved with the same method
# The solver handles the Enterprise variant automatically
submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": "6LcR_RsTAAAAAN_r0GEkGBfq3L7KmU5JbPHJtwNp",
    "pageurl": "https://enterprise-site.com/login",
    "enterprise": 1,  # Flag for Enterprise variant
    "json": 1,
})

task_id = submit.json()["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:
        token = result["request"]
        print(f"Enterprise token: {token[:50]}...")
        break

Node.js

const axios = require("axios");

async function solveEnterprise(sitekey, pageurl) {
    const API_KEY = "YOUR_API_KEY";

    const { data: submit } = await axios.post(
        "https://ocr.captchaai.com/in.php",
        new URLSearchParams({
            key: API_KEY,
            method: "userrecaptcha",
            googlekey: sitekey,
            pageurl: pageurl,
            enterprise: 1,
            json: 1,
        })
    );

    const taskId = submit.request;

    for (let i = 0; i < 60; i++) {
        await new Promise(r => setTimeout(r, 5000));
        const { data: result } = await axios.get(
            "https://ocr.captchaai.com/res.php",
            { params: { key: API_KEY, action: "get", id: taskId, json: 1 } }
        );

        if (result.status === 1) return result.request;
    }

    throw new Error("Timeout");
}

So erkennen Sie Enterprise vs. Standard auf einer Zielseite

def identify_recaptcha_version(html):
    """Determine which reCAPTCHA version a page uses."""
    if "recaptcha/enterprise.js" in html:
        return "enterprise"
    elif "recaptcha/api.js?render=" in html:
        return "v3"
    elif "g-recaptcha" in html and 'data-size="invisible"' in html:
        return "v2_invisible"
    elif "g-recaptcha" in html:
        return "v2"
    else:
        return "none"

Fehlerbehebung für Unternehmen

Häufig gestellte Fragen

Ist reCAPTCHA Enterprise schwieriger zu lösen als Standard-reCAPTCHA?

Der Token-Generierungsprozess ist derselbe. Enterprise fügt serverseitige Analysefunktionen hinzu (Bewertungsgründe, Account Defender), aber die clientseitige Herausforderung ist identisch. API-Solver generieren Token für Enterprise auf die gleiche Weise wie für Standardversionen.

Benötige ich ein Google Cloud-Konto, um Unternehmens-CAPTCHAs zu lösen?

Nein. Als Automatisierungsentwickler, der Unternehmens-CAPTCHAs auf Zielwebsites löst, benötigen Sie lediglich den sitekey von der Seite und einen API-Solver wie CaptchaAI. Das Google Cloud-Konto wird vom Website-Betreiber zur Validierung von Bewertungen benötigt, nicht vom CAPTCHA-Löser.

Wie kann ich feststellen, ob eine Website Enterprise- oder Standard-reCAPTCHA verwendet?

Überprüfen Sie die Skript-URL. Enterprise verwendet recaptcha/enterprise.js, während Standard recaptcha/api.js verwendet. Auch der Name des JavaScript-API-Objekts unterscheidet sich: grecaptcha.enterprise.execute() vs. grecaptcha.execute().

Können Enterprise-Score-Gründe zur Verbesserung meiner Automatisierung verwendet werden?

Wenn Sie die Zielseite betreiben (und Ihre eigene CAPTCHA-Implementierung testen), ja – aus den Gründen erfahren Sie, welche Erkennungssignale ausgelöst wurden. Wenn Sie CAPTCHAs auf Drittseiten lösen, sind die Gründe für Sie nicht sichtbar, sondern nur für den Seitenbetreiber.

Zusammenfassung

reCAPTCHA Enterprise erweitert das Standard-reCAPTCHA um detaillierte Risikoanalyse, Bewertungsgründe, Account Defender und WAF-Integration. Aus Sicht der Automatisierung werden Enterprise-CAPTCHAs genauso gelöst wie Standard-reCAPTCHA – fügen Sie den Parameter enterprise=1 zu Ihrem hinzuCaptchaAIAPI-Anfrage. Erkennen Sie Enterprise, indem Sie in der Seitenquelle nach recaptcha/enterprise.js suchen. Der wesentliche betriebliche Unterschied besteht darin, sicherzustellen, dass Sie das richtige enterprise-Flag und den passenden action-Parameter übergeben.

Verwandte Leitfäden

• reCAPTCHA v2 Callback lösen
• reCAPTCHA v2 und Turnstile: Gleiche Seite
• So lösen Sie Recaptcha V3 Enterprise mithilfe der API