Comparação de reCAPTCHA v3 Enterprise vs Standard

Se a sua automação parou de funcionar de um dia para o outro em um site que antes passava sem reclamar, provavelmente ninguém trocou o CAPTCHA: o site migrou do reCAPTCHA v3 Standard para o Enterprise. No seu código, a diferença é um parâmetro — enterprise=1 na requisição à CaptchaAI. No site, muda quem define o limite de aprovação e com que granularidade.

As duas versões rodam de forma invisível e devolvem uma pontuação de risco entre 0,0 (bot) e 1,0 (humano). O Enterprise acrescenta códigos de motivo, gerenciamento por projeto no Google Cloud, limites adaptativos por ação e o Account Defender.

O que muda de fato para quem integra

Três diferenças aparecem no seu log; o resto é conversa de marketing:

• A escala continua igual, de 0,0 a 1,0. Muda o limite que o site aplica a ela.
• O limite deixa de ser único. No Standard há um corte para tudo; no Enterprise cada ação tem o seu — login passa com 0,7 enquanto checkout exige 0,9.
• O parâmetro action vira crítico: enviar a ação errada é ser avaliado contra o limite de outra.

Uma equipe de QA em São Paulo que valida o cadastro do próprio produto sente isso na prática: o script estável contra staging.example.com passa a receber tokens recusados depois que a segurança ativa o Enterprise no Google Cloud. Nada quebrou no código — mudou o limite da ação signup.

Como identificar a versão em produção

Não há diferença visual: as duas são invisíveis. A pista está no HTML. O script é enterprise.js?render=KEY no Enterprise e api.js?render=KEY no Standard, e a chamada é grecaptcha.enterprise.execute() em vez de grecaptcha.execute(). Nos dois, a sitekey (chave pública do widget) vem do render= na URL do script, não de um data-sitekey como no v2 — origem mais comum do ERROR_WRONG_GOOGLEKEY.

Em Python, a detecção cabe em uma função que devolve versão, sitekey e ação:

import requests
import re

def detect_v3_version(url):
    html = requests.get(url).text

    if "enterprise.js" in html:
        version = "enterprise"
    elif "recaptcha/api.js" in html and "render=" in html:
        version = "standard"
    else:
        return None

    # Extract sitekey
    key_match = re.search(r'render[=:]\s*["\']?([A-Za-z0-9_-]{40})', html)
    sitekey = key_match.group(1) if key_match else None

    # Extract action
    action_match = re.search(r'action["\']?\s*[:=]\s*["\'](\w+)', html)
    action = action_match.group(1) if action_match else None

    return {"version": version, "sitekey": sitekey, "action": action}

O equivalente em Node.js, para quem já tem o pipeline em JavaScript:

const axios = require("axios");

