Erros e correções de verificação de domínio reCAPTCHA

O reCAPTCHA valida que os tokens são usados ​​no mesmo domínio para o qual foram gerados. Quando há uma incompatibilidade entre a configuração do domínio do CAPTCHA e a origem real da solicitação, você recebe erros de verificação de domínio. Essas falhas são silenciosas — o token parece válido, mas o servidor o rejeita. Este guia cobre todos os cenários de erros relacionados ao domínio e como corrigi-los.

Como funciona a verificação de domínio

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 }

Onde o domínio é verificado

Erros comuns de verificação de domínio

Erro 1: incompatibilidade de nome de host na resposta do siteverify

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

O token é válido, mas o campo hostname mostra um domínio diferente do esperado. Algumas implementações de servidor rejeitam isso:

# 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

Causas:

• Token resolvido para www.example.com mas validado em example.com
• Token resolvido para staging.example.com mas validado em example.com
• Proxy ou CDN altera o nome do host aparente

Correção: Certifique-se de que pageurl em sua solicitação do solucionador corresponda exatamente ao domínio onde o token será enviado.

Erro 2: o widget se recusa a carregar

O widget reCAPTCHA mostra um erro ou não é renderizado:

ERROR: Invalid domain for site key

Causas:

• Os domínios permitidos da chave do site não incluem o domínio da página atual
• Carregando o widget do localhost ou arquivo:protocolo //
• Usando um endereço IP em vez de um nome de domínio

Correção para automação: este é um problema de configuração do proprietário do site. Para resolver, certifique-se de passar o pageurl correto que corresponde a um domínio permitido.

Erro 3: Token rejeitado apesar da resolução correta

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

O token foi gerado para um domínio diferente daquele onde está sendo validado.

Causa comum de automação: O pageurl enviado ao solucionador não corresponde ao domínio de destino real:

# 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://staging.example.com/qa-login",  # ← Must match actual domain
    "json": 1,
})

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

Regras de correspondência de domínio

Correspondência exata vs curinga

A verificação de domínio do reCAPTCHA não é uma correspondência estrita de subdomínio por padrão. O comportamento depende da configuração do proprietário do site:

Comportamento do nome de host do lado do servidor

Ao validar via siteverify, o hostname na resposta reflete a página onde o token foi gerado. O servidor do proprietário do site decide se aceita:

# 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

Corrigindo erros de domínio na automação

Correção 1: corresponda exatamente ao URL da página

A correção mais comum – garantir que pageurl corresponda ao alvo real:

# Correct: pageurl matches where you'll submit the token
target_url = "https://www.staging.example.com/qa-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,
})

Correção 2: lidar com www e não 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://staging.example.com/qa-login", allow_redirects=True)
actual_url = response.url  # May be https://www.staging.example.com/qa-login after redirect

Correção 3: detecte o domínio correto da cadeia de redirecionamento

Alguns sites redirecionam através de vários domínios:

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://staging.example.com/qa-login → https://auth.staging.example.com/qa-login
final_url = get_final_url("https://staging.example.com/qa-login")
# Use final_url as pageurl for solver

Correção 4: extraia o domínio do URL de retorno de chamada reCAPTCHA

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

Ferramenta de diagnóstico de verificação de domínio

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://staging.example.com/qa-login")
diag.report()

Tabela de solução de problemas

Perguntas frequentes

CaptchaAI lida com a verificação de domínio automaticamente?

CaptchaAI gera tokens vinculados ao pageurl que você fornece. Você deve garantir que esse URL corresponda ao domínio para o qual enviará o token. CaptchaAI não verifica a configuração do domínio – ele usa qualquer pageurl que você especificar.

Posso resolver um CAPTCHA para um domínio e utilizá-lo em outro?

Os tokens reCAPTCHA estão vinculados ao domínio para o qual foram gerados. Um token gerado para example.com não pode ser usado em other-site.com. Mesmo subdomínios diferentes podem falhar se o site validar estritamente o nome do host.

Por que meu token funciona nos testes, mas falha na produção?

Causas comuns: (1) O teste usa localhost que possui regras de domínio diferentes, (2) A produção usa um CDN com um domínio diferente, (3) A produção tem validação de nome de host mais rigorosa, (4) Caminho de URL ou cadeia de redirecionamento diferente na produção.

O caminho importa ou apenas o domínio?

Apenas o domínio (nome do host) é validado pelo reCAPTCHA. O caminho (/login, /signup) não afeta a verificação do domínio. No entanto, você ainda deve usar o URL completo correto como pageurl porque algumas implementações do solucionador podem usá-lo para outros fins.

Resumo

A verificação de domínio reCAPTCHA vincula os tokens ao nome do host onde foram gerados. A falha de automação mais comum é uma incompatibilidade de pageurl — o URL passado paraCaptchaAIdeve corresponder ao domínio onde o token será enviado. Siga os redirecionamentos para encontrar o domínio real, lide com variantes www e não www e use a ferramenta de diagnóstico de domínio para identificar incompatibilidades antes de resolver.

Artigos relacionados

• Como resolver o retorno de chamada do Recaptcha V2 usando API
• Torniquete Recaptcha V2 no mesmo local
• Erros e correções comuns de captcha de imagem de grade