Skip to content
capzy
Login

reCAPTCHA v2 Enterprise

A checkbox token for your Enterprise integration. Confirm that the page uses the Enterprise checkbox SDK, then collect its public key and visible or invisible setting.

Get the integration code
POST /createTask · example
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "ReCaptchaV2EnterpriseTaskProxyLess",
    "websiteURL": "https://example.com/signup",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
  }
}

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

Enterprise widget URL + site keyProxyless or your own proxygRecaptchaResponse token

Check the Enterprise widget configuration.

Confirm that the page uses the Enterprise checkbox SDK, then collect its public key and visible or invisible setting.

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

Match enterprise.js to the checkbox configuration.

  1. In Network, filter for enterprise.js and confirm it is loaded by the form page.
  2. In Elements, find the g-recaptcha container and copy data-sitekey into websiteKey. Copy the page's complete URL into websiteURL.
  3. Read data-size or the widget options. Set isInvisible only if the current Enterprise widget is invisible.
Input collection example - replace illustrative values
<script src="https://www.google.com/recaptcha/enterprise.js" async defer></script>
<div class="g-recaptcha" data-sitekey="YOUR_ENTERPRISE_SITE_KEY"></div>

Use the public checkbox site key configured for this Enterprise integration.

Provider integration documentation
How reCAPTCHA v2 Enterprise works

reCAPTCHA v2 Enterprise is Google's paid upgrade to v2. It loads from /recaptcha/enterprise.js instead of /recaptcha/api.js and runs the same checkbox/image-challenge UX, but layers on additional behavioral and reputation signals that Google only exposes to Enterprise customers. The token format is identical; what changes is how strict the server-side risk analysis is when the site verifies the token. If a site's HTML loads enterprise.js or the sitekey was registered as an Enterprise key in Google's admin console, you need the Enterprise task type — standard v2 tokens won't pass validation.

Capzy's proprietary solver returns valid reCAPTCHA v2 Enterprise tokens. Same operational guarantees as standard v2 — checkbox + invisible modes, refunds on failure, designed for authorized testing.

  • Enterprise-specific script loading (enterprise.js)
  • Checkbox + image challenge solving — fully automated
  • Invisible variant support
  • Same ~8s solve time as standard v2
  • Drop-in compatible with Google's Enterprise siteverify endpoint

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.

Enterprise checkbox widget: the page loads /recaptcha/enterprise.js and renders a g-recaptcha element or calls grecaptcha.enterprise.render() with size: normal. Proxy mode sends ReCaptchaV2EnterpriseTask through your own exit.

Request authentication

Required task inputs

Optional context

websiteURL

stringRequired

The page URL where reCAPTCHA v2 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/signup
POST /createTask · selected configuration
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "ReCaptchaV2EnterpriseTaskProxyLess",
    "websiteURL": "https://example.com/signup",
    "websiteKey": "6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-"
  }
}

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

    Use solution.gRecaptchaResponse in the Enterprise checkbox form/callback flow. Your backend sends the returned token to its existing Enterprise assessment logic and checks acceptance there.

ReCaptchaV2EnterpriseTaskProxyLess · $1.00 / 1,000
solve_recaptcha_v2_enterprise.py
import json, os, time
import requests

API = "https://api.capzy.ai"
KEY = os.environ["CAPZY_API_KEY"]
task = json.loads("{\"type\":\"ReCaptchaV2EnterpriseTaskProxyLess\",\"websiteURL\":\"https://example.com/signup\",\"websiteKey\":\"6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-\"}")

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.

gRecaptchaResponse token

Use solution.gRecaptchaResponse in the Enterprise checkbox form/callback flow. Your backend sends the returned token to its existing Enterprise assessment logic and checks acceptance there.

string
The solved Enterprise token. Submit in g-recaptcha-response textarea
POST /getTaskResult · example response
{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "gRecaptchaResponse": "03AGdBq25...<long Enterprise token>..."
  }
}

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

Use the result

Use solution.gRecaptchaResponse in the Enterprise checkbox form/callback flow. Your backend sends the returned token to its existing Enterprise assessment logic and checks acceptance there.

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 if a site is using Enterprise?

Look at the script tag in the page source — if it loads /recaptcha/enterprise.js instead of /recaptcha/api.js, it's Enterprise. Standard v2 tokens will not validate against Enterprise sitekeys.

Can I use the standard v2 task type for Enterprise?

No. Enterprise sitekeys require ReCaptchaV2EnterpriseTaskProxyLess or ReCaptchaV2EnterpriseTask. There is no isEnterprise flag on the standard task; the task type alone switches the solver to enterprise.js. Using the standard type produces a token Google rejects.

Does isInvisible work with Enterprise?

Yes. Set isInvisible: true on the Enterprise task; we'll load enterprise.js and execute programmatically the same way.

Connect reCAPTCHA v2 Enterprise to your workflow.

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

Get an API key Full API documentation
$1.00Per 1,000 solves
10.2sAverage solve time

ReCaptchaV2EnterpriseTaskProxyLess · Live configuration