async function detectV3Version(url) {
  const { data: html } = await axios.get(url);

  const version = html.includes("enterprise.js")
    ? "enterprise"
    : html.includes("recaptcha/api.js") && html.includes("render=")
      ? "standard"
      : null;

  const keyMatch = html.match(/render[=:]\s*['"]?([A-Za-z0-9_-]{40})/);
  const actionMatch = html.match(/action['"]?\s*[:=]\s*['"](\w+)/);

  return {
    version,
    sitekey: keyMatch?.[1],
    action: actionMatch?.[1],
  };
}

Rode essa detecção a cada execução, nunca como constante: sites migram para o Enterprise sem aviso, e um valor fixo transforma a migração deles em incidente seu.

Resolvendo cada versão com a CaptchaAI

O fluxo é o mesmo nos dois casos: envie a tarefa para in.php e consulte res.php até o token ficar pronto.

Standard v3

import requests
import time

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

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 v3

A única linha nova é enterprise: 1:

import requests
import time

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

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

Detecção e resolução em um só objeto

O padrão que melhor sobrevive em produção junta as duas etapas: a classe abaixo inspeciona a página, decide se precisa da flag e envia a tarefa.

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

    def solve(self, page_url, action=None):
        import re
        html = requests.get(page_url).text

        is_enterprise = "enterprise.js" in html
        key_match = re.search(r'render[=:]\s*["\']?([A-Za-z0-9_-]{40})', html)
        if not key_match:
            raise Exception("No v3 sitekey found")

        if not action:
            act_match = re.search(r'action["\']?\s*[:=]\s*["\'](\w+)', html)
            action = act_match.group(1) if act_match else "verify"

        params = {
            "key": self.api_key,
            "method": "userrecaptcha",
            "version": "v3",
            "googlekey": key_match.group(1),
            "action": action,
            "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 result.text.split("|")[1]
            if result.text != "CAPCHA_NOT_READY":
                raise Exception(f"Solve error: {result.text}")
        raise Exception("Timed out")

Como a cobrança da CaptchaAI é por thread simultânea, e não por resolução, detectar antes de cada envio não custa nada a mais. O BASIC (US$ 15/mês, 5 threads) cobre uma suíte de QA com resoluções ilimitadas; volumes maiores só pedem mais threads — STANDARD (US$ 30/mês, 15 threads) ou ADVANCE (US$ 90/mês, 50 threads).

Códigos de motivo: por que o Enterprise recusa

É a novidade mais útil do Enterprise para quem diagnostica: junto da pontuação vêm códigos que explicam o veredito.

Importante: você não vê esses códigos ao resolver pela CaptchaAI — eles vão para o backend do site na verificação do token. Conhecê-los ajuda a interpretar o que você observa: quando o token é aceito em teste e recusado em produção, a causa costuma estar em um deles.

Pontuação e recursos, lado a lado

O Standard v3 usa um único modelo global do Google; o Enterprise parte dele e acrescenta camadas:

A consequência é contraintuitiva: a mesma pontuação pode ser aprovada em um site e recusada em outro, sem nada ter mudado do seu lado. Antes de mexer no código, meça — registre pontuação, ação e resposta a cada tentativa.

Quando algo dá errado

Se o token chega correto pela API mas o navegador reprova, o problema está no ambiente, não na resolução.

Um lembrete de escopo: tudo acima pressupõe automação autorizada — QA de formulários que você mantém, testes em staging, monitoramento autorizado. Ao registrar pontuações e respostas, considere o que a LGPD (ou o RGPD, em Portugal) exige sobre o que fica nos logs.

Perguntas frequentes

Preciso de código diferente para cada versão?

Não. O mesmo method=userrecaptcha com version=v3 atende às duas; o Enterprise só acrescenta enterprise=1. O que muda é a detecção, que roda a cada execução.

Como sei se o site migrou para o Enterprise sem avisar?

Pelo script da página: enterprise.js no lugar de api.js. Registre isso em log a cada execução — a migração aparece no monitoramento em vez de virar falha silenciosa.

A CaptchaAI cobra mais caro para resolver o Enterprise?

Não há cobrança por tipo de CAPTCHA. Os planos são por thread simultânea, com resoluções ilimitadas: de BASIC (US$ 15/mês, 5 threads) a VIP-3 (US$ 7.500/mês, 5.000 threads). Cada envio consome uma thread.

O que faço quando a pontuação cai depois da migração?

Comece pelo action: cada ação tem seu limite no Enterprise, e um verify genérico onde o site espera login derruba o resultado. Depois revise o intervalo entre requisições e o sinal de navegador.

Quais outros tipos de CAPTCHA a CaptchaAI atende?

Não há suporte a hCaptcha nem a FunCaptcha (Arkose Labs). Os tipos disponíveis incluem reCAPTCHA v2 e v3, Cloudflare Turnstile e Challenge, GeeTest v3 e CAPTCHAs de imagem/OCR e grade, além de CaptchaFox (beta), Friendly Captcha (beta) e Lemin (beta). O GeeTest v4 é "em breve".

Guias relacionados

• Standard vs Enterprise no reCAPTCHA v3
• reCAPTCHA Enterprise e Standard, do v2 ao v3
• Como resolver reCAPTCHA v3 pela API
• Como resolver reCAPTCHA v3 Enterprise pela API
• Como funciona a pontuação de risco no reCAPTCHA v3 Enterprise