Unterschiede zwischen Standard- und Enterprise-Solver reCAPTCHA v2

Sie stehen vor einer Seite mit dem „Ich bin kein Roboter“-Kontrollkästchen und müssen entscheiden: Standard v2 oder Enterprise v2? Für das Lösen selbst ist die Antwort beruhigend kurz – ein einziger Parameter, enterprise=1, trennt die beiden Wege. Der eigentliche Stolperstein liegt davor: die Erkennung, welche Variante eine Seite tatsächlich einsetzt. Wer hier falsch tippt, erhält am Ende ein Token, das die Ziel-Site ablehnt. Dieser Vergleich zeigt zuerst, woran Sie Enterprise v2 sicher erkennen, und dann, wie Sie beide Varianten mit derselben CaptchaAI-Integration verarbeiten.

So erkennen Sie reCAPTCHA v2 Enterprise

Der entscheidende Unterschied steckt nicht im Kontrollkästchen, sondern in der JavaScript-Datei, die die Seite lädt. Standard v2 bindet api.js ein, Enterprise v2 die Datei enterprise.js. Das ist das eine Signal, auf das Sie sich verlassen können.

Worauf Sie sich hingegen nicht verlassen sollten:

• der Sitekey allein – er verrät die Variante nicht;
• das Aussehen des Widgets – Kontrollkästchen und Bildraster sind identisch;
• der Domainname oder das CMS – Enterprise taucht auf großen wie auf kleinen Seiten auf.

Prüfen Sie das Skript-Tag:

<!-- Standard v2 -->
<script src="https://www.google.com/recaptcha/api.js"></script>

<!-- Enterprise v2 -->
<script src="https://www.google.com/recaptcha/enterprise.js"></script>

Automatisierte Erkennung (Python):

import requests
from bs4 import BeautifulSoup

def detect_recaptcha_version(url):
    resp = requests.get(url)
    soup = BeautifulSoup(resp.text, "html.parser")

    enterprise_script = soup.find("script", src=lambda s: s and "enterprise.js" in s)
    standard_script = soup.find("script", src=lambda s: s and "recaptcha/api.js" in s)

    widget = soup.find(class_="g-recaptcha")
    sitekey = widget["data-sitekey"] if widget else None

    if enterprise_script:
        return {"version": "enterprise_v2", "sitekey": sitekey}
    elif standard_script:
        return {"version": "standard_v2", "sitekey": sitekey}
    return None

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

Automatisierte Erkennung (Node.js):

const axios = require("axios");
const cheerio = require("cheerio");

async function detectRecaptchaVersion(url) {
  const { data } = await axios.get(url);
  const $ = cheerio.load(data);

  const hasEnterprise = $('script[src*="enterprise.js"]').length > 0;
  const hasStandard = $('script[src*="recaptcha/api.js"]').length > 0;
  const sitekey = $(".g-recaptcha").attr("data-sitekey");

  if (hasEnterprise) return { version: "enterprise_v2", sitekey };
  if (hasStandard) return { version: "standard_v2", sitekey };
  return null;
}

Schnellprüfung in der Browserkonsole:

// Quick check in DevTools
if (document.querySelector('script[src*="enterprise.js"]')) {
  console.log("Enterprise v2");
} else if (document.querySelector('script[src*="recaptcha/api.js"]')) {
  console.log("Standard v2");
}

In DACH-Projekten begegnet Ihnen Enterprise v2 häufig in Login- und Kontobereichen größerer SaaS-Plattformen und Portale. Für eigene QA-Tests spielen Sie das Formular am besten zuerst in einer Staging-Umgebung durch, prüfen dort das Skript-Tag und binden den Solver erst danach produktiv ein. Bei Scraping-Vorhaben gilt zusätzlich die übliche DSGVO-Sorgfalt: Prüfen Sie Ihre Datenflüsse und die Rechtsgrundlage, bevor Sie Seiten mit personenbezogenen Daten automatisiert abrufen.

Standard v2 und Enterprise v2 im Vergleich

Für das Auge sind beide Varianten nicht zu unterscheiden – gleiches Widget, gleiches Bildraster. Die Unterschiede liegen ausschließlich im Backend. Enterprise ergänzt drei Dinge, die den Betreiber der Website betreffen, nicht Ihre Integration:

• Reason Codes wie AUTOMATION oder TOO_MUCH_TRAFFIC, die Google an das Site-Backend meldet;
• eigene Regeln mit Grenzwerten pro Aktion;
• die Anbindung an die Google Cloud Console samt projektbasierter Verwaltung und Passwortleck-Erkennung.

Für den Solver bleibt der Aufwand dagegen nahezu gleich.

Die Zeile, auf die es beim Lösen ankommt, ist die letzte vor dem Token-Format: der Parameter enterprise=1. Alles Übrige – Reason Codes, Passwortleck-Erkennung, projektbasierte Verwaltung – spielt sich im Backend der Website ab und berührt Ihre Integration nicht.

Beide Varianten mit CaptchaAI lösen

reCAPTCHA v2 und v2 Enterprise gehören beide zu den regulär unterstützten Typen bei CaptchaAI. Der Ablauf ist in beiden Fällen identisch und besteht aus drei Schritten:

1. Aufgabe mit googlekey und pageurl an in.php übermitteln.
2. Status im Sekundentakt an res.php abfragen (Polling), bis das Token zurückkommt.
3. Token in das Formularfeld einfügen und das Formular absenden.

Der einzige Unterschied zwischen den Varianten ist der zusätzliche Parameter enterprise=1 im ersten Schritt.

