Guia de solução do reCAPTCHA v3 padrão vs empresarial

Both versions run invisibly and return a risk score (0.0 to 1.0). Enterprise adds reason codes, adaptive thresholds, and Google Cloud project management — but from a CaptchaAI solving perspective, the only parameter difference is enterprise=1. The challenge is detecting which version a site uses, since both are invisible.

Comparação de recursos

How to detect which version a site uses

Since both versions are invisible (no visible widget), detection must rely on the JavaScript:

Detecção de Python:

import requests
import re

def detect_v3_type(url):
    resp = requests.get(url)
    html = resp.text

    # Check for enterprise.js
    if "enterprise.js" in html:
        version = "enterprise_v3"
        execute_fn = "grecaptcha.enterprise.execute"
    elif "recaptcha/api.js" in html and "render=" in html:
        version = "standard_v3"
        execute_fn = "grecaptcha.execute"
    else:
        return None

    # Extract sitekey from render parameter
    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 parameter
    action_match = re.search(r'action["\']?\s*[:=]\s*["\'](\w+)', html)
    action = action_match.group(1) if action_match else "unknown"

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

info = detect_v3_type("https://staging.example.com/qa-login")
print(info)

Detecção de Node.js:

const axios = require("axios");

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

  let version, executeFn;
  if (html.includes("enterprise.js")) {
    version = "enterprise_v3";
    executeFn = "grecaptcha.enterprise.execute";
  } else if (html.includes("recaptcha/api.js") && html.includes("render=")) {
    version = "standard_v3";
    executeFn = "grecaptcha.execute";
  } else {
    return 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] || null,
    action: actionMatch?.[1] || "unknown",
    executeFn,
  };
}

Browser console quick check:

// Paste in DevTools console
if (document.querySelector('script[src*="enterprise.js"]')) {
  console.log("Enterprise v3");
  console.log("Execute:", typeof grecaptcha?.enterprise?.execute);
} else if (document.querySelector('script[src*="api.js"][src*="render="]')) {
  console.log("Standard v3");
  console.log("Execute:", typeof grecaptcha?.execute);
}

Resolvendo com CaptchaAI

Padrão v3

import requests
import time

# Submit
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]

# Poll
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

Empresa v3

import requests
import time

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

# Polling is identical to standard
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

Universal solver with auto-detection

import requests
import time
import re

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

    def detect_and_solve(self, page_url, action=None):
        """Auto-detect standard vs enterprise and solve."""
        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")
        sitekey = key_match.group(1)

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

        params = {
            "key": self.api_key,
            "method": "userrecaptcha",
            "version": "v3",
            "googlekey": sitekey,
            "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 failed: {result.text}")

        raise Exception("Timed out")

solver = RecaptchaV3Solver("YOUR_API_KEY")
token = solver.detect_and_solve("https://staging.example.com/qa-login", action="login")
print(f"Token: {token[:40]}...")

Erros comuns

Extraindo o parâmetro de ação

O parâmetro action é crítico para v3 — tanto padrão quanto empresarial. Se você enviar a ação errada, a pontuação será baixa e o token poderá ser rejeitado.

import re

def find_v3_actions(html):
    """Extract all action parameters from page JavaScript."""
    # Look for grecaptcha.execute(key, {action: '...'})
    pattern = r"(?:grecaptcha\.(?:enterprise\.)?execute|action)\s*[(:]\s*['\"](\w+)"
    actions = re.findall(pattern, html)
    return list(set(actions))

# Common actions: "login", "submit", "register", "checkout", "homepage"

envio controlado ao endpoint QA

Mesma abordagem para ambas as versões:

# For browser-based workflows (Selenium)
driver.execute_script(
    f'document.getElementById("g-recaptcha-response").value = "{token}";'
)

# For pure HTTP workflows
requests.post(page_url, data={
    "g-recaptcha-response": token,
    "username": "user",
    "password": "pass"
})

// Puppeteer
await page.evaluate((tok) => {
  document.getElementById("g-recaptcha-response").value = tok;
}, token);

// Pure HTTP (axios)
await axios.post(pageUrl, new URLSearchParams({
  "g-recaptcha-response": token,
  username: "user",
  password: "pass",
}));

Perguntas frequentes

O Enterprise v3 oferece pontuações diferentes?

O modelo de pontuação é semelhante, mas o Enterprise pode usar sinais adicionais e limites personalizados. CaptchaAI lida com ambos de forma idêntica – o token retornado funciona independentemente do modelo que o Google usa.

Como detecto o Enterprise v3 em uma página?

Procure enterprise.js em vez de api.js na tag de script e grecaptcha.enterprise.execute() no JavaScript. Ambos são invisíveis, portanto não há diferença visual.

O Enterprise v3 é mais caro para resolver?

Verifique os preços atuais de CaptchaAI. As soluções empresariais podem ter preços diferentes, mas o esforço de integração da API é idêntico ao padrão.

E se eu não conseguir encontrar o parâmetro de ação?

Experimente valores comuns: "verify", "submit", "homepage", "login". Se o token ainda for rejeitado, use o DevTools do navegador para procurar execute( nos scripts da página e encontrar a sequência de ação exata.

Um site pode alternar entre padrão e empresarial sem aviso prévio?

Sim. Os sites podem migrar para o Enterprise a qualquer momento. Crie sua detecção para ser executada em cada carregamento de página, em vez de codificar a versão.

Guias relacionados

• reCAPTCHA v3 Enterprise vs Padrão— ângulo de comparação alternativo
• reCAPTCHA Enterprise vs Standard – Guia completo- cobre todas as versões
• Como resolver reCAPTCHA v3 usando API— tutorial v3 padrão
• Como resolver reCAPTCHA v3 Enterprise usando API— tutorial empresarial v3
• Parâmetro de ação reCAPTCHA v3 explicado— action parameter deep dive

Perguntas frequentes

Usar o sinalizador corporativo errado causará falhas?

Muitas vezes sim. Sites que usam Enterprise verificam tokens em relação à API Enterprise, que espera tokens Enterprise. Os tokens padrão podem falhar na verificação e vice-versa.

Como posso detectar o Enterprise v3 programaticamente?

Pesquise o código-fonte da página por enterprise.js:

page_source = driver.page_source
is_enterprise = "enterprise.js" in page_source

Existe uma diferença de desempenho?

Não. O tempo de resolução e as taxas de sucesso são semelhantes em ambas as versões.

Guias relacionados

• reCAPTCHA v3 Enterprise vs Padrão
• reCAPTCHA Enterprise vs Standard – Guia completo
• Como resolver reCAPTCHA v3 Enterprise usando API