ERROR_WRONG_GOOGLEKEY: Guia completo de diagnóstico e correção

ERROR_WRONG_GOOGLEKEY quase sempre significa que a sitekey enviada não é a que o Google espera para aquela página — raramente um problema da sua conta CaptchaAI. Este guia mostra como localizar a sitekey certa, validar antes de enviar e tratar reCAPTCHA Enterprise e invisível.

Na maioria dos casos, o diagnóstico e a correção levam menos de cinco minutos.

O que causa o ERROR_WRONG_GOOGLEKEY

Seis cenários respondem pela quase totalidade dos casos reportados:

• Sitekey errada extraída da página — o valor copiado não bate com a origem real do widget.
• Sitekey Enterprise enviada como padrão — falta o parâmetro enterprise=1 na requisição.
• Sitekey de reCAPTCHA invisível sem o parâmetro certo — falta invisible=1 na requisição.
• Sitekey dinâmica que já rotacionou — o valor era válido no momento da extração, mas o site trocou a chave depois.
• Sitekey de outra página ou domínio — extraída de um iframe ou host diferente por engano.
• Sitekey antiga fixada no código — funcionava antes, mas ficou desatualizada e ninguém percebeu.

Diagnóstico rápido: sintoma, causa e correção

Antes de investigar a fundo, cruze o sintoma observado com a tabela abaixo — ela cobre a maioria dos chamados de suporte sobre esse erro:

Como localizar a sitekey correta

Três caminhos cobrem praticamente qualquer situação, do mais rápido ao mais indicado quando o widget é montado via JavaScript:

Método 1: buscar a sitekey no código-fonte da página

Busque estes quatro padrões no HTML retornado:

import re
import requests


def extract_sitekey(page_url):
    """Extract reCAPTCHA sitekey from page source."""
    resp = requests.get(page_url, timeout=15)
    html = resp.text

    # Pattern 1: data-sitekey attribute
    match = re.search(r'data-sitekey="([^"]+)"', html)
    if match:
        return match.group(1)

    # Pattern 2: grecaptcha.render call
    match = re.search(r"grecaptcha\.render\([^,]+,\s*\{[^}]*sitekey['\"]?\s*:\s*['\"]([^'\"]+)", html)
    if match:
        return match.group(1)

    # Pattern 3: grecaptcha.execute call
    match = re.search(r"grecaptcha\.execute\(['\"]([^'\"]+)", html)
    if match:
        return match.group(1)

    # Pattern 4: reCAPTCHA script src
    match = re.search(r"recaptcha/api\.js\?render=([^&\"]+)", html)
    if match:
        return match.group(1)

    return None


sitekey = extract_sitekey("https://staging.example.com/qa-login")
print(f"Sitekey: {sitekey}")

Método 2: DevTools do navegador

Sem acesso rápido ao código-fonte renderizado, o DevTools do Chrome resolve em poucos cliques:

1. Abra a página de destino no Chrome
2. Pressione F12 e vá para a aba Elementos
3. Pressione Ctrl+F e busque por sitekey
4. Localize o atributo data-sitekey="..."
5. Copie o valor (uma sequência alfanumérica de até 40 caracteres)

Método 3: aba Rede

Quando a sitekey só aparece depois de uma chamada ao Google, capture-a diretamente na requisição:

1. Abra F12 → aba Rede
2. Filtre por recaptcha
3. Procure requisições para google.com/recaptcha/api2/anchor
4. Encontre o parâmetro k= na URL — esse valor é a sitekey

Valide a sitekey antes de enviar

Valide o formato da sitekey antes de enviar — evita gastar uma requisição com um valor claramente inválido:

import re


def validate_sitekey(sitekey):
    """Validate sitekey format before API call."""
    if not sitekey:
        raise ValueError("Sitekey is empty")

    # Standard format: 40 alphanumeric + hyphens/underscores
    if not re.match(r'^[a-zA-Z0-9_-]{20,60}$', sitekey):
        raise ValueError(f"Invalid sitekey format: {sitekey}")

    return True


# Use before solving
sitekey = extract_sitekey("https://staging.example.com/qa-login")
validate_sitekey(sitekey)

Por que validar antes: um valor claramente inválido nunca vai resolver — rejeitá-lo localmente evita gastar uma requisição só para receber ERROR_WRONG_GOOGLEKEY de volta.

reCAPTCHA Enterprise: a sitekey parece igual, mas falha

Sitekeys Enterprise parecem iguais às padrão — a diferença está no script carregado e no parâmetro da requisição:

import requests

# Standard reCAPTCHA — loads via recaptcha/api.js
# Enterprise reCAPTCHA — loads via recaptcha/enterprise.js

