What score will I get?

Score is decided by Google's backend when your server calls siteverify. The biggest driver is the IP that fetches /recaptcha/api2/* — our shared proxyless pool typically scores 0.3-0.5; for 0.7-0.9 use ReCaptchaV3Task with your own residential or mobile proxy. We can't guarantee a specific score because we never see what Google returns to your siteverify call.

Do I need to provide the pageAction?

It's recommended. The pageAction must match what the site's JavaScript passes to grecaptcha.execute(). If it doesn't match, the score will be lower.

What's the difference between v3 and v3 Enterprise?

reCAPTCHA v3 Enterprise uses a different API endpoint and may include additional risk signals. Set isEnterprise: true if the site loads from recaptcha/enterprise.js.

Can I report my verified score back to you?

Yes — call POST /reportScore with the score Google returned from siteverify. It's optional, never affects pricing, and powers the V3 quality dashboard so you can see your score distribution over time.

How do I find the sitekey?

Search the page source for 'data-sitekey', 'sitekey', or the pattern starting with '6L'. It's also visible in network requests to google.com/recaptcha.

Can I use this with Selenium/Puppeteer?

Yes. Create the task via our API, get the token, then inject it into the page using document.getElementById('g-recaptcha-response').value = token.

Is there a rate limit?

No hard rate limit. Our infrastructure auto-scales. You can send thousands of concurrent tasks.

reCAPTCHA v3 Solver — Fast Proxyless API for Scraping & Automation

Before you submit — these must be correct

If any of these are wrong, your token may be accepted by our solver but rejected or scored poorly by the target site. We can’t detect these mismatches for you.

pageAction must match the site's real action. Google scores the token against the action you request — if the site calls grecaptcha.execute(sitekey, {action: 'login'}) and you send pageAction: 'verify', the score will drop. Inspect the site's JS for the exact string. We default to 'verify' only when none is provided.
websiteURL must be the exact page URL where reCAPTCHA loads. Domain-only URLs or wrong paths cause invalid tokens — use the full URL of the page that contains the widget.
Proxy quality is the #1 factor in your score. Google evaluates the IP that fetches /recaptcha/api2/*. Shared proxyless pools (including ours and every other provider) produce lower scores than a dedicated residential or mobile IP you supply yourself. For 0.7-0.9 scores on strict sitekeys, use ReCaptchaV3Task with your own residential or mobile proxy.
isEnterprise must match the site. Enterprise v3 uses a different bundle (enterprise.js) and scoring endpoint. Setting it wrong will produce an invalid token.

What is reCAPTCHA v3?

reCAPTCHA v3 is Google's invisible captcha that runs in the background without user interaction. Instead of showing a challenge, it analyzes user behavior and returns a risk score between 0.0 (bot) and 1.0 (human). Websites set a threshold (typically 0.3-0.7) and block requests below it. Unlike v2, there's no checkbox or image puzzle — the captcha is completely invisible. This makes it harder to detect but also harder to bypass, since you need to produce a token that results in a high enough score.

How it works

Send Task

POST your ReCaptchaV3TaskProxyLess with the target URL and sitekey to our API. We'll queue it instantly.

We Solve

Capzy's proprietary solver returns valid reCAPTCHA v3 tokens. The final score is set by Google when your backend calls siteverify and depends heavily on the IP that makes the request — for the highest scores use ReCaptchaV3Task with your own proxy.

Get Token

Poll getTaskResult — when status is 'ready', the solution contains the token to inject into the target page.

Quick integration

solve.py

import requests, time

API = "https://api.capzy.ai"
KEY = "capzy_your_key_here"

# Step 1: Create task
task = requests.post(f"{API}/createTask", json={
    "clientKey": KEY,
    "task": {
        "type": "ReCaptchaV3TaskProxyLess",
        "pageAction": "login",
        "websiteKey": "6LcR_RsTAAAAADHmXXPJh-Lr7Mz4aCezAo3vKWiq",
        "websiteURL": "https://example.com/login"
    }
}).json()

task_id = task["taskId"]
print(f"Task created: {task_id}")

