Fehler und Korrekturen bei der reCAPTCHA-Domänenüberprüfung

reCAPTCHA überprüft, ob Token in derselben Domäne verwendet werden, für die sie generiert wurden. Wenn eine Diskrepanz zwischen der Domänenkonfiguration des CAPTCHA und dem tatsächlichen Anforderungsursprung besteht, erhalten Sie Fehler bei der Domänenüberprüfung. Diese Fehler sind still – das Token scheint gültig zu sein, aber der Server lehnt es ab. In diesem Leitfaden werden alle domänenbezogenen Fehlerszenarien und deren Behebung behandelt.

So funktioniert die Domain-Verifizierung

Site owner registers reCAPTCHA → adds allowed domains (example.com, www.example.com)
    ↓
reCAPTCHA widget loads on example.com → matches allowed domain ✓
    ↓
Token generated with embedded hostname
    ↓
Server validates token via siteverify API
    ↓
Google checks: Does token hostname match allowed domains?
    ├─ YES → { "success": true, "hostname": "example.com" }
    └─ NO  → { "success": false, error or hostname mismatch }

Wo die Domäne überprüft wird

Häufige Fehler bei der Domänenüberprüfung

Fehler 1: Hostname stimmt in der Siteverify-Antwort nicht überein

{
    "success": true,
    "hostname": "subdomain.example.com",
    "challenge_ts": "2025-01-15T10:30:00Z"
}

Das Token ist gültig, aber das Feld hostname zeigt eine andere Domäne als erwartet. Einige Serverimplementierungen lehnen dies ab:

# Server-side validation that checks hostname
def validate_token(token, secret_key, expected_hostname):
    result = requests.post(
        "https://www.google.com/recaptcha/api/siteverify",
        data={"secret": secret_key, "response": token},
    ).json()

    if not result.get("success"):
        return False

    # This check causes failures when hostnames don't match
    if result.get("hostname") != expected_hostname:
        return False  # Domain mismatch!

    return True

Ursachen:

• Token für www.example.com gelöst, aber für example.com validiert
• Token für staging.example.com gelöst, aber für example.com validiert
• Proxy oder CDN ändern den scheinbaren Hostnamen

Fix: Stellen Sie sicher, dass pageurl in Ihrer Solver-Anfrage genau mit der Domäne übereinstimmt, an die das Token übermittelt wird.

Fehler 2: Widget lässt sich nicht laden

Das reCAPTCHA-Widget zeigt einen Fehler an oder rendert nicht:

ERROR: Invalid domain for site key

Ursachen:

• Die zulässigen Domänen des Site-Schlüssels umfassen nicht die Domäne der aktuellen Seite
• Laden des Widgets vom Protokoll localhost oder file://
• Verwendung einer IP-Adresse anstelle eines Domänennamens

Fix für die Automatisierung: Dies ist ein Konfigurationsproblem des Websitebesitzers. Stellen Sie zum Lösen sicher, dass Sie den richtigen pageurl übergeben, der einer zulässigen Domäne entspricht.

Fehler 3: Token trotz korrekter Lösung abgelehnt

{
    "success": false,
    "error-codes": ["invalid-input-response"]
}

Das Token wurde für eine andere Domäne generiert als die, in der es validiert wird.

Häufige Automatisierungsursache: Der an den Solver gesendete pageurl stimmt nicht mit der tatsächlichen Zieldomäne überein:

# WRONG: pageurl doesn't match actual target
submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": "https://example.com/login",  # ← Must match actual domain
    "json": 1,
})

# But submitting token to:
requests.post("https://app.example.com/login", ...)  # Different subdomain!

Domain-Matching-Regeln

Genaue Übereinstimmung mit Wildcard

Die Domänenüberprüfung von reCAPTCHA ist standardmäßig kein strikter Subdomänenabgleich. Das Verhalten hängt von der Konfiguration des Websitebesitzers ab:

Serverseitiges Hostnamenverhalten