def detect_enterprise(page_url):
    """Detect if page uses reCAPTCHA Enterprise."""
    resp = requests.get(page_url, timeout=15)
    return "recaptcha/enterprise.js" in resp.text


# Submit with enterprise flag
is_enterprise = detect_enterprise("https://example.com")

data = {
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": "https://example.com",
    "json": 1,
}

if is_enterprise:
    data["enterprise"] = 1

resp = requests.post("https://ocr.captchaai.com/in.php", data=data)

Se a página carrega recaptcha/enterprise.js, adicione enterprise=1 — sem isso a API devolve ERROR_WRONG_GOOGLEKEY mesmo com a sitekey certa.

Cenário comum: times que testam contra staging na região sa-east-1 (São Paulo) da AWS costumam ver esse erro logo depois de um deploy — a sitekey de produção fica fixada no pipeline enquanto o staging usa uma Enterprise diferente. Extraia o valor a cada execução e, ao logar pageurl, trate os dados conforme a LGPD.

reCAPTCHA invisível: sitekey sem caixa de seleção visível

reCAPTCHA invisível dispara via grecaptcha.execute(), sem caixa de seleção visível:

def detect_invisible(html):
    """Detect invisible reCAPTCHA."""
    indicators = [
        'data-size="invisible"',
        "grecaptcha.execute(",
        "recaptcha/api.js?render=",
    ]
    return any(i in html for i in indicators)


# Submit with invisible flag
data = {
    "key": "YOUR_API_KEY",
    "method": "userrecaptcha",
    "googlekey": sitekey,
    "pageurl": "https://example.com",
    "invisible": 1,
    "json": 1,
}

Sinal rápido: se o HTML não tem data-sitekey nem chama grecaptcha.render, mas o envio funciona mesmo assim, é reCAPTCHA invisível — confirme procurando grecaptcha.execute( no código-fonte.

Sitekey renderizada via JavaScript: extração dinâmica

Alguns sites só renderizam o widget via JavaScript — nesses casos, use um navegador real:

from selenium import webdriver
from selenium.webdriver.common.by import By


def extract_dynamic_sitekey(url):
    """Extract sitekey from JavaScript-rendered page."""
    driver = webdriver.Chrome()
    driver.get(url)

    # Wait for reCAPTCHA to load
    import time
    time.sleep(3)

    # Try data-sitekey attribute
    elements = driver.find_elements(By.CSS_SELECTOR, "[data-sitekey]")
    if elements:
        sitekey = elements[0].get_attribute("data-sitekey")
        driver.quit()
        return sitekey

    # Try iframe src parameter
    iframes = driver.find_elements(By.CSS_SELECTOR, "iframe[src*='recaptcha']")
    for iframe in iframes:
        src = iframe.get_attribute("src")
        import re
        match = re.search(r'[?&]k=([^&]+)', src)
        if match:
            driver.quit()
            return match.group(1)

    driver.quit()
    return None

Perguntas frequentes

O que muda entre uma sitekey padrão e uma sitekey Enterprise?

Visualmente, nada — a diferença está no script (recaptcha/api.js vs. enterprise.js) e no parâmetro enterprise=1 na requisição.

A página tem mais de uma sitekey — como escolho a certa?

Confirme qual data-sitekey está dentro do formulário que você automatiza, não o primeiro da busca — login e newsletter na mesma tela costumam usar sitekeys diferentes.

Por quanto tempo posso reaproveitar a mesma sitekey?

Cache por períodos curtos — minutos a horas. Alguns sites rotacionam a sitekey em deploys; se a resolução falhar sem mudança no código, reextraia o valor primeiro.

O erro pode ser causado pela minha conta na CaptchaAI, e não pela sitekey?

Raramente. Antes de suspeitar de saldo ou credenciais, confirme o valor enviado — na maioria dos chamados de suporte sobre esse erro, a causa era a sitekey, não a conta.

Preciso reextrair a sitekey depois de cada deploy?

Sim, sobretudo se o staging usa reCAPTCHA Enterprise e a produção usa a versão padrão (ou vice-versa). Trate a extração como parte do checklist de deploy, não como algo pontual.

Guias relacionados

Depois de corrigir o ERROR_WRONG_GOOGLEKEY, dois guias ajudam a evitar reincidência.

Para outros erros de parâmetro, veja como corrigir erros de parâmetro inválido (BAD_PARAMETERS).

Para um fluxo completo de tratamento de erros, consulte a árvore de decisão para erros da API da CaptchaAI.

Extraia a sitekey certa da primeira vez — resolva com a CaptchaAI.