# Step 2: Poll for result
while True:
    result = requests.post(f"{API}/getTaskResult", json={
        "clientKey": KEY,
        "taskId": task_id
    }).json()

    if result["status"] == "ready":
        print("Solved!", result["solution"])
        break
    elif result["status"] == "failed":
        print("Failed:", result.get("errorDescription"))
        break

    time.sleep(1)

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

Using your own proxy

Use ReCaptchaV3Task instead of ReCaptchaV3TaskProxyLess to route the solve through your own proxy. This is useful when the target site checks the IP that solved the captcha matches the IP submitting the form.

solve_proxy.py

import requests, time

API = "https://api.capzy.ai"
KEY = "capzy_your_key_here"

# Step 1: Create task
task = requests.post(f"{API}/createTask", json={
    "clientKey": KEY,
    "task": {
        "type": "ReCaptchaV3Task",
        "proxyPort": "8080",
        "proxyType": "http",
        "pageAction": "login",
        "proxyLogin": "user",
        "websiteKey": "6LcR_RsTAAAAADHmXXPJh-Lr7Mz4aCezAo3vKWiq",
        "websiteURL": "https://example.com/login",
        "proxyAddress": "123.45.67.89",
        "proxyPassword": "pass"
    }
}).json()

task_id = task["taskId"]
print(f"Task created: {task_id}")

# Step 2: Poll for result
while True:
    result = requests.post(f"{API}/getTaskResult", json={
        "clientKey": KEY,
        "taskId": task_id
    }).json()

    if result["status"] == "ready":
        print("Solved!", result["solution"])
        break
    elif result["status"] == "failed":
        print("Failed:", result.get("errorDescription"))
        break

    time.sleep(1)

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

additional proxy parameters

fieldtyperequireddescription

proxyTypetypestringreqyesProxy protocol: http or https

proxyAddresstypestringreqyesProxy IP address or hostname

proxyPorttypenumberreqyesProxy port number

proxyLogintypestringreqnoProxy username (if auth required)

proxyPasswordtypestringreqnoProxy password (if auth required)

userAgenttypestringreqnoUser-Agent string to use. Must match the UA you use when submitting the token

Task parameters

fieldtyperequireddescription

typetypestringreqyesReCaptchaV3TaskProxyLess or ReCaptchaV3Task

websiteURLtypestringreqyesThe URL of the page where reCAPTCHA v3 is loaded

websiteKeytypestringreqyesThe sitekey found in the page source (starts with 6L...)

pageActiontypestringreqnoThe action parameter passed to grecaptcha.execute(). Found in the site's JS code

isEnterprisetypebooleanreqnoSet true if the site uses reCAPTCHA Enterprise

Solution response

fieldtypedescription

gRecaptchaResponsetypestringThe solved token — submit this in the g-recaptcha-response field or the callback parameter

userAgenttypestringThe 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.

expireTimetypenumberUnix milliseconds when the token expires (issued time + 120s — Google v3 tokens have a 2-minute lifetime).

Example response

Full getTaskResult response shape. The fields in the table above describe what's inside solution — the outer envelope (errorId, status) is identical for every captcha type.

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "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,
    "gRecaptchaResponse": "03AGdBq25...<long v3 token, 2-minute lifetime>..."
  }
}

Error response

Failures use the same envelope with errorId: 1 plus errorCode + errorDescription. See the error-code reference for the full list.

{
  "errorId": 1,
  "errorCode": "ERROR_CAPTCHA_UNSOLVABLE",
  "errorDescription": "Solver gave up — automatically refunded."
}

Pending response

While the solver is still working, getTaskResult returns status: "processing". Poll every 1–2 seconds until ready or failed.

{
  "errorId": 0,
  "status": "processing"
}

Features

AI-powered — no human workers needed

Flat $0.0015 per solve — no hidden tiers

Optional /reportScore feedback loop — share Google's verified score and see your quality on the dashboard

Enterprise support — works with reCAPTCHA Enterprise

Fast — average 8-9 second solve time

pageAction support — matches the site's expected action

99.9% uptime — redundant solver infrastructure

task types

proxyless: ReCaptchaV3TaskProxyLess

with proxy: ReCaptchaV3Task

reCAPTCHA v3 Solver, solved in 3.0s.