Standard v2

import requests
import time

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

# Poll for token
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 v2

import requests
import time

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

# Polling is identical
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 Solver mit automatischer Erkennung

Am robustesten ist es, Erkennung und Lösung in einer Klasse zu bündeln: Sie prüfen einmal auf enterprise.js, setzen den Parameter bedingt und behalten für Standard und Enterprise denselben Code.

import requests
import time
from bs4 import BeautifulSoup

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

    def detect_and_solve(self, page_url, page_html=None):
        if not page_html:
            page_html = requests.get(page_url).text

        soup = BeautifulSoup(page_html, "html.parser")
        is_enterprise = bool(soup.find("script", src=lambda s: s and "enterprise.js" in s))
        widget = soup.find(class_="g-recaptcha")
        sitekey = widget["data-sitekey"] if widget else None

        if not sitekey:
            raise Exception("No reCAPTCHA sitekey found on page")

        params = {
            "key": self.api_key,
            "method": "userrecaptcha",
            "googlekey": sitekey,
            "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 {
                    "token": result.text.split("|")[1],
                    "is_enterprise": is_enterprise,
                    "sitekey": sitekey
                }
            if result.text != "CAPCHA_NOT_READY":
                raise Exception(f"Solve failed: {result.text}")

        raise Exception("Solve timed out")


solver = RecaptchaV2Solver("YOUR_API_KEY")
result = solver.detect_and_solve("https://example.com/login")
print(f"Enterprise: {result['is_enterprise']}, Token: {result['token'][:40]}...")

Typische Fehler bei der Enterprise-Erkennung

Fast alle Probleme in diesem Umfeld gehen auf eine falsch erkannte Variante zurück – nicht auf das Lösen selbst. Der rote Faden ist immer derselbe:

• Erst die Variante am Skript-Tag bestimmen, dann den Parameter setzen.
• enterprise=1 gehört ausschließlich auf Seiten mit enterprise.js.

Diese vier Fälle decken die überwiegende Mehrheit der Fehlerbilder ab.

Token einfügen – für beide Varianten gleich

Ist das Token gelöst, tragen Sie es in das versteckte Feld g-recaptcha-response ein und rufen bei Bedarf die Callback-Funktion des Widgets auf. Der Schritt ist für Standard und Enterprise identisch.

# Selenium injection — works for both standard and enterprise
driver.execute_script(
    f'document.getElementById("g-recaptcha-response").value = "{token}";'
)

# If the page uses a callback function
callback = driver.find_element("css selector", ".g-recaptcha").get_attribute("data-callback")
if callback:
    driver.execute_script(f'{callback}("{token}");')

// Puppeteer injection — works for both
await page.evaluate((token) => {
  document.getElementById("g-recaptcha-response").value = token;
  // Find and call callback if present
  const widget = document.querySelector(".g-recaptcha");
  const cb = widget?.getAttribute("data-callback");
  if (cb && typeof window[cb] === "function") {
    window[cb](token);
  }
}, token);

Beachten Sie, dass reCAPTCHA-Token nur rund 120 Sekunden gültig sind. Lösen Sie das Token daher unmittelbar vor dem Absenden des Formulars und nicht auf Vorrat.

Häufige Fragen

Unterstützt CaptchaAI reCAPTCHA v2 Enterprise?

Ja. Sowohl reCAPTCHA v2 als auch v2 Enterprise sind regulär unterstützte Typen. Beide nutzen dieselbe Submit-Methode userrecaptcha; für Enterprise ergänzen Sie lediglich enterprise=1.

Woran erkenne ich, ob eine Seite Enterprise v2 nutzt?

Am eingebundenen Skript. Zwei schnelle Wege:

• Quelltext ansehen und nach enterprise.js (Enterprise) bzw. recaptcha/api.js (Standard) suchen.
• Die Schnellprüfung aus dem Abschnitt oben in der Browserkonsole ausführen.

Der Sitekey allein reicht als Signal nicht.

Muss ich Reason Codes in meiner Integration behandeln?

Nein. Reason Codes gibt Google während der Verifizierung an das Backend der Website zurück. Für den Solver sind sie unsichtbar, und Ihre CaptchaAI-Integration benötigt dafür keine Anpassung.

Ist v2 Enterprise schwerer zu lösen als Standard v2?

Nein. Kontrollkästchen und Bildraster sind identisch. Enterprise ergänzt nur Backend-Analysen wie Reason Codes und eigene Schwellenwerte; die Schwierigkeit der Abfrage bleibt für den Solver gleich.

Welcher CaptchaAI-Tarif passt zu vielen parallelen Lösungen?

CaptchaAI rechnet pro gleichzeitigem Thread ab – nicht pro Lösung – mit unbegrenzten Lösungen je Thread. Als Orientierung:

• BASIC (15 $/Monat, 5 Threads) – einzelne Test-Pipelines;
• ADVANCE (90 $/Monat, 50 Threads) – mittlere Parallelität;
• PREMIUM (170 $/Monat, 100 Threads) – hoher Durchsatz.

Preise in US-Dollar; die aktuellen Werte finden Sie auf der Preisseite.

Verwandte Leitfäden

• reCAPTCHA Enterprise und Standard im vollständigen Vergleich – alle Versionen im Überblick
• reCAPTCHA v2 per API lösen – Anleitung für Standard v2
• reCAPTCHA v2 Enterprise per API lösen – Anleitung für Enterprise v2
• reCAPTCHA-Enterprise-Implementierung erkennen – Erkennung im Detail
• reCAPTCHA Enterprise sicher identifizieren