Google reCAPTCHA v3 Enterprise

Google reCAPTCHA Enterprise is the business-grade iteration of reCAPTCHA v3, offering enhanced risk analysis, granular scoring, and deeper integration with Google Cloud security infrastructure.

SolverCF solves reCAPTCHA v3 Enterprise transparently using specialized browser automation.

Task Types

RecaptchaV3EnterpriseTaskProxyless (Recommended): Automatically routes solving through SolverCF's high-reputation network.
RecaptchaV3EnterpriseTask: Uses your own specified proxy.

Task Object Parameters

Field	Type	Required	Description
`type`	string	Yes	`"RecaptchaV3EnterpriseTaskProxyless"` or `"RecaptchaV3EnterpriseTask"`.
`websiteUrl`	string	Yes	The full URL of the page where reCAPTCHA v3 Enterprise is rendered (`https://...`).
`websiteKey`	string	Yes	The Enterprise site key extracted from the target page.
`pageAction`	string	No	The action parameter passed to `grecaptcha.enterprise.execute()` (e.g. `"login"`, `"checkout"`).
`minScore`	number	No	Minimum acceptable score (`0.1` to `0.9`). Defaults to high score (`0.7`–`0.9`).
`proxy`	string	Required for `EnterpriseTask`	Your proxy in `host:port` or `host:port:user:pass` format.
`userAgent`	string	No	Specific browser User-Agent to solve with.

Identifying Enterprise vs Standard v3

Inspect the page source to check if the target site uses Enterprise:

Look for enterprise.js in the script tags:

Html

<script src="https://www.google.com/recaptcha/enterprise.js?render=6Ld_XYZ_EnterpriseKey"></script>

Or check for calls to grecaptcha.enterprise:

JavaScript

grecaptcha.enterprise.execute('6Ld_XYZ_EnterpriseKey', { action: 'login' })
  .then(function(token) { ... });

API Workflow

Step 1: Create Task

Send a POST request to https://solvercf.com/token/extension/createTask:

JSON

{
  "clientKey": "YOUR_CLIENT_KEY",
  "task": {
    "type": "RecaptchaV3EnterpriseTaskProxyless",
    "websiteUrl": "https://example.com/checkout",
    "websiteKey": "6Ld_XYZ_EnterpriseKey",
    "pageAction": "checkout",
    "minScore": 0.7
  }
}

Response:

JSON

{
  "errorId": 0,
  "taskId": "e1f2a3b4-c5d6-7e8f-9a0b-1c2d3e4f5a6b",
  "status": "created"
}

Step 2: Poll Task Result

Send periodic POST requests (every 1.5s) to https://solvercf.com/token/extension/getTaskResult:

JSON

{
  "clientKey": "YOUR_CLIENT_KEY",
  "taskId": "e1f2a3b4-c5d6-7e8f-9a0b-1c2d3e4f5a6b"
}

When solved, status becomes "ready":

JSON

{
  "errorId": 0,
  "taskId": "e1f2a3b4-c5d6-7e8f-9a0b-1c2d3e4f5a6b",
  "status": "ready",
  "cost": 0.0009,
  "solution": {
    "type": "RecaptchaV3EnterpriseTaskProxyless",
    "token": "03AFcWeA8...",
    "gRecaptchaResponse": "03AFcWeA8...",
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36"
  }
}

Complete Code Examples

cURL

Step 1: Create Task

cURL

curl -X POST https://solvercf.com/token/extension/createTask \
  -H "Content-Type: application/json" \
  -d '{
    "clientKey": "YOUR_CLIENT_KEY",
    "task": {
      "type": "RecaptchaV3EnterpriseTaskProxyless",
      "websiteUrl": "https://example.com/checkout",
      "websiteKey": "6Ld_XYZ_EnterpriseKey",
      "pageAction": "checkout",
      "minScore": 0.7
    }
  }'

Step 2: Get Task Result

cURL

curl -X POST https://solvercf.com/token/extension/getTaskResult \
  -H "Content-Type: application/json" \
  -d '{
    "clientKey": "YOUR_CLIENT_KEY",
    "taskId": "YOUR_TASK_ID_FROM_STEP_1"
  }'

Python

import time
import requests

CLIENT_KEY = "YOUR_CLIENT_KEY"
WEBSITE_URL = "https://example.com/checkout"
WEBSITE_KEY = "6Ld_XYZ_EnterpriseKey"

def solve_recaptcha_v3_enterprise(client_key: str, website_url: str, website_key: str, page_action: str = "checkout", min_score: float = 0.7, proxy: str = None):
    # 1. Create task
    task_type = "RecaptchaV3EnterpriseTask" if proxy else "RecaptchaV3EnterpriseTaskProxyless"
    payload = {
        "clientKey": client_key,
        "task": {
            "type": task_type,
            "websiteUrl": website_url,
            "websiteKey": website_key,
            "pageAction": page_action,
            "minScore": min_score
        }
    }
    if proxy:
        payload["task"]["proxy"] = proxy

    create_resp = requests.post("https://solvercf.com/token/extension/createTask", json=payload).json()
    if create_resp.get("errorId") == 1:
        raise Exception(f"Create task failed: {create_resp.get('errorDescription')}")

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

    # 2. Poll result
    timeout = 90
    start = time.time()
    while time.time() - start < timeout:
        time.sleep(1.5)
        res = requests.post("https://solvercf.com/token/extension/getTaskResult", json={
            "clientKey": client_key,
            "taskId": task_id
        }).json()

        status = res.get("status")
        if status == "ready":
            solution = res["solution"]
            print("reCAPTCHA v3 Enterprise solved successfully!")
            print(f"Token: {solution['token']}")
            print(f"UserAgent: {solution['userAgent']}")
            return solution

        if status in ("failed", "expired"):
            raise Exception(f"Task failed with status: {status}")

    raise TimeoutError("Solving reCAPTCHA v3 Enterprise timed out")

