reCAPTCHA v3 Enterprise vs Standard — Feature and Scoring Comparison

Both versions run invisibly and return a risk score between 0.0 (bot) and 1.0 (human). Enterprise adds reason codes, project-based management, adaptive thresholds, and account defender. For CaptchaAI users, the solving difference is a single parameter: enterprise=1.

This guide focuses on what matters for automation: what Enterprise adds, how to detect it, and how the scoring differences affect your integration.

Feature comparison

Feature	Standard v3	Enterprise v3
Invisible operation	Yes	Yes
Score (0.0–1.0)	Yes	Yes
Action parameter	Required	Required
Reason codes	No	Yes
Custom thresholds per action	No	Yes (via Cloud Console)
Password leak detection	No	Yes
Account defender	No	Yes
Fraud prevention labels	No	Yes
Multi-factor authentication integration	No	Yes
Verification endpoint	`siteverify` (free)	`recaptchaenterprise.googleapis.com`
Monthly quota	1M assessments free	Pay per assessment
JS file	`api.js?render=KEY`	`enterprise.js?render=KEY`
CaptchaAI params	`version=v3`	`version=v3` + `enterprise=1`

Enterprise reason codes explained

Enterprise responses include reason codes that explain why a score was assigned. These codes help site owners fine-tune their security — and understanding them helps you build better automation.

Code	Meaning	Impact on automation
`AUTOMATION`	Automated behavior detected	Use realistic browser fingerprints
`UNEXPECTED_ENVIRONMENT`	Unusual browser environment	Check headless browser detection
`TOO_MUCH_TRAFFIC`	High request volume from source	Implement rate limiting and proxy rotation
`UNEXPECTED_USAGE_PATTERNS`	Abnormal interaction patterns	Add realistic delays between actions
`LOW_CONFIDENCE_SCORE`	Insufficient data for confident scoring	Send more behavioral signals
`SUSPECTED_CARDING`	Credit card fraud patterns	Not relevant for most automation
`SUSPECTED_CHARGEBACK`	Chargeback fraud patterns	Not relevant for most automation

Note: You do not see these codes when solving through CaptchaAI. They are returned to the website's backend during token verification. Understanding them helps you diagnose why tokens might be rejected.

Enterprise scoring differences

Standard v3 uses a single global scoring model. Enterprise v3 adds layers:

Scoring aspect	Standard	Enterprise
Base score model	Google's global model	Google's global model + custom signals
Per-action thresholds	One threshold for all actions	Different thresholds per action (login=0.7, checkout=0.9)
Adaptive learning	Basic	Learns from site's specific traffic patterns
Score granularity	0.0-1.0 (two decimals)	Same range, more nuanced signals
False positive handling	Manual threshold tuning	Automatic with reason code analysis

What this means for CaptchaAI users: Enterprise sites may have stricter or more nuanced thresholds per action. Sending the correct action parameter is even more important with Enterprise because each action may have its own threshold.

Detection and solving

Detecting which version

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}

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],
  };
}

Solving 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

Solving Enterprise v3

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

Auto-detecting solver

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")

Troubleshooting

Problem	Likely cause	Fix
Token rejected on Enterprise site	Missing `enterprise=1`	Check for `enterprise.js` and add the flag
Low score on Enterprise	Wrong `action` parameter	Extract exact action from `grecaptcha.enterprise.execute()` call
Token works in testing, fails in production	Enterprise adaptive learning flagged your pattern	Rotate IPs, add delays, vary request patterns
`ERROR_WRONG_GOOGLEKEY`	v3 sitekey comes from render param, not data-sitekey	Look for `render=KEY` in the script URL

FAQ

Does Enterprise v3 give different scores than standard?

The base scoring model is similar, but Enterprise may use additional signals and custom per-action thresholds. A 0.7 on standard might pass, while Enterprise could require 0.9 for the same action. CaptchaAI handles both identically — the returned token quality is the same.

How do I detect Enterprise v3 on a page?

Look for enterprise.js instead of api.js in the script tags, and grecaptcha.enterprise.execute() in the JavaScript. Both versions are invisible — 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 code is identical except for one parameter.

Can a site switch from standard to enterprise?

Yes, and they often do. Google encourages migration to Enterprise for better analytics. Build your detection to check on every request rather than hardcoding the version.

Why did my score drop after the site migrated to Enterprise?

Enterprise uses adaptive learning that builds a model from the site's specific traffic. If your automation patterns stood out before, Enterprise may catch them faster. Improve fingerprinting beyond just CaptchaAI — add realistic browser behavior.