Google reCAPTCHA v3

Google reCAPTCHA v3 is an invisible CAPTCHA system that returns a risk score (from 0.0 to 1.0) representing how likely an interaction is to be human, without showing visual challenges to visitors.

SolverCF provides fast, high-score solving for reCAPTCHA v3 using real browser environments.

Task Types

RecaptchaV3TaskProxyless (Recommended): Uses SolverCF's premium residential worker network to solve the captcha. No proxy configuration required on your side.
RecaptchaV3Task: Solves the captcha using your own specified proxy.

Task Object Parameters

Field	Type	Required	Description
`type`	string	Yes	`"RecaptchaV3TaskProxyless"` or `"RecaptchaV3Task"`.
`websiteUrl`	string	Yes	The full URL of the page where reCAPTCHA v3 is rendered (`https://...`).
`websiteKey`	string	Yes	The reCAPTCHA v3 site key extracted from the target page.
`pageAction`	string	No	The action parameter passed to `grecaptcha.execute()` (e.g. `"login"`, `"register"`, `"verify"`). Highly recommended to match the target site.
`minScore`	number	No	Minimum score required (`0.1` to `0.9`). SolverCF workers deliver high scores (`0.7`–`0.9`).
`proxy`	string	Required for `RecaptchaV3Task`	Your proxy in `host:port` or `host:port:user:pass` format.
`userAgent`	string	No	Specific browser User-Agent to solve with.

Finding the Site Key & Action

Open the browser's Developer Tools (Inspect Elements) or view page source:

Find the reCAPTCHA script tag:

Html

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

Search for the grecaptcha.execute call:
JavaScript
```
grecaptcha.execute('6LeSYmUtAAAAADy78hcvyfvGXqWKqN4aaFs2vyG8', { action: 'login' })
  .then(function(token) { ... });
```
Here, websiteKey is 6LeSYmUtAAAAADy78hcvyfvGXqWKqN4aaFs2vyG8 and pageAction is "login".

API Workflow

Step 1: Create Task

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

JSON

{
  "clientKey": "YOUR_CLIENT_KEY",
  "task": {
    "type": "RecaptchaV3TaskProxyless",
    "websiteUrl": "https://example.com/login",
    "websiteKey": "6LeSYmUtAAAAADy78hcvyfvGXqWKqN4aaFs2vyG8",
    "pageAction": "login",
    "minScore": 0.7
  }
}

Response:

JSON

{
  "errorId": 0,
  "taskId": "c1d2e3f4-a5b6-7c8d-9e0f-1a2b3c4d5e6f",
  "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": "c1d2e3f4-a5b6-7c8d-9e0f-1a2b3c4d5e6f"
}

When solved, status becomes "ready":

JSON

{
  "errorId": 0,
  "taskId": "c1d2e3f4-a5b6-7c8d-9e0f-1a2b3c4d5e6f",
  "status": "ready",
  "cost": 0.0009,
  "solution": {
    "type": "RecaptchaV3TaskProxyless",
    "token": "03AFcWeA7...",
    "gRecaptchaResponse": "03AFcWeA7...",
    "userAgent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36"
  }
}

Submit solution.token (or solution.gRecaptchaResponse) as the captcha response payload along with the matching solution.userAgent.

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": "RecaptchaV3TaskProxyless",
      "websiteUrl": "https://example.com/login",
      "websiteKey": "6LeSYmUtAAAAADy78hcvyfvGXqWKqN4aaFs2vyG8",
      "pageAction": "login",
      "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/login"
WEBSITE_KEY = "6LeSYmUtAAAAADy78hcvyfvGXqWKqN4aaFs2vyG8"

def solve_recaptcha_v3(client_key: str, website_url: str, website_key: str, page_action: str = "login", min_score: float = 0.7, proxy: str = None):
    # 1. Create task
    task_type = "RecaptchaV3Task" if proxy else "RecaptchaV3TaskProxyless"
    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 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 timed out")

if __name__ == "__main__":
    result = solve_recaptcha_v3(CLIENT_KEY, WEBSITE_URL, WEBSITE_KEY, page_action="login")

Node.js

JavaScript

const CLIENT_KEY = "YOUR_CLIENT_KEY";
const WEBSITE_URL = "https://example.com/login";
const WEBSITE_KEY = "6LeSYmUtAAAAADy78hcvyfvGXqWKqN4aaFs2vyG8";

async function solveRecaptchaV3(clientKey, websiteUrl, websiteKey, pageAction = "login", minScore = 0.7, proxy = null) {
  // 1. Create task
  const taskType = proxy ? "RecaptchaV3Task" : "RecaptchaV3TaskProxyless";
  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 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 timed out");
}

solveRecaptchaV3(CLIENT_KEY, WEBSITE_URL, WEBSITE_KEY, "login", 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/login";
    private const string WebsiteKey = "6LeSYmUtAAAAADy78hcvyfvGXqWKqN4aaFs2vyG8";

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

    public static async Task<RecaptchaSolution> SolveRecaptchaV3Async(
        string clientKey,
        string websiteUrl,
        string websiteKey,
        string pageAction = "login",
        double minScore = 0.7,
        string? proxy = null)
    {
        string taskType = string.IsNullOrEmpty(proxy) ? "RecaptchaV3TaskProxyless" : "RecaptchaV3Task";

        // 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 timed out");
    }

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