if __name__ == "__main__":
    result = solve_recaptcha_v3_enterprise(CLIENT_KEY, WEBSITE_URL, WEBSITE_KEY, page_action="checkout")

Node.js

JavaScript

const CLIENT_KEY = "YOUR_CLIENT_KEY";
const WEBSITE_URL = "https://example.com/checkout";
const WEBSITE_KEY = "6Ld_XYZ_EnterpriseKey";

async function solveRecaptchaV3Enterprise(clientKey, websiteUrl, websiteKey, pageAction = "checkout", minScore = 0.7, proxy = null) {
  // 1. Create task
  const taskType = proxy ? "RecaptchaV3EnterpriseTask" : "RecaptchaV3EnterpriseTaskProxyless";
  const createRes = await fetch("https://solvercf.com/token/extension/createTask", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      clientKey,
      task: {
        type: taskType,
        websiteUrl,
        websiteKey,
        pageAction,
        minScore,
        ...(proxy ? { proxy } : {}),
      },
    }),
  }).then((r) => r.json());

  if (createRes.errorId === 1) {
    throw new Error(`Failed to create task: ${createRes.errorDescription}`);
  }

  const taskId = createRes.taskId;
  console.log(`Task created: ${taskId}`);

  // 2. Poll result
  const deadline = Date.now() + 90000;
  while (Date.now() < deadline) {
    await new Promise((resolve) => setTimeout(resolve, 1500));

    const resultRes = await fetch("https://solvercf.com/token/extension/getTaskResult", {
      method: "POST",
      headers: { "Content-Type": "application/json" },
      body: JSON.stringify({ clientKey, taskId }),
    }).then((r) => r.json());

    if (resultRes.status === "ready") {
      console.log("reCAPTCHA v3 Enterprise solved successfully!");
      return resultRes.solution;
    }

    if (resultRes.status === "failed" || resultRes.status === "expired") {
      throw new Error(`Task ended with status: ${resultRes.status}`);
    }
  }

  throw new Error("Solving reCAPTCHA v3 Enterprise timed out");
}

solveRecaptchaV3Enterprise(CLIENT_KEY, WEBSITE_URL, WEBSITE_KEY, "checkout", 0.7)
  .then((solution) => console.log(solution))
  .catch((err) => console.error(err));

C#

using System;
using System.Net.Http;
using System.Net.Http.Json;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    private static readonly HttpClient HttpClient = new HttpClient();
    private const string ClientKey = "YOUR_CLIENT_KEY";
    private const string WebsiteUrl = "https://example.com/checkout";
    private const string WebsiteKey = "6Ld_XYZ_EnterpriseKey";

    static async Task Main()
    {
        var solution = await SolveRecaptchaV3EnterpriseAsync(ClientKey, WebsiteUrl, WebsiteKey, "checkout", 0.7);
        Console.WriteLine($"Token: {solution.Token}");
        Console.WriteLine($"UserAgent: {solution.UserAgent}");
    }

    public static async Task<RecaptchaSolution> SolveRecaptchaV3EnterpriseAsync(
        string clientKey,
        string websiteUrl,
        string websiteKey,
        string pageAction = "checkout",
        double minScore = 0.7,
        string? proxy = null)
    {
        string taskType = string.IsNullOrEmpty(proxy) ? "RecaptchaV3EnterpriseTaskProxyless" : "RecaptchaV3EnterpriseTask";

        // 1. Create task
        var createResponse = await HttpClient.PostAsJsonAsync("https://solvercf.com/token/extension/createTask", new
        {
            clientKey,
            task = new
            {
                type = taskType,
                websiteUrl,
                websiteKey,
                pageAction,
                minScore,
                proxy
            }
        });

        var createJson = await createResponse.Content.ReadFromJsonAsync<JsonElement>();
        if (createJson.TryGetProperty("errorId", out var errorId) && errorId.GetInt32() == 1)
        {
            throw new Exception($"Failed to create task: {createJson.GetProperty("errorDescription").GetString()}");
        }

        string taskId = createJson.GetProperty("taskId").GetString()!;
        Console.WriteLine($"Task created: {taskId}");

        // 2. Poll result
        DateTime deadline = DateTime.UtcNow.AddSeconds(90);
        while (DateTime.UtcNow < deadline)
        {
            await Task.Delay(1500);

            var resultResponse = await HttpClient.PostAsJsonAsync("https://solvercf.com/token/extension/getTaskResult", new
            {
                clientKey,
                taskId
            });

            var resultJson = await resultResponse.Content.ReadFromJsonAsync<JsonElement>();
            string status = resultJson.GetProperty("status").GetString()!;

            if (status == "ready")
            {
                var solutionElement = resultJson.GetProperty("solution");
                return new RecaptchaSolution
                {
                    Token = solutionElement.GetProperty("token").GetString(),
                    UserAgent = solutionElement.GetProperty("userAgent").GetString()
                };
            }

            if (status == "failed" || status == "expired")
            {
                throw new Exception($"Task ended with status: {status}");
            }
        }

        throw new TimeoutException("Solving reCAPTCHA v3 Enterprise timed out");
    }

    public class RecaptchaSolution
    {
        public string? Token { get; set; }
        public string? UserAgent { get; set; }
    }
}