Bei der Validierung über siteverify spiegelt hostname in der Antwort die Seite wider, auf der das Token generiert wurde. Der Server des Websitebesitzers entscheidet, ob er es akzeptiert:

# Permissive validation (accepts any subdomain)
def validate_permissive(token, secret, base_domain):
    result = requests.post(
        "https://www.google.com/recaptcha/api/siteverify",
        data={"secret": secret, "response": token},
    ).json()

    if not result.get("success"):
        return False

    hostname = result.get("hostname", "")
    return hostname == base_domain or hostname.endswith(f".{base_domain}")


# Strict validation (exact match only)
def validate_strict(token, secret, expected_hostname):
    result = requests.post(
        "https://www.google.com/recaptcha/api/siteverify",
        data={"secret": secret, "response": token},
    ).json()

    return result.get("success") and result.get("hostname") == expected_hostname

Beheben von Domänenfehlern in der Automatisierung

Fix 1: Passen Sie die Seiten-URL genau an

Die häufigste Lösung besteht darin, sicherzustellen, dass pageurl mit dem tatsächlichen Ziel übereinstimmt:

# Correct: pageurl matches where you'll submit the token
target_url = "https://www.example.com/login"

submit = requests.post("https://ocr.captchaai.com/in.php", data={
    "key": API_KEY,
    "method": "userrecaptcha",
    "googlekey": "6LcR_RsTAAAAAN_r0GEkGBfq3L7KmU5JbPHJtwNp",
    "pageurl": target_url,  # Must match the actual domain
    "json": 1,
})

Fix 2: Behandeln Sie www vs. nicht-www

from urllib.parse import urlparse

def normalize_url(url):
    """Normalize URL for consistent domain matching."""
    parsed = urlparse(url)
    # Use exactly what the target site uses
    # Check if the site redirects www → non-www or vice versa
    return f"{parsed.scheme}://{parsed.netloc}{parsed.path}"

# Test which variant the site uses
response = requests.get("https://example.com/login", allow_redirects=True)
actual_url = response.url  # May be https://www.example.com/login after redirect

Fix 3: Erkennen Sie die richtige Domain aus der Weiterleitungskette

Einige Websites leiten über mehrere Domänen weiter:

def get_final_url(url):
    """Follow redirects to find the actual CAPTCHA page domain."""
    response = requests.get(url, allow_redirects=True, timeout=15)
    return response.url

# Login URL might redirect:
# https://example.com/login → https://auth.example.com/login
final_url = get_final_url("https://example.com/login")
# Use final_url as pageurl for solver

Fix 4: Domain aus reCAPTCHA-Callback-URL extrahieren

from bs4 import BeautifulSoup
from urllib.parse import urlparse

def extract_recaptcha_domain(html, page_url):
    """Extract the domain reCAPTCHA uses for token binding."""
    soup = BeautifulSoup(html, "html.parser")

    # Check for reCAPTCHA iframe
    iframe = soup.find("iframe", src=lambda s: s and "recaptcha" in s)
    if iframe:
        src = iframe.get("src", "")
        # The iframe URL may contain the domain parameter
        if "domain=" in src:
            # Extract domain from iframe URL
            pass

    # Default: use the page URL's domain
    return urlparse(page_url).netloc

Diagnosetool zur Domänenüberprüfung

import requests
from urllib.parse import urlparse

