Skip to content
capzy
Login

reCAPTCHA v2

Connect the checkbox to your form submission. Find the public key on the checkbox or invisible widget, then pair it with the form page. The Google secret stays in your application's server validation.

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

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

Page URL + Google site keyProxyless or your own proxygRecaptchaResponse token

Find the checkbox's site key.

Find the public key on the checkbox or invisible widget, then pair it with the form page. The Google secret stays in your application's server validation.

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

Copy data-sitekey from the correct widget.

  1. Open the form, right-click the reCAPTCHA area, and choose Inspect. In Elements, search for g-recaptcha or data-sitekey.
  2. Copy the attribute value into websiteKey and the complete form URL into websiteURL. Check the parent form when several widgets are present.
  3. Read data-size. Set isInvisible: true only when this v2 integration uses invisible mode.
Input collection example - replace illustrative values
<div class="g-recaptcha"
  data-sitekey="YOUR_PUBLIC_SITE_KEY"
  data-size="normal">
</div>

The public site key identifies Google's widget. Your Capzy credential is the separate clientKey field.

Provider integration documentation
How reCAPTCHA v2 works

reCAPTCHA v2 presents a checkbox ('I'm not a robot') that users must click. If Google's risk engine is suspicious, it shows image grid challenges ('Select all images with traffic lights'). The invisible variant skips the checkbox and triggers programmatically. reCAPTCHA v2 is still widely used on login forms, registration pages, and anywhere Google's free captcha is deployed. reCAPTCHA v2 Enterprise is the same checkbox or invisible widget, loaded from /recaptcha/enterprise.js instead of /recaptcha/api.js. The token looks identical, but Google only accepts it for an Enterprise sitekey when it was minted through the Enterprise flow. Select the Enterprise variant on this page (ReCaptchaV2EnterpriseTaskProxyLess, or ReCaptchaV2EnterpriseTask with your proxy) whenever the page loads enterprise.js or calls grecaptcha.enterprise.render().

Capzy's proprietary solver returns valid reCAPTCHA v2 tokens for authorized testing and automation. Both checkbox and invisible modes are supported. Standard and Enterprise sitekeys use separate task types; pick the matching request variant below and the examples update to the right type.

  • Checkbox + image challenge solving
  • Invisible variant support (isInvisible: true)
  • Enterprise sitekeys via ReCaptchaV2EnterpriseTaskProxyLess / ReCaptchaV2EnterpriseTask
  • Capzy proprietary models handle every challenge type — no human workers
  • Capzy proprietary infrastructure — high-quality solves
  • ~8 second average solve time

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.

Standard v2. The page loads /recaptcha/api.js and renders a g-recaptcha element or calls grecaptcha.render(). Proxy mode sends ReCaptchaV2Task through your own exit.

Request authentication

Required task inputs

Optional context

websiteURL

stringRequired

The page URL where reCAPTCHA 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": "ReCaptchaV2TaskProxyLess",
    "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

    Read solution.gRecaptchaResponse and pass it through the form's g-recaptcha-response field or its existing response callback. Submit it promptly with the original form fields; your application's server performs Google validation.

ReCaptchaV2TaskProxyLess · $1.00 / 1,000
solve_recaptcha_v2.py
import json, os, time
import requests

API = "https://api.capzy.ai"
KEY = os.environ["CAPZY_API_KEY"]
task = json.loads("{\"type\":\"ReCaptchaV2TaskProxyLess\",\"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

Read solution.gRecaptchaResponse and pass it through the form's g-recaptcha-response field or its existing response callback. Submit it promptly with the original form fields; your application's server performs Google validation.

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

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

Use the result

Read solution.gRecaptchaResponse and pass it through the form's g-recaptcha-response field or its existing response callback. Submit it promptly with the original form fields; your application's server performs Google validation.

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.

Do you solve the image grid challenges?

Yes — Capzy's proprietary solver handles both audio and image challenges automatically. You don't need to choose.

What about invisible reCAPTCHA?

Set isInvisible: true in your task. We'll inject the widget in invisible mode and auto-execute it. Most invisible instances auto-pass without a challenge.

How do I use the token?

Set the value of the textarea named 'g-recaptcha-response' to the token, then submit the form. In JS: document.querySelector('textarea[name="g-recaptcha-response"]').value = token

How do I know if the site uses v2 Enterprise?

Check the script, not the widget. Enterprise pages load /recaptcha/enterprise.js and call grecaptcha.enterprise.render(); standard v2 pages load /recaptcha/api.js and call grecaptcha.render(). The checkbox looks identical in both cases, so open the page source or the Network panel.

How do I solve an Enterprise sitekey?

Select the Enterprise variant above and send ReCaptchaV2EnterpriseTaskProxyLess, or ReCaptchaV2EnterpriseTask with your own proxy. The parameters are the same as standard v2: websiteURL, websiteKey, and isInvisible when the widget is invisible. There is no isEnterprise flag; the task type is what switches the solver to enterprise.js.

My Enterprise token is rejected. What should I check?

First the task type: a standard v2 token never validates against an Enterprise sitekey, and an Enterprise token never validates against a standard one. Then confirm websiteURL is the exact page that hosts the widget and websiteKey is that widget's sitekey. Enterprise risk analysis also weighs the submitting IP more than standard v2, so when you submit from a different IP than the solve, use ReCaptchaV2EnterpriseTask with the same proxy for both.

Connect reCAPTCHA v2 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
9.4sAverage solve time

ReCaptchaV2TaskProxyLess · Live configuration