Skip to content

reCAPTCHA v3 Enterprise

Keep Enterprise scoring tied to the right action. Use the Enterprise execution key, action, and any additional options from the current page. Keep the assessment tied to the action that requested it.

POST /createTask · example
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "ReCaptchaV3EnterpriseTaskProxyLess",
    "websiteURL": "https://example.com/login",
    "websiteKey": "6LcR_RsTAAAAADHmXXPJh-Lr7Mz4aCezAo3vKWiq",
    "pageAction": "login"
  }
}

Illustrative values. Replace the inputs with values from your current integration.

Enterprise key + action + contextProxyless or your own proxyResponse token + browser identity

Capture the Enterprise execution context.

Use the Enterprise execution key, action, and any additional options from the current page. Keep the assessment tied to the action that requested it.

Your API key authenticates Capzy.
Provider keys, challenge IDs, images, and session values belong inside task.

Copy the Enterprise key and action together.

  1. In Network, find enterprise.js and inspect its render query. In Sources, search for grecaptcha.enterprise.execute.
  2. Find the execute call for the current action. Copy the first argument into websiteKey and options.action into pageAction.
  3. Copy the complete page URL into websiteURL and its document.title into websiteTitle when providing page identity.
Input collection example - replace illustrative values
grecaptcha.enterprise.execute("YOUR_ENTERPRISE_SITE_KEY", {
  action: "login"
}).then(onCaptchaComplete);

Keep pageAction identical to the value used by your application's Enterprise assessment.

Provider integration documentation
How reCAPTCHA v3 Enterprise works

reCAPTCHA v3 Enterprise is Google's paid tier of v3 — same invisible scoring model (0.0 bot to 1.0 human), same grecaptcha.execute() API, but loads from /recaptcha/enterprise.js and includes additional risk signals that Google only exposes to Enterprise customers. If a site's JavaScript loads enterprise.js or the sitekey was registered as Enterprise in Google's admin console, standard v3 tokens will not verify — you need the Enterprise task type.

Capzy's proprietary solver returns valid reCAPTCHA v3 Enterprise tokens. Same operational guarantees as standard v3 — score depends on the requesting IP, so use the Task variant with your own proxy when score sensitivity matters.

  • Enterprise-specific bundle (enterprise.js)
  • Correct grecaptcha.enterprise.execute() invocation
  • pageAction support — stricter matching than standard v3
  • Bring your own proxy on the Task variant
  • Drop-in compatible with Google Enterprise siteverify

Know what goes in.

Choose a field to see its purpose, where to get it, and its place in the request. Optional values omitted from the example can be added when your flow uses them.

The common case: the page calls grecaptcha.enterprise.execute(SITEKEY, { action }). Copy the action into pageAction exactly. Proxy mode sends ReCaptchaV3EnterpriseTask through your own exit, which is the best lever for a higher score.

Request authentication

Required task inputs

Optional context

websiteURL

stringRequired

The URL of the page where reCAPTCHA v3 Enterprise is loaded

Where it comes from

Copy the full page URL from the address bar or the document request in Network, including the path where this flow runs.

Open the input guide
Example valuehttps://example.com/login
POST /createTask · selected configuration
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "ReCaptchaV3EnterpriseTaskProxyLess",
    "websiteURL": "https://example.com/login",
    "websiteKey": "6LcR_RsTAAAAADHmXXPJh-Lr7Mz4aCezAo3vKWiq",
    "pageAction": "login"
  }
}

The selected field is highlighted when present. Preserve the declared value type and current challenge context.

Make your first request.

Create the task, keep its taskId, and poll until status is ready. Then read the selected variant's solution.

More examples
  1. Create the task

    Send clientKey and the selected task to /createTask from your server. Keep the returned taskId.

  2. Wait for the solution

    Send that same key and ID to /getTaskResult. While processing, wait two seconds before checking again. Stop on Ready or an error.

  3. Apply the result

    Send solution.gRecaptchaResponse through the original action's token transport. Your Enterprise assessment should check validity, expected action, and risk results before accepting the action. Preserve returned identity and expiration metadata when provided.

solve_recaptcha_v3_enterprise.py
import json, os, time
import requests

API = "https://api.capzy.ai"
KEY = os.environ["CAPZY_API_KEY"]
task = json.loads("{\"type\":\"ReCaptchaV3EnterpriseTaskProxyLess\",\"websiteURL\":\"https://example.com/login\",\"websiteKey\":\"6LcR_RsTAAAAADHmXXPJh-Lr7Mz4aCezAo3vKWiq\",\"pageAction\":\"login\"}")

def call(path, payload):
    response = requests.post(f"{API}/{path}", json={"clientKey": KEY, **payload}, timeout=30)
    response.raise_for_status()
    data = response.json()
    if data.get("errorId", 0) or data.get("status") == "failed":
        raise RuntimeError(data.get("errorDescription") or data.get("errorCode") or "Task failed")
    return data