class DomainDiagnostic:
    """Diagnose domain verification issues for reCAPTCHA solving."""

    def __init__(self, target_url):
        self.target_url = target_url
        self.issues = []

    def check_redirects(self):
        """Check if the URL redirects to a different domain."""
        try:
            response = requests.get(
                self.target_url, allow_redirects=True, timeout=15,
                headers={"User-Agent": "Mozilla/5.0 Chrome/120.0.0.0"},
            )
            final_url = response.url
            original_domain = urlparse(self.target_url).netloc
            final_domain = urlparse(final_url).netloc

            if original_domain != final_domain:
                self.issues.append({
                    "type": "redirect",
                    "message": f"Redirects from {original_domain} to {final_domain}",
                    "fix": f"Use pageurl: {final_url}",
                })

            return final_url
        except Exception as e:
            self.issues.append({"type": "error", "message": str(e)})
            return self.target_url

    def check_www_variant(self):
        """Check if www and non-www point to the same content."""
        parsed = urlparse(self.target_url)
        domain = parsed.netloc

        if domain.startswith("www."):
            alt_domain = domain[4:]
        else:
            alt_domain = f"www.{domain}"

        alt_url = self.target_url.replace(domain, alt_domain)

        try:
            alt_response = requests.get(alt_url, allow_redirects=True, timeout=10)
            alt_final = urlparse(alt_response.url).netloc

            if alt_final != domain and alt_final != alt_domain:
                self.issues.append({
                    "type": "www_redirect",
                    "message": f"{alt_domain} redirects to {alt_final}",
                })
        except Exception:
            pass

    def report(self):
        """Generate diagnostic report."""
        final_url = self.check_redirects()
        self.check_www_variant()

        print(f"Target URL: {self.target_url}")
        print(f"Final URL:  {final_url}")
        print(f"Use as pageurl: {final_url}")

        if self.issues:
            print("\nIssues found:")
            for issue in self.issues:
                print(f"  [{issue['type']}] {issue['message']}")
                if "fix" in issue:
                    print(f"  Fix: {issue['fix']}")
        else:
            print("\nNo domain issues detected.")


# Usage
diag = DomainDiagnostic("https://example.com/login")
diag.report()

Fehlerbehebungstabelle

Häufig gestellte Fragen

Führt CaptchaAI die Domänenüberprüfung automatisch durch?

CaptchaAI generiert Token, die an das von Ihnen bereitgestellte pageurl gebunden sind. Sie müssen sicherstellen, dass diese URL mit der Domäne übereinstimmt, an die Sie das Token übermitteln. CaptchaAI überprüft die Domänenkonfiguration nicht – es verwendet die von Ihnen angegebene Seiten-URL.

Kann ich ein CAPTCHA für eine Domain lösen und es für eine andere verwenden?

Nein. reCAPTCHA-Tokens sind an die Domain gebunden, für die sie generiert wurden. Ein für example.com generiertes Token kann nicht für other-site.com verwendet werden. Sogar verschiedene Subdomains können fehlschlagen, wenn die Site den Hostnamen strikt validiert.

Warum funktioniert mein Token beim Testen, schlägt jedoch in der Produktion fehl?

Häufige Ursachen: (1) Beim Testen wird localhost verwendet, das andere Domänenregeln hat, (2) Die Produktion verwendet ein CDN mit einer anderen Domäne, (3) Die Produktion verfügt über eine strengere Hostnamen-Validierung, (4) Anderer URL-Pfad oder andere Umleitungskette in der Produktion.

Spielt der Pfad eine Rolle oder nur die Domäne?

Nur die Domäne (Hostname) wird von reCAPTCHA validiert. Der Pfad (/login, /signup) hat keinen Einfluss auf die Domänenüberprüfung. Sie sollten jedoch weiterhin die korrekte vollständige URL als pageurl verwenden, da sie von einigen Solver-Implementierungen möglicherweise für andere Zwecke verwendet wird.

Zusammenfassung

Die reCAPTCHA-Domänenüberprüfung verknüpft Token mit dem Hostnamen, auf dem sie generiert wurden. Der häufigste Automatisierungsfehler ist eine Nichtübereinstimmung von pageurl – der URL, an die übergeben wirdCaptchaAImuss mit der Domäne übereinstimmen, an die das Token übermittelt wird. Folgen Sie den Weiterleitungen, um die tatsächliche Domain zu finden, behandeln Sie WWW- und Nicht-WWW-Varianten und verwenden Sie das Domain-Diagnosetool, um Nichtübereinstimmungen vor der Lösung zu identifizieren.

Verwandte Leitfäden

• reCAPTCHA v2 Callback lösen
• reCAPTCHA v2 und Turnstile: Gleiche Seite
• Häufige Grid-Image-Captcha-Fehler und -Korrekturen