Standard vs Enterprise reCAPTCHA v3 Solving Guide

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.

Feature comparison

How to detect which version a site uses

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

Python detection:

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://example.com/login")
print(info)

Node.js detection:

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);
}

Solving with CaptchaAI

Standard 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

Enterprise 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://example.com/login", action="login")
print(f"Token: {token[:40]}...")

Common mistakes

Extracting the action parameter

The action parameter is critical for v3 — both standard and enterprise. If you send the wrong action, the score will be low and the token may be rejected.

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"

Token injection

Same approach for both versions:

# 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",
}));

FAQ

Does Enterprise v3 give different scores?

The scoring model is similar, but Enterprise may use additional signals and custom thresholds. CaptchaAI handles both identically — the returned token works regardless of which model Google uses.

How do I detect Enterprise v3 on a page?

Look for enterprise.js instead of api.js in the script tag, and grecaptcha.enterprise.execute() in the JavaScript. Both are invisible, so there is no visual difference.

Is Enterprise v3 more expensive to solve?

Check CaptchaAI's current pricing. Enterprise solves may be priced differently, but the API integration effort is identical to standard.

What if I cannot find the action parameter?

Try common values: "verify", "submit", "homepage", "login". If the token is still rejected, use browser DevTools to search for execute( in the page scripts and find the exact action string.

Can a site switch between standard and enterprise without notice?

Yes. Sites can migrate to Enterprise at any time. Build your detection to run on every page load rather than hardcoding the version.

Related guides

• reCAPTCHA v3 Enterprise vs Standard — alternative comparison angle
• reCAPTCHA Enterprise vs Standard — Complete Guide — covers all versions
• How to Solve reCAPTCHA v3 Using API — standard v3 tutorial
• How to Solve reCAPTCHA v3 Enterprise Using API — enterprise v3 tutorial
• reCAPTCHA v3 Action Parameter Explained — action parameter deep dive

FAQ

Will using the wrong enterprise flag cause failures?

Often yes. Sites that use Enterprise verify tokens against the Enterprise API, which expects Enterprise tokens. Standard tokens may fail verification, and vice versa.

How do I detect Enterprise v3 programmatically?

Search the page source for enterprise.js:

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

Is there a performance difference?

No. Solving time and success rates are similar for both versions.

Related guides

• reCAPTCHA v3 Enterprise vs Standard
• reCAPTCHA Enterprise vs Standard — Complete Guide
• How to Solve reCAPTCHA v3 Enterprise Using API