reCAPTCHA v3

The task is executed through our own proxy servers. There are no additional costs for proxies — their usage is already included in the service price.

This section describes the task for solving Google reCAPTCHA v3.

reCAPTCHA v3 operates entirely in the background and does not require any user interaction. The system analyzes behavioral and technical signals of the page visitor and generates a risk score for each request. Based on this data, the website decides whether to allow the action using a trust score, which typically ranges from 0.1 to 0.9.

When creating a task, it is recommended to provide two parameters: pageAction and minScore.

Task Type

Task Type	Description
`RecaptchaV3TaskProxyless`	Solve without proxy (uses built-in proxies)

Request Parameters

Parameter	Type	Required	Description
`type`	String	Required	`RecaptchaV3TaskProxyless`
`websiteURL`	String	Required	Address of a webpage with Google ReCaptcha.
`websiteKey`	String	Required	Recaptcha website key. `https://www.google.com/recaptcha/api.js?render=THIS_ONE`
`isEnterprise`	Boolean	Optional	reCAPTCHA version. Supported values: `true` / `false` (also `1` / `0`). Set `true` if you need to solve the reCAPTCHA as Enterprise.
`minScore`	Double	Optional	Value from 0.1 to 0.9.
`pageAction`	String	Optional	Widget action value. Website owner defines what user is doing on the page through this parameter. Default value: verify. Example: `grecaptcha.execute('site_key', {action:'login_test'})`.

Create Task

Request

POST https://captcha69.com/createTask
Content-Type: application/json

{
  "clientKey": "max1_YOUR_API_KEY",
  "task": {
    "type": "RecaptchaV3TaskProxyless",
    "websiteURL": "https://example.com/captcha-page",
    "websiteKey": "6Le0xVgUAAAAAIt20XEB4rVhYOODgTl00d8juDob",
    "isEnterprise": false,
    "minScore": 0.7,
    "pageAction": "myverify"
  }
}

Response

{
  "errorId": 0,
  "taskId": 407533072
}

Get Task Result

Warning! On some websites, it is important that the UserAgent matches the one used when solving the captcha. Therefore, if a UserAgent is returned along with the token, always apply it when submitting the form or confirming the solution on the target page.

Request

POST https://captcha69.com/getTaskResult
Content-Type: application/json

{
  "clientKey": "max1_YOUR_API_KEY",
  "taskId": 407533072
}

Response

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "gRecaptchaResponse": "3AHJ_VuvYIBNBW5yyv0zRYJ75VkOKvhKj9_xGBJKnQimF72rfoq3Iy-DyGHMwLAo6a3"
  }
}

For some websites, the response may include userAgent and cookies:

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 ...",
    "gRecaptchaResponse": "0cAFcWeA5Y3...hF8UWA",
    "cookies": {
      "nocookies": "true"
    }
  }
}

Solution Properties

Property	Type	Description
`gRecaptchaResponse`	String	Hash which should be inserted into Recaptcha3 submit form in `<textarea id="g-recaptcha-response"></textarea>`. It has a length of 500 to 2190 bytes.

Finding Parameters

websiteKey

The public site key (sitekey). Usually, it can be found in the included script:

In Elements:

In the Network tab:

pageAction

The action name passed to grecaptcha.execute().

Code Examples

JavaScript (Browser) - Extract Parameters

(() => {
    const originalGrecaptcha = window.grecaptcha;

    if (!originalGrecaptcha || !originalGrecaptcha.execute) {
        console.warn("grecaptcha.execute not found. Wait until it loads.");
        return;
    }

    window.__extractedParams = null;

    window.grecaptcha = {
        ...originalGrecaptcha,
        execute: function(sitekey, config) {
            console.log("Captured!");
            console.log("sitekey:", sitekey);
            console.log("action:", config?.action);
            window.__extractedParams = {
                sitekey,
                action: config?.action
            };

            return originalGrecaptcha.execute(sitekey, config);
        },
        ready: originalGrecaptcha.ready
    };

    console.log("grecaptcha.execute is wrapped. Click the button - parameters will be captured.");
})();

JavaScript (Node.js) - Extract Parameters

import { chromium } from "playwright";

(async () => {
  const browser = await chromium.launch({ headless: false });
  const context = await browser.newContext();
  const page = await context.newPage();

  const jsContents = [];

  page.on("response", async (response) => {
    try {
      const url = response.url();
      const ct = response.headers()["content-type"] || "";
      if (ct.includes("javascript") || url.endsWith(".js")) {
        const text = await response.text();
        jsContents.push(text);
      }
    } catch (e) {}
  });

  const targetUrl = "https://example.com/captcha-page";
  await page.goto(targetUrl, { timeout: 60000 });
  await page.waitForTimeout(3000);

  const inlineScripts = await page.$$eval("script:not([src])", (scripts) =>
    scripts.map((s) => s.textContent)
  );
  jsContents.push(...inlineScripts);

  const executeRegex =
    /grecaptcha\.execute\(\s*['"](?<sitekey>[^'"]+)['"]\s*,\s*\{[^}]*action\s*:\s*['"](?<action>[^'"]+)['"]/i;

  let foundSitekey = null;
  let foundAction = null;

  for (const js of jsContents) {
    const match = js.match(executeRegex);
    if (match && match.groups) {
      foundSitekey = match.groups.sitekey;
      foundAction = match.groups.action;
      break;
    }
  }

  console.log({
    sitekey: foundSitekey,
    action: foundAction,
  });

  await browser.close();
})();

Python - Extract Parameters

import asyncio
import re
from playwright.async_api import async_playwright

async def extract_recaptcha_v3_execute(url):
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=False)
        context = await browser.new_context()
        page = await context.new_page()

        execute_pattern = re.compile(
            r"grecaptcha\.execute\(\s*['\"]"
            r"(?P<sitekey>[^'\"]+)['\"]\s*,\s*\{[^}]*action\s*:\s*['\"](?P<action>[^'\"]+)['\"]",
            re.IGNORECASE
        )

        found_sitekey = None
        found_action = None
        js_contents = []

        async def handle_response(response):
            try:
                ct = response.headers.get("content-type", "")
                if "javascript" in ct or response.url.endswith(".js"):
                    text = await response.text()
                    js_contents.append(text)
            except:
                pass

        page.on("response", handle_response)

        await page.goto(url, timeout=60000)
        await page.wait_for_timeout(3000)

        inline_scripts = await page.locator("script:not([src])").all_text_contents()
        js_contents += inline_scripts

        for js in js_contents:
            match = execute_pattern.search(js)
            if match:
                found_sitekey = match.group("sitekey")
                found_action = match.group("action")
                break

        await browser.close()

        print({
            "sitekey": found_sitekey,
            "action": found_action
        })

asyncio.run(extract_recaptcha_v3_execute("https://example.com/captcha-page"))