created = call("createTask", {"task": task})
for attempt in range(60):
    result = call("getTaskResult", {"taskId": created["taskId"]})
    if result.get("status") == "ready":
        solution = result["solution"]
        print(solution)
        break
    time.sleep(2)
else:
    raise TimeoutError("Task is still processing; keep the taskId to check it later.")

Before runningReplace all illustrative inputs with your captured values. Set CAPZY_API_KEY in your environment. Install requests with pip install requests.

Polling and failuresThe example checks HTTP/API failures, uses 30-second request timeouts, and stops after 60 result checks. Retain taskId if your task is still processing.

Understand what comes back.

Follow this task from creation to completion. Response fields and usage follow your selected request variant.

Response token + browser identity

Send solution.gRecaptchaResponse through the original action's token transport. Your Enterprise assessment should check validity, expected action, and risk results before accepting the action. Preserve returned identity and expiration metadata when provided.

string
The solved Enterprise token — submit to your Enterprise siteverify endpoint
string
The User-Agent string the solver used to mint the token. Submit it from the same UA on your backend if Google's siteverify enforces UA binding.
number
Unix milliseconds when the token expires (issued time + 120s).
POST /getTaskResult · example response
{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "gRecaptchaResponse": "03AGdBq25...<long Enterprise v3 token>...",
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/131.0.0.0 Safari/537.36",
    "expireTime": 1735689720000
  }
}

Illustrative values. Additional metadata may be returned; only Ready contains a completed solution.

Use the result

Send solution.gRecaptchaResponse through the original action's token transport. Your Enterprise assessment should check validity, expected action, and risk results before accepting the action. Preserve returned identity and expiration metadata when provided.

Execution context result is the parsed Ready response from the polling example. session, when referenced, is your existing requests.Session (or browser-compatible session) with the original cookie jar, headers, and solving proxy configured in session.proxies for both http and https. Keep this client for the complete flow. task is the task object you submitted. For Shape, action_body is the original protected request body as bytes or a string, with its original Content-Type in session.headers. Install curl_cffi when the fragment imports it; match the target's required browser/TLS identity.

Use the result · Python

# Step 3: Use the result — paste the token into g-recaptcha-response
token = result["solution"]["gRecaptchaResponse"]
# Browser side: document.querySelector('textarea[name="g-recaptcha-response"]').value = token
# Or include it in your form POST:
resp = requests.post("https://target.example.com/login", data={
    "username": "...",
    "password": "...",
    "g-recaptcha-response": token,
})
print(resp.status_code)

When something doesn't work.

Check your captured values, the selected variant, and the response before starting another task.

How do I know a site is Enterprise vs. standard v3?

Look at the script tag: /recaptcha/enterprise.js = Enterprise, /recaptcha/api.js = standard. Also, sites using Enterprise usually call grecaptcha.enterprise.execute() instead of grecaptcha.execute().

Is there an isEnterprise flag?

No. The task type is the only switch. ReCaptchaV3EnterpriseTaskProxyLess and ReCaptchaV3EnterpriseTask load enterprise.js and call grecaptcha.enterprise.execute(); the standard ReCaptchaV3 types load api.js. Send the Enterprise type with the normal websiteURL, websiteKey and pageAction.

When do I need enterprisePayload?

Only when the site's grecaptcha.enterprise.execute() call passes options besides action. The most common one is an s token, for example execute(SITEKEY, { action: 'login', s: '...' }). Copy that object without the action into enterprisePayload exactly as the page supplies it. Omit it when the site passes only the action.

Will my score be different from standard v3?

Enterprise risk analysis can be stricter on flagged IPs and browser signals. Expect slightly lower scores than standard v3 on the same IP — the same as a real user would experience.

Integration checks for reCAPTCHA v3 Enterprise
  • pageAction must match the site's real action. Enterprise sitekeys are stricter than standard v3 about action mismatches — use the exact string the site's JS passes to grecaptcha.enterprise.execute().
  • websiteURL must be the exact page URL where reCAPTCHA Enterprise loads. Domain-only URLs or wrong paths produce invalid tokens.
  • Proxy quality is the #1 factor in your score. Google's Enterprise risk analysis is harsher on flagged IPs than standard v3 — a high-reputation IP from your own provider will always score higher than the ProxyLess path.
  • Don't use the standard ReCaptchaV3Task type — Enterprise sitekeys require the Enterprise task type (ReCaptchaV3EnterpriseTask or ReCaptchaV3EnterpriseTaskProxyLess). Using the wrong type produces a token Google rejects.

Connect reCAPTCHA v3 Enterprise to your workflow.

Get your Capzy API key and use this guide's integration.

$3.00Per 1,000 solves
10.1sAverage solve time

ReCaptchaV3EnterpriseTaskProxyLess · Live configuration