API documentation

npm i playwright — collects the parameters from a live page and solves them through this API.

// RecaptchaV2TaskProxyless — collect the parameters from a live page, then solve them here.
// Requirements: npm i playwright   ·   Run: node collect-and-solve.mjs

import { chromium } from 'playwright';

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://solvecaptcha.net/api';
const PAGE_URL = 'https://example.com/page-with-captcha';

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  Accept: 'application/json',
  'Content-Type': 'application/json',
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const post = async (path, payload) => {
  const response = await fetch(`${BASE_URL}/${path}`, {
    method: 'POST',
    headers,
    body: JSON.stringify(payload),
  });

  return response.json();
};

async function collect(pageUrl) {
  const browser = await chromium.launch({ headless: false });
  const page = await browser.newPage();

  await page.goto(pageUrl);
  await page.waitForTimeout(6000);

  const collected = await page.evaluate(() => {
    const el = document.querySelector('[data-sitekey], [data-captcha-id], [data-scene-id]');

    return {
      page_url: location.href,
      user_agent: navigator.userAgent,
      site_key: el
        ? el.getAttribute('data-sitekey') || el.getAttribute('data-captcha-id') || el.getAttribute('data-scene-id')
        : null,
    };
  });

  await browser.close();

  // Fill in the metadata fields documented below before submitting.
  return Object.fromEntries(Object.entries(collected).filter(([, value]) => value != null));
}

const task = { method: 'RecaptchaV2TaskProxyless', ...(await collect(PAGE_URL)) };
console.log('collected task:', JSON.stringify(task, null, 2));

const created = await post('createTask', { task });

if (created.error_id) {
  throw new Error(`createTask failed: ${created.error_code} ${created.error_description}`);
}

console.log('task_id:', created.task_id);

// Keep at least three seconds between polls: the result endpoint is
// rate limited per task.
const deadline = Date.now() + 180_000;

while (Date.now() < deadline) {
  await sleep(3000);

  const result = await post('getTaskResult', { task_id: created.task_id });

  if (result.status === 'processing') continue;

  if (result.status === 'ready') {
    console.log('solution:', result.solution);
  } else {
    console.error('failed:', result.error_code, result.error_description);
  }

  process.exit(0);
}

console.error('timed out while waiting for the solution');

pip install playwright requests && playwright install chromium

# RecaptchaV2TaskProxyless — collect the parameters from a live page, then solve them here.
# Requirements: pip install playwright requests && playwright install chromium
# Run:          python3 collect_and_solve.py

import sys
import time

import requests
from playwright.sync_api import sync_playwright

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://solvecaptcha.net/api"
PAGE_URL = "https://example.com/page-with-captcha"

READ = """
() => {
  const el = document.querySelector('[data-sitekey], [data-captcha-id], [data-scene-id]');
  return {
    page_url: location.href,
    user_agent: navigator.userAgent,
    site_key: el
      ? el.getAttribute('data-sitekey') || el.getAttribute('data-captcha-id') || el.getAttribute('data-scene-id')
      : null,
  };
}
"""


def collect(page_url):
    """Read the widget identifier, then add the metadata documented below."""
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        page.goto(page_url)
        page.wait_for_timeout(6000)
        collected = page.evaluate(READ)
        browser.close()

    return {key: value for key, value in collected.items() if value is not None}

task = {"method": "RecaptchaV2TaskProxyless", **collect(PAGE_URL)}
print("collected task:", task)

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
})

created = session.post(f"{BASE_URL}/createTask", json={"task": task}, timeout=30).json()

if created.get("error_id"):
    sys.exit(f"createTask failed: {created.get('error_code')} {created.get('error_description')}")

task_id = created["task_id"]
print("task_id:", task_id)

# Keep at least three seconds between polls: the result endpoint is
# rate limited per task.
deadline = time.time() + 180

while time.time() < deadline:
    time.sleep(3)

    result = session.post(
        f"{BASE_URL}/getTaskResult", json={"task_id": task_id}, timeout=30
    ).json()
    status = result.get("status")

    if status == "processing":
        continue

    if status == "ready":
        print("solution:", result["solution"])
    else:
        print("failed:", result.get("error_code"), result.get("error_description"))

    break
else:
    print("timed out while waiting for the solution")

npm i playwright — collects the parameters from a live page and solves them through this API.

// RecaptchaV2Task — collect the parameters from a live page, then solve them here.
// Requirements: npm i playwright   ·   Run: node collect-and-solve.mjs

import { chromium } from 'playwright';

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://solvecaptcha.net/api';
const PAGE_URL = 'https://example.com/page-with-captcha';

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  Accept: 'application/json',
  'Content-Type': 'application/json',
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const post = async (path, payload) => {
  const response = await fetch(`${BASE_URL}/${path}`, {
    method: 'POST',
    headers,
    body: JSON.stringify(payload),
  });

  return response.json();
};

async function collect(pageUrl) {
  const browser = await chromium.launch({ headless: false });
  const page = await browser.newPage();

  await page.goto(pageUrl);
  await page.waitForTimeout(6000);

  const collected = await page.evaluate(() => {
    const el = document.querySelector('[data-sitekey], [data-captcha-id], [data-scene-id]');

    return {
      page_url: location.href,
      user_agent: navigator.userAgent,
      site_key: el
        ? el.getAttribute('data-sitekey') || el.getAttribute('data-captcha-id') || el.getAttribute('data-scene-id')
        : null,
    };
  });

  await browser.close();

  // Fill in the metadata fields documented below before submitting.
  return Object.fromEntries(Object.entries(collected).filter(([, value]) => value != null));
}

const task = { method: 'RecaptchaV2Task', ...(await collect(PAGE_URL)) };
console.log('collected task:', JSON.stringify(task, null, 2));

const created = await post('createTask', { task });

if (created.error_id) {
  throw new Error(`createTask failed: ${created.error_code} ${created.error_description}`);
}

console.log('task_id:', created.task_id);

// Keep at least three seconds between polls: the result endpoint is
// rate limited per task.
const deadline = Date.now() + 180_000;

while (Date.now() < deadline) {
  await sleep(3000);

  const result = await post('getTaskResult', { task_id: created.task_id });

  if (result.status === 'processing') continue;

  if (result.status === 'ready') {
    console.log('solution:', result.solution);
  } else {
    console.error('failed:', result.error_code, result.error_description);
  }

  process.exit(0);
}

console.error('timed out while waiting for the solution');

pip install playwright requests && playwright install chromium

# RecaptchaV2Task — collect the parameters from a live page, then solve them here.
# Requirements: pip install playwright requests && playwright install chromium
# Run:          python3 collect_and_solve.py

import sys
import time

import requests
from playwright.sync_api import sync_playwright

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://solvecaptcha.net/api"
PAGE_URL = "https://example.com/page-with-captcha"

READ = """
() => {
  const el = document.querySelector('[data-sitekey], [data-captcha-id], [data-scene-id]');
  return {
    page_url: location.href,
    user_agent: navigator.userAgent,
    site_key: el
      ? el.getAttribute('data-sitekey') || el.getAttribute('data-captcha-id') || el.getAttribute('data-scene-id')
      : null,
  };
}
"""


def collect(page_url):
    """Read the widget identifier, then add the metadata documented below."""
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        page.goto(page_url)
        page.wait_for_timeout(6000)
        collected = page.evaluate(READ)
        browser.close()

    return {key: value for key, value in collected.items() if value is not None}

task = {"method": "RecaptchaV2Task", **collect(PAGE_URL)}
print("collected task:", task)

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
})

created = session.post(f"{BASE_URL}/createTask", json={"task": task}, timeout=30).json()

if created.get("error_id"):
    sys.exit(f"createTask failed: {created.get('error_code')} {created.get('error_description')}")

task_id = created["task_id"]
print("task_id:", task_id)

# Keep at least three seconds between polls: the result endpoint is
# rate limited per task.
deadline = time.time() + 180

while time.time() < deadline:
    time.sleep(3)

    result = session.post(
        f"{BASE_URL}/getTaskResult", json={"task_id": task_id}, timeout=30
    ).json()
    status = result.get("status")

    if status == "processing":
        continue

    if status == "ready":
        print("solution:", result["solution"])
    else:
        print("failed:", result.get("error_code"), result.get("error_description"))

    break
else:
    print("timed out while waiting for the solution")

npm i playwright — collects the parameters from a live page and solves them through this API.

// RecaptchaV3TaskProxyless — collect the parameters from a live page, then solve them here.
// Requirements: npm i playwright   ·   Run: node collect-and-solve.mjs

import { chromium } from 'playwright';

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://solvecaptcha.net/api';
const PAGE_URL = 'https://example.com/page-with-captcha';

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  Accept: 'application/json',
  'Content-Type': 'application/json',
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const post = async (path, payload) => {
  const response = await fetch(`${BASE_URL}/${path}`, {
    method: 'POST',
    headers,
    body: JSON.stringify(payload),
  });

  return response.json();
};

async function collect(pageUrl) {
  const browser = await chromium.launch({ headless: false });
  const page = await browser.newPage();

  await page.goto(pageUrl);
  await page.waitForTimeout(6000);

  const collected = await page.evaluate(() => {
    const el = document.querySelector('[data-sitekey], [data-captcha-id], [data-scene-id]');

    return {
      page_url: location.href,
      user_agent: navigator.userAgent,
      site_key: el
        ? el.getAttribute('data-sitekey') || el.getAttribute('data-captcha-id') || el.getAttribute('data-scene-id')
        : null,
    };
  });

  await browser.close();

  // Fill in the metadata fields documented below before submitting.
  return Object.fromEntries(Object.entries(collected).filter(([, value]) => value != null));
}

const task = { method: 'RecaptchaV3TaskProxyless', ...(await collect(PAGE_URL)) };
console.log('collected task:', JSON.stringify(task, null, 2));

const created = await post('createTask', { task });

if (created.error_id) {
  throw new Error(`createTask failed: ${created.error_code} ${created.error_description}`);
}

console.log('task_id:', created.task_id);

// Keep at least three seconds between polls: the result endpoint is
// rate limited per task.
const deadline = Date.now() + 180_000;

while (Date.now() < deadline) {
  await sleep(3000);

  const result = await post('getTaskResult', { task_id: created.task_id });

  if (result.status === 'processing') continue;

  if (result.status === 'ready') {
    console.log('solution:', result.solution);
  } else {
    console.error('failed:', result.error_code, result.error_description);
  }

  process.exit(0);
}

console.error('timed out while waiting for the solution');

pip install playwright requests && playwright install chromium

# RecaptchaV3TaskProxyless — collect the parameters from a live page, then solve them here.
# Requirements: pip install playwright requests && playwright install chromium
# Run:          python3 collect_and_solve.py

import sys
import time

import requests
from playwright.sync_api import sync_playwright

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://solvecaptcha.net/api"
PAGE_URL = "https://example.com/page-with-captcha"

READ = """
() => {
  const el = document.querySelector('[data-sitekey], [data-captcha-id], [data-scene-id]');
  return {
    page_url: location.href,
    user_agent: navigator.userAgent,
    site_key: el
      ? el.getAttribute('data-sitekey') || el.getAttribute('data-captcha-id') || el.getAttribute('data-scene-id')
      : null,
  };
}
"""


def collect(page_url):
    """Read the widget identifier, then add the metadata documented below."""
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        page.goto(page_url)
        page.wait_for_timeout(6000)
        collected = page.evaluate(READ)
        browser.close()

    return {key: value for key, value in collected.items() if value is not None}

task = {"method": "RecaptchaV3TaskProxyless", **collect(PAGE_URL)}
print("collected task:", task)

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
})

created = session.post(f"{BASE_URL}/createTask", json={"task": task}, timeout=30).json()

if created.get("error_id"):
    sys.exit(f"createTask failed: {created.get('error_code')} {created.get('error_description')}")

task_id = created["task_id"]
print("task_id:", task_id)

# Keep at least three seconds between polls: the result endpoint is
# rate limited per task.
deadline = time.time() + 180

while time.time() < deadline:
    time.sleep(3)

    result = session.post(
        f"{BASE_URL}/getTaskResult", json={"task_id": task_id}, timeout=30
    ).json()
    status = result.get("status")

    if status == "processing":
        continue

    if status == "ready":
        print("solution:", result["solution"])
    else:
        print("failed:", result.get("error_code"), result.get("error_description"))

    break
else:
    print("timed out while waiting for the solution")

npm i playwright — collects the parameters from a live page and solves them through this API.

// FunCaptchaTask — collect the parameters from a live page, then solve them here.
// Requirements: npm i playwright   ·   Run: node collect-and-solve.mjs

import { chromium } from 'playwright';

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://solvecaptcha.net/api';
const PAGE_URL = 'https://example.com/page-with-captcha';

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  Accept: 'application/json',
  'Content-Type': 'application/json',
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const post = async (path, payload) => {
  const response = await fetch(`${BASE_URL}/${path}`, {
    method: 'POST',
    headers,
    body: JSON.stringify(payload),
  });

  return response.json();
};

async function collect(pageUrl) {
  const browser = await chromium.launch({ headless: false });
  const page = await browser.newPage();
  let collected = null;

  page.on('request', (request) => {
    const url = request.url();
    if (collected || !url.includes('arkoselabs') || !url.includes('pk=')) return;
    const parsed = new URL(url);
    collected = { site_key: parsed.searchParams.get('pk'), sub_domain: parsed.host };
  });

  await page.goto(pageUrl);
  await page.waitForTimeout(8000);

  const pageHref = page.url();
  const userAgent = await page.evaluate(() => navigator.userAgent);
  await browser.close();

  if (!collected) throw new Error('No Arkose request with pk= was seen on this page.');

  return { page_url: pageHref, user_agent: userAgent, ...collected };
}

const task = { method: 'FunCaptchaTask', ...(await collect(PAGE_URL)) };
console.log('collected task:', JSON.stringify(task, null, 2));

const created = await post('createTask', { task });

if (created.error_id) {
  throw new Error(`createTask failed: ${created.error_code} ${created.error_description}`);
}

console.log('task_id:', created.task_id);

// Keep at least three seconds between polls: the result endpoint is
// rate limited per task.
const deadline = Date.now() + 180_000;

while (Date.now() < deadline) {
  await sleep(3000);

  const result = await post('getTaskResult', { task_id: created.task_id });

  if (result.status === 'processing') continue;

  if (result.status === 'ready') {
    console.log('solution:', result.solution);
  } else {
    console.error('failed:', result.error_code, result.error_description);
  }

  process.exit(0);
}

console.error('timed out while waiting for the solution');

pip install playwright requests && playwright install chromium

# FunCaptchaTask — collect the parameters from a live page, then solve them here.
# Requirements: pip install playwright requests && playwright install chromium
# Run:          python3 collect_and_solve.py

import sys
import time
from urllib.parse import parse_qs, urlparse

import requests
from playwright.sync_api import sync_playwright

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://solvecaptcha.net/api"
PAGE_URL = "https://example.com/page-with-captcha"

def collect(page_url):
    """The Arkose /fc/gc/ request carries the public key as pk."""
    collected = {}

    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()

        def on_request(request):
            url = request.url
            if collected or "arkoselabs" not in url or "pk=" not in url:
                return
            parsed = urlparse(url)
            collected.update({
                "site_key": parse_qs(parsed.query).get("pk", [None])[0],
                "sub_domain": parsed.netloc,
            })

        page.on("request", on_request)
        page.goto(page_url)
        page.wait_for_timeout(8000)
        page_href = page.url
        user_agent = page.evaluate("() => navigator.userAgent")
        browser.close()

    if not collected:
        sys.exit("No Arkose request with pk= was seen on this page.")

    return {"page_url": page_href, "user_agent": user_agent, **collected}

task = {"method": "FunCaptchaTask", **collect(PAGE_URL)}
print("collected task:", task)

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
})

created = session.post(f"{BASE_URL}/createTask", json={"task": task}, timeout=30).json()

if created.get("error_id"):
    sys.exit(f"createTask failed: {created.get('error_code')} {created.get('error_description')}")

task_id = created["task_id"]
print("task_id:", task_id)

# Keep at least three seconds between polls: the result endpoint is
# rate limited per task.
deadline = time.time() + 180

while time.time() < deadline:
    time.sleep(3)

    result = session.post(
        f"{BASE_URL}/getTaskResult", json={"task_id": task_id}, timeout=30
    ).json()
    status = result.get("status")

    if status == "processing":
        continue

    if status == "ready":
        print("solution:", result["solution"])
    else:
        print("failed:", result.get("error_code"), result.get("error_description"))

    break
else:
    print("timed out while waiting for the solution")

npm i playwright — collects the parameters from a live page and solves them through this API.

// FunCaptchaTaskProxyless — collect the parameters from a live page, then solve them here.
// Requirements: npm i playwright   ·   Run: node collect-and-solve.mjs

import { chromium } from 'playwright';

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://solvecaptcha.net/api';
const PAGE_URL = 'https://example.com/page-with-captcha';

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  Accept: 'application/json',
  'Content-Type': 'application/json',
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const post = async (path, payload) => {
  const response = await fetch(`${BASE_URL}/${path}`, {
    method: 'POST',
    headers,
    body: JSON.stringify(payload),
  });

  return response.json();
};

async function collect(pageUrl) {
  const browser = await chromium.launch({ headless: false });
  const page = await browser.newPage();
  let collected = null;

  page.on('request', (request) => {
    const url = request.url();
    if (collected || !url.includes('arkoselabs') || !url.includes('pk=')) return;
    const parsed = new URL(url);
    collected = { site_key: parsed.searchParams.get('pk'), sub_domain: parsed.host };
  });

  await page.goto(pageUrl);
  await page.waitForTimeout(8000);

  const pageHref = page.url();
  const userAgent = await page.evaluate(() => navigator.userAgent);
  await browser.close();

  if (!collected) throw new Error('No Arkose request with pk= was seen on this page.');

  return { page_url: pageHref, user_agent: userAgent, ...collected };
}

const task = { method: 'FunCaptchaTaskProxyless', ...(await collect(PAGE_URL)) };
console.log('collected task:', JSON.stringify(task, null, 2));

const created = await post('createTask', { task });

if (created.error_id) {
  throw new Error(`createTask failed: ${created.error_code} ${created.error_description}`);
}

console.log('task_id:', created.task_id);

// Keep at least three seconds between polls: the result endpoint is
// rate limited per task.
const deadline = Date.now() + 180_000;

while (Date.now() < deadline) {
  await sleep(3000);

  const result = await post('getTaskResult', { task_id: created.task_id });

  if (result.status === 'processing') continue;

  if (result.status === 'ready') {
    console.log('solution:', result.solution);
  } else {
    console.error('failed:', result.error_code, result.error_description);
  }

  process.exit(0);
}

console.error('timed out while waiting for the solution');

pip install playwright requests && playwright install chromium

# FunCaptchaTaskProxyless — collect the parameters from a live page, then solve them here.
# Requirements: pip install playwright requests && playwright install chromium
# Run:          python3 collect_and_solve.py

import sys
import time
from urllib.parse import parse_qs, urlparse

import requests
from playwright.sync_api import sync_playwright

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://solvecaptcha.net/api"
PAGE_URL = "https://example.com/page-with-captcha"

def collect(page_url):
    """The Arkose /fc/gc/ request carries the public key as pk."""
    collected = {}

    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()

        def on_request(request):
            url = request.url
            if collected or "arkoselabs" not in url or "pk=" not in url:
                return
            parsed = urlparse(url)
            collected.update({
                "site_key": parse_qs(parsed.query).get("pk", [None])[0],
                "sub_domain": parsed.netloc,
            })

        page.on("request", on_request)
        page.goto(page_url)
        page.wait_for_timeout(8000)
        page_href = page.url
        user_agent = page.evaluate("() => navigator.userAgent")
        browser.close()

    if not collected:
        sys.exit("No Arkose request with pk= was seen on this page.")

    return {"page_url": page_href, "user_agent": user_agent, **collected}

task = {"method": "FunCaptchaTaskProxyless", **collect(PAGE_URL)}
print("collected task:", task)

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
})

created = session.post(f"{BASE_URL}/createTask", json={"task": task}, timeout=30).json()

if created.get("error_id"):
    sys.exit(f"createTask failed: {created.get('error_code')} {created.get('error_description')}")

task_id = created["task_id"]
print("task_id:", task_id)

# Keep at least three seconds between polls: the result endpoint is
# rate limited per task.
deadline = time.time() + 180

while time.time() < deadline:
    time.sleep(3)

    result = session.post(
        f"{BASE_URL}/getTaskResult", json={"task_id": task_id}, timeout=30
    ).json()
    status = result.get("status")

    if status == "processing":
        continue

    if status == "ready":
        print("solution:", result["solution"])
    else:
        print("failed:", result.get("error_code"), result.get("error_description"))

    break
else:
    print("timed out while waiting for the solution")

npm i playwright — collects the parameters from a live page and solves them through this API.

// GeeTestTask — collect the parameters from a live page, then solve them here.
// Requirements: npm i playwright   ·   Run: node collect-and-solve.mjs

import { chromium } from 'playwright';

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://solvecaptcha.net/api';
const PAGE_URL = 'https://example.com/page-with-captcha';

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  Accept: 'application/json',
  'Content-Type': 'application/json',
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const post = async (path, payload) => {
  const response = await fetch(`${BASE_URL}/${path}`, {
    method: 'POST',
    headers,
    body: JSON.stringify(payload),
  });

  return response.json();
};

async function collect(pageUrl) {
  const browser = await chromium.launch({ headless: false });
  const context = await browser.newContext();
  let collected = null;

  // Block the GeeTest call and read its query string: letting it through
  // would spend the challenge before the task is created.
  await context.route('**/*', async (route) => {
    const url = route.request().url();

    if (url.includes('api.geetest.com/get.php') || url.includes('api.geevisit.com/ajax.php')) {
      const query = new URL(url).searchParams;
      const gt = query.get('gt');
      const challenge = query.get('challenge');

      if (gt && challenge && !collected) {
        collected = { gt, challenge, version: 3 };
      }

      return route.abort();
    }

    return route.continue();
  });

  const page = await context.newPage();
  await page.goto(pageUrl);
  await page.waitForTimeout(8000);

  const pageHref = page.url();
  await browser.close();

  if (!collected) throw new Error('No gt/challenge seen. For V4 read captcha_id and send it as gt with version: 4.');

  return { page_url: pageHref, ...collected };
}

const task = { method: 'GeeTestTask', ...(await collect(PAGE_URL)) };
console.log('collected task:', JSON.stringify(task, null, 2));

const created = await post('createTask', { task });

if (created.error_id) {
  throw new Error(`createTask failed: ${created.error_code} ${created.error_description}`);
}

console.log('task_id:', created.task_id);

// Keep at least three seconds between polls: the result endpoint is
// rate limited per task.
const deadline = Date.now() + 180_000;

while (Date.now() < deadline) {
  await sleep(3000);

  const result = await post('getTaskResult', { task_id: created.task_id });

  if (result.status === 'processing') continue;

  if (result.status === 'ready') {
    console.log('solution:', result.solution);
  } else {
    console.error('failed:', result.error_code, result.error_description);
  }

  process.exit(0);
}

console.error('timed out while waiting for the solution');

pip install playwright requests && playwright install chromium

# GeeTestTask — collect the parameters from a live page, then solve them here.
# Requirements: pip install playwright requests && playwright install chromium
# Run:          python3 collect_and_solve.py

import sys
import time
from urllib.parse import parse_qs, urlparse

import requests
from playwright.sync_api import sync_playwright

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://solvecaptcha.net/api"
PAGE_URL = "https://example.com/page-with-captcha"

def collect(page_url):
    """Block the GeeTest call and read its query string.

    Letting it through would spend the challenge before the task exists.
    """
    collected = {}

    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        context = browser.new_context()

        def handle(route):
            url = route.request.url

            if "api.geetest.com/get.php" in url or "api.geevisit.com/ajax.php" in url:
                query = parse_qs(urlparse(url).query)
                gt = query.get("gt", [None])[0]
                challenge = query.get("challenge", [None])[0]

                if gt and challenge and not collected:
                    collected.update({"gt": gt, "challenge": challenge, "version": 3})

                return route.abort()

            return route.continue_()

        context.route("**/*", handle)
        page = context.new_page()
        page.goto(page_url)
        page.wait_for_timeout(8000)
        page_href = page.url
        browser.close()

    if not collected:
        sys.exit("No gt/challenge seen. For V4 read captcha_id and send it as gt with version 4.")

    return {"page_url": page_href, **collected}

task = {"method": "GeeTestTask", **collect(PAGE_URL)}
print("collected task:", task)

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
})

created = session.post(f"{BASE_URL}/createTask", json={"task": task}, timeout=30).json()

if created.get("error_id"):
    sys.exit(f"createTask failed: {created.get('error_code')} {created.get('error_description')}")

task_id = created["task_id"]
print("task_id:", task_id)

# Keep at least three seconds between polls: the result endpoint is
# rate limited per task.
deadline = time.time() + 180

while time.time() < deadline:
    time.sleep(3)

    result = session.post(
        f"{BASE_URL}/getTaskResult", json={"task_id": task_id}, timeout=30
    ).json()
    status = result.get("status")

    if status == "processing":
        continue

    if status == "ready":
        print("solution:", result["solution"])
    else:
        print("failed:", result.get("error_code"), result.get("error_description"))

    break
else:
    print("timed out while waiting for the solution")

npm i playwright — collects the parameters from a live page and solves them through this API.

// GeeTestTaskProxyless — collect the parameters from a live page, then solve them here.
// Requirements: npm i playwright   ·   Run: node collect-and-solve.mjs

import { chromium } from 'playwright';

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://solvecaptcha.net/api';
const PAGE_URL = 'https://example.com/page-with-captcha';

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  Accept: 'application/json',
  'Content-Type': 'application/json',
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const post = async (path, payload) => {
  const response = await fetch(`${BASE_URL}/${path}`, {
    method: 'POST',
    headers,
    body: JSON.stringify(payload),
  });

  return response.json();
};

async function collect(pageUrl) {
  const browser = await chromium.launch({ headless: false });
  const context = await browser.newContext();
  let collected = null;

  // Block the GeeTest call and read its query string: letting it through
  // would spend the challenge before the task is created.
  await context.route('**/*', async (route) => {
    const url = route.request().url();

    if (url.includes('api.geetest.com/get.php') || url.includes('api.geevisit.com/ajax.php')) {
      const query = new URL(url).searchParams;
      const gt = query.get('gt');
      const challenge = query.get('challenge');

      if (gt && challenge && !collected) {
        collected = { gt, challenge, version: 3 };
      }

      return route.abort();
    }

    return route.continue();
  });

  const page = await context.newPage();
  await page.goto(pageUrl);
  await page.waitForTimeout(8000);

  const pageHref = page.url();
  await browser.close();

  if (!collected) throw new Error('No gt/challenge seen. For V4 read captcha_id and send it as gt with version: 4.');

  return { page_url: pageHref, ...collected };
}

const task = { method: 'GeeTestTaskProxyless', ...(await collect(PAGE_URL)) };
console.log('collected task:', JSON.stringify(task, null, 2));

const created = await post('createTask', { task });

if (created.error_id) {
  throw new Error(`createTask failed: ${created.error_code} ${created.error_description}`);
}

console.log('task_id:', created.task_id);

// Keep at least three seconds between polls: the result endpoint is
// rate limited per task.
const deadline = Date.now() + 180_000;

while (Date.now() < deadline) {
  await sleep(3000);

  const result = await post('getTaskResult', { task_id: created.task_id });

  if (result.status === 'processing') continue;

  if (result.status === 'ready') {
    console.log('solution:', result.solution);
  } else {
    console.error('failed:', result.error_code, result.error_description);
  }

  process.exit(0);
}

console.error('timed out while waiting for the solution');

pip install playwright requests && playwright install chromium

# GeeTestTaskProxyless — collect the parameters from a live page, then solve them here.
# Requirements: pip install playwright requests && playwright install chromium
# Run:          python3 collect_and_solve.py

import sys
import time
from urllib.parse import parse_qs, urlparse

import requests
from playwright.sync_api import sync_playwright

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://solvecaptcha.net/api"
PAGE_URL = "https://example.com/page-with-captcha"

def collect(page_url):
    """Block the GeeTest call and read its query string.

    Letting it through would spend the challenge before the task exists.
    """
    collected = {}

    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        context = browser.new_context()

        def handle(route):
            url = route.request.url

            if "api.geetest.com/get.php" in url or "api.geevisit.com/ajax.php" in url:
                query = parse_qs(urlparse(url).query)
                gt = query.get("gt", [None])[0]
                challenge = query.get("challenge", [None])[0]

                if gt and challenge and not collected:
                    collected.update({"gt": gt, "challenge": challenge, "version": 3})

                return route.abort()

            return route.continue_()

        context.route("**/*", handle)
        page = context.new_page()
        page.goto(page_url)
        page.wait_for_timeout(8000)
        page_href = page.url
        browser.close()

    if not collected:
        sys.exit("No gt/challenge seen. For V4 read captcha_id and send it as gt with version 4.")

    return {"page_url": page_href, **collected}

task = {"method": "GeeTestTaskProxyless", **collect(PAGE_URL)}
print("collected task:", task)

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
})

created = session.post(f"{BASE_URL}/createTask", json={"task": task}, timeout=30).json()

if created.get("error_id"):
    sys.exit(f"createTask failed: {created.get('error_code')} {created.get('error_description')}")

task_id = created["task_id"]
print("task_id:", task_id)

# Keep at least three seconds between polls: the result endpoint is
# rate limited per task.
deadline = time.time() + 180

while time.time() < deadline:
    time.sleep(3)

    result = session.post(
        f"{BASE_URL}/getTaskResult", json={"task_id": task_id}, timeout=30
    ).json()
    status = result.get("status")

    if status == "processing":
        continue

    if status == "ready":
        print("solution:", result["solution"])
    else:
        print("failed:", result.get("error_code"), result.get("error_description"))

    break
else:
    print("timed out while waiting for the solution")

npm i playwright — collects the parameters from a live page and solves them through this API.

// TurnstileTask — collect the parameters from a live page, then solve them here.
// Requirements: npm i playwright   ·   Run: node collect-and-solve.mjs

import { chromium } from 'playwright';

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://solvecaptcha.net/api';
const PAGE_URL = 'https://example.com/page-with-captcha';

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  Accept: 'application/json',
  'Content-Type': 'application/json',
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const post = async (path, payload) => {
  const response = await fetch(`${BASE_URL}/${path}`, {
    method: 'POST',
    headers,
    body: JSON.stringify(payload),
  });

  return response.json();
};

async function collect(pageUrl) {
  const browser = await chromium.launch({ headless: false });
  const page = await browser.newPage();

  // Hook turnstile.render before the page script runs: the options it
  // receives carry the sitekey, action, cData and chlPageData.
  await page.addInitScript(() => {
    window.__collected = null;
    let real = null;
    Object.defineProperty(window, 'turnstile', {
      configurable: true,
      get: () => real,
      set(value) {
        const render = value.render.bind(value);
        value.render = (container, options = {}) => {
          window.__collected = {
            site_key: options.sitekey,
            page_action: options.action,
            data: options.cData,
            page_data: options.chlPageData,
            user_agent: navigator.userAgent,
          };
          return render(container, options);
        };
        real = value;
      },
    });
  });

  await page.goto(pageUrl);
  await page.waitForFunction(() => window.__collected !== null, null, { timeout: 30000 });

  const collected = await page.evaluate(() => ({ page_url: location.href, ...window.__collected }));
  await browser.close();

  return Object.fromEntries(Object.entries(collected).filter(([, value]) => value != null));
}

const task = { method: 'TurnstileTask', ...(await collect(PAGE_URL)) };
console.log('collected task:', JSON.stringify(task, null, 2));

const created = await post('createTask', { task });

if (created.error_id) {
  throw new Error(`createTask failed: ${created.error_code} ${created.error_description}`);
}

console.log('task_id:', created.task_id);

// Keep at least three seconds between polls: the result endpoint is
// rate limited per task.
const deadline = Date.now() + 180_000;

while (Date.now() < deadline) {
  await sleep(3000);

  const result = await post('getTaskResult', { task_id: created.task_id });

  if (result.status === 'processing') continue;

  if (result.status === 'ready') {
    console.log('solution:', result.solution);
  } else {
    console.error('failed:', result.error_code, result.error_description);
  }

  process.exit(0);
}

console.error('timed out while waiting for the solution');

pip install playwright requests && playwright install chromium

# TurnstileTask — collect the parameters from a live page, then solve them here.
# Requirements: pip install playwright requests && playwright install chromium
# Run:          python3 collect_and_solve.py

import sys
import time

import requests
from playwright.sync_api import sync_playwright

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://solvecaptcha.net/api"
PAGE_URL = "https://example.com/page-with-captcha"

HOOK = """
window.__collected = null;
let real = null;
Object.defineProperty(window, 'turnstile', {
  configurable: true,
  get: () => real,
  set(value) {
    const render = value.render.bind(value);
    value.render = (container, options = {}) => {
      window.__collected = {
        site_key: options.sitekey,
        page_action: options.action,
        data: options.cData,
        page_data: options.chlPageData,
        user_agent: navigator.userAgent,
      };
      return render(container, options);
    };
    real = value;
  },
});
"""


def collect(page_url):
    """Hook turnstile.render: its options carry every value the task needs."""
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        page.add_init_script(HOOK)
        page.goto(page_url)
        page.wait_for_function("window.__collected !== null", timeout=30000)

        collected = page.evaluate(
            "() => ({ page_url: location.href, ...window.__collected })"
        )
        browser.close()

    return {key: value for key, value in collected.items() if value is not None}

task = {"method": "TurnstileTask", **collect(PAGE_URL)}
print("collected task:", task)

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
})

created = session.post(f"{BASE_URL}/createTask", json={"task": task}, timeout=30).json()

if created.get("error_id"):
    sys.exit(f"createTask failed: {created.get('error_code')} {created.get('error_description')}")

task_id = created["task_id"]
print("task_id:", task_id)

# Keep at least three seconds between polls: the result endpoint is
# rate limited per task.
deadline = time.time() + 180

while time.time() < deadline:
    time.sleep(3)

    result = session.post(
        f"{BASE_URL}/getTaskResult", json={"task_id": task_id}, timeout=30
    ).json()
    status = result.get("status")

    if status == "processing":
        continue

    if status == "ready":
        print("solution:", result["solution"])
    else:
        print("failed:", result.get("error_code"), result.get("error_description"))

    break
else:
    print("timed out while waiting for the solution")

npm i playwright — collects the parameters from a live page and solves them through this API.

// TurnstileTaskProxyless — collect the parameters from a live page, then solve them here.
// Requirements: npm i playwright   ·   Run: node collect-and-solve.mjs

import { chromium } from 'playwright';

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://solvecaptcha.net/api';
const PAGE_URL = 'https://example.com/page-with-captcha';

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  Accept: 'application/json',
  'Content-Type': 'application/json',
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const post = async (path, payload) => {
  const response = await fetch(`${BASE_URL}/${path}`, {
    method: 'POST',
    headers,
    body: JSON.stringify(payload),
  });

  return response.json();
};

async function collect(pageUrl) {
  const browser = await chromium.launch({ headless: false });
  const page = await browser.newPage();

  // Hook turnstile.render before the page script runs: the options it
  // receives carry the sitekey, action, cData and chlPageData.
  await page.addInitScript(() => {
    window.__collected = null;
    let real = null;
    Object.defineProperty(window, 'turnstile', {
      configurable: true,
      get: () => real,
      set(value) {
        const render = value.render.bind(value);
        value.render = (container, options = {}) => {
          window.__collected = {
            site_key: options.sitekey,
            page_action: options.action,
            data: options.cData,
            page_data: options.chlPageData,
            user_agent: navigator.userAgent,
          };
          return render(container, options);
        };
        real = value;
      },
    });
  });

  await page.goto(pageUrl);
  await page.waitForFunction(() => window.__collected !== null, null, { timeout: 30000 });

  const collected = await page.evaluate(() => ({ page_url: location.href, ...window.__collected }));
  await browser.close();

  return Object.fromEntries(Object.entries(collected).filter(([, value]) => value != null));
}

const task = { method: 'TurnstileTaskProxyless', ...(await collect(PAGE_URL)) };
console.log('collected task:', JSON.stringify(task, null, 2));

const created = await post('createTask', { task });

if (created.error_id) {
  throw new Error(`createTask failed: ${created.error_code} ${created.error_description}`);
}

console.log('task_id:', created.task_id);

// Keep at least three seconds between polls: the result endpoint is
// rate limited per task.
const deadline = Date.now() + 180_000;

while (Date.now() < deadline) {
  await sleep(3000);

  const result = await post('getTaskResult', { task_id: created.task_id });

  if (result.status === 'processing') continue;

  if (result.status === 'ready') {
    console.log('solution:', result.solution);
  } else {
    console.error('failed:', result.error_code, result.error_description);
  }

  process.exit(0);
}

console.error('timed out while waiting for the solution');

pip install playwright requests && playwright install chromium

# TurnstileTaskProxyless — collect the parameters from a live page, then solve them here.
# Requirements: pip install playwright requests && playwright install chromium
# Run:          python3 collect_and_solve.py

import sys
import time

import requests
from playwright.sync_api import sync_playwright

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://solvecaptcha.net/api"
PAGE_URL = "https://example.com/page-with-captcha"

HOOK = """
window.__collected = null;
let real = null;
Object.defineProperty(window, 'turnstile', {
  configurable: true,
  get: () => real,
  set(value) {
    const render = value.render.bind(value);
    value.render = (container, options = {}) => {
      window.__collected = {
        site_key: options.sitekey,
        page_action: options.action,
        data: options.cData,
        page_data: options.chlPageData,
        user_agent: navigator.userAgent,
      };
      return render(container, options);
    };
    real = value;
  },
});
"""


def collect(page_url):
    """Hook turnstile.render: its options carry every value the task needs."""
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        page.add_init_script(HOOK)
        page.goto(page_url)
        page.wait_for_function("window.__collected !== null", timeout=30000)

        collected = page.evaluate(
            "() => ({ page_url: location.href, ...window.__collected })"
        )
        browser.close()

    return {key: value for key, value in collected.items() if value is not None}

task = {"method": "TurnstileTaskProxyless", **collect(PAGE_URL)}
print("collected task:", task)

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
})

created = session.post(f"{BASE_URL}/createTask", json={"task": task}, timeout=30).json()

if created.get("error_id"):
    sys.exit(f"createTask failed: {created.get('error_code')} {created.get('error_description')}")

task_id = created["task_id"]
print("task_id:", task_id)

# Keep at least three seconds between polls: the result endpoint is
# rate limited per task.
deadline = time.time() + 180

while time.time() < deadline:
    time.sleep(3)

    result = session.post(
        f"{BASE_URL}/getTaskResult", json={"task_id": task_id}, timeout=30
    ).json()
    status = result.get("status")

    if status == "processing":
        continue

    if status == "ready":
        print("solution:", result["solution"])
    else:
        print("failed:", result.get("error_code"), result.get("error_description"))

    break
else:
    print("timed out while waiting for the solution")

npm i playwright — collects the parameters from a live page and solves them through this API.

// RecaptchaV2EnterpriseTask — collect the parameters from a live page, then solve them here.
// Requirements: npm i playwright   ·   Run: node collect-and-solve.mjs

import { chromium } from 'playwright';

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://solvecaptcha.net/api';
const PAGE_URL = 'https://example.com/page-with-captcha';

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  Accept: 'application/json',
  'Content-Type': 'application/json',
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const post = async (path, payload) => {
  const response = await fetch(`${BASE_URL}/${path}`, {
    method: 'POST',
    headers,
    body: JSON.stringify(payload),
  });

  return response.json();
};

async function collect(pageUrl) {
  const browser = await chromium.launch({ headless: false });
  const page = await browser.newPage();

  await page.goto(pageUrl);
  await page.waitForTimeout(6000);

  const collected = await page.evaluate(() => {
    const el = document.querySelector('[data-sitekey], [data-captcha-id], [data-scene-id]');

    return {
      page_url: location.href,
      user_agent: navigator.userAgent,
      site_key: el
        ? el.getAttribute('data-sitekey') || el.getAttribute('data-captcha-id') || el.getAttribute('data-scene-id')
        : null,
    };
  });

  await browser.close();

  // Fill in the metadata fields documented below before submitting.
  return Object.fromEntries(Object.entries(collected).filter(([, value]) => value != null));
}

const task = { method: 'RecaptchaV2EnterpriseTask', ...(await collect(PAGE_URL)) };
console.log('collected task:', JSON.stringify(task, null, 2));

const created = await post('createTask', { task });

if (created.error_id) {
  throw new Error(`createTask failed: ${created.error_code} ${created.error_description}`);
}

console.log('task_id:', created.task_id);

// Keep at least three seconds between polls: the result endpoint is
// rate limited per task.
const deadline = Date.now() + 180_000;

while (Date.now() < deadline) {
  await sleep(3000);

  const result = await post('getTaskResult', { task_id: created.task_id });

  if (result.status === 'processing') continue;

  if (result.status === 'ready') {
    console.log('solution:', result.solution);
  } else {
    console.error('failed:', result.error_code, result.error_description);
  }

  process.exit(0);
}

console.error('timed out while waiting for the solution');

pip install playwright requests && playwright install chromium

# RecaptchaV2EnterpriseTask — collect the parameters from a live page, then solve them here.
# Requirements: pip install playwright requests && playwright install chromium
# Run:          python3 collect_and_solve.py

import sys
import time

import requests
from playwright.sync_api import sync_playwright

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://solvecaptcha.net/api"
PAGE_URL = "https://example.com/page-with-captcha"

READ = """
() => {
  const el = document.querySelector('[data-sitekey], [data-captcha-id], [data-scene-id]');
  return {
    page_url: location.href,
    user_agent: navigator.userAgent,
    site_key: el
      ? el.getAttribute('data-sitekey') || el.getAttribute('data-captcha-id') || el.getAttribute('data-scene-id')
      : null,
  };
}
"""


def collect(page_url):
    """Read the widget identifier, then add the metadata documented below."""
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        page.goto(page_url)
        page.wait_for_timeout(6000)
        collected = page.evaluate(READ)
        browser.close()

    return {key: value for key, value in collected.items() if value is not None}

task = {"method": "RecaptchaV2EnterpriseTask", **collect(PAGE_URL)}
print("collected task:", task)

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
})

created = session.post(f"{BASE_URL}/createTask", json={"task": task}, timeout=30).json()

if created.get("error_id"):
    sys.exit(f"createTask failed: {created.get('error_code')} {created.get('error_description')}")

task_id = created["task_id"]
print("task_id:", task_id)

# Keep at least three seconds between polls: the result endpoint is
# rate limited per task.
deadline = time.time() + 180

while time.time() < deadline:
    time.sleep(3)

    result = session.post(
        f"{BASE_URL}/getTaskResult", json={"task_id": task_id}, timeout=30
    ).json()
    status = result.get("status")

    if status == "processing":
        continue

    if status == "ready":
        print("solution:", result["solution"])
    else:
        print("failed:", result.get("error_code"), result.get("error_description"))

    break
else:
    print("timed out while waiting for the solution")

npm i playwright — collects the parameters from a live page and solves them through this API.

// RecaptchaV2EnterpriseTaskProxyless — collect the parameters from a live page, then solve them here.
// Requirements: npm i playwright   ·   Run: node collect-and-solve.mjs

import { chromium } from 'playwright';

const API_KEY = 'YOUR_API_KEY';
const BASE_URL = 'https://solvecaptcha.net/api';
const PAGE_URL = 'https://example.com/page-with-captcha';

const headers = {
  Authorization: `Bearer ${API_KEY}`,
  Accept: 'application/json',
  'Content-Type': 'application/json',
};

const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));

const post = async (path, payload) => {
  const response = await fetch(`${BASE_URL}/${path}`, {
    method: 'POST',
    headers,
    body: JSON.stringify(payload),
  });

  return response.json();
};

async function collect(pageUrl) {
  const browser = await chromium.launch({ headless: false });
  const page = await browser.newPage();

  await page.goto(pageUrl);
  await page.waitForTimeout(6000);

  const collected = await page.evaluate(() => {
    const el = document.querySelector('[data-sitekey], [data-captcha-id], [data-scene-id]');

    return {
      page_url: location.href,
      user_agent: navigator.userAgent,
      site_key: el
        ? el.getAttribute('data-sitekey') || el.getAttribute('data-captcha-id') || el.getAttribute('data-scene-id')
        : null,
    };
  });

  await browser.close();

  // Fill in the metadata fields documented below before submitting.
  return Object.fromEntries(Object.entries(collected).filter(([, value]) => value != null));
}

const task = { method: 'RecaptchaV2EnterpriseTaskProxyless', ...(await collect(PAGE_URL)) };
console.log('collected task:', JSON.stringify(task, null, 2));

const created = await post('createTask', { task });

if (created.error_id) {
  throw new Error(`createTask failed: ${created.error_code} ${created.error_description}`);
}

console.log('task_id:', created.task_id);

// Keep at least three seconds between polls: the result endpoint is
// rate limited per task.
const deadline = Date.now() + 180_000;

while (Date.now() < deadline) {
  await sleep(3000);

  const result = await post('getTaskResult', { task_id: created.task_id });

  if (result.status === 'processing') continue;

  if (result.status === 'ready') {
    console.log('solution:', result.solution);
  } else {
    console.error('failed:', result.error_code, result.error_description);
  }

  process.exit(0);
}

console.error('timed out while waiting for the solution');

pip install playwright requests && playwright install chromium

# RecaptchaV2EnterpriseTaskProxyless — collect the parameters from a live page, then solve them here.
# Requirements: pip install playwright requests && playwright install chromium
# Run:          python3 collect_and_solve.py

import sys
import time

import requests
from playwright.sync_api import sync_playwright

API_KEY = "YOUR_API_KEY"
BASE_URL = "https://solvecaptcha.net/api"
PAGE_URL = "https://example.com/page-with-captcha"

READ = """
() => {
  const el = document.querySelector('[data-sitekey], [data-captcha-id], [data-scene-id]');
  return {
    page_url: location.href,
    user_agent: navigator.userAgent,
    site_key: el
      ? el.getAttribute('data-sitekey') || el.getAttribute('data-captcha-id') || el.getAttribute('data-scene-id')
      : null,
  };
}
"""


def collect(page_url):
    """Read the widget identifier, then add the metadata documented below."""
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=False)
        page = browser.new_page()
        page.goto(page_url)
        page.wait_for_timeout(6000)
        collected = page.evaluate(READ)
        browser.close()

    return {key: value for key, value in collected.items() if value is not None}

task = {"method": "RecaptchaV2EnterpriseTaskProxyless", **collect(PAGE_URL)}
print("collected task:", task)

session = requests.Session()
session.headers.update({
    "Authorization": f"Bearer {API_KEY}",
    "Accept": "application/json",
})

created = session.post(f"{BASE_URL}/createTask", json={"task": task}, timeout=30).json()

if created.get("error_id"):
    sys.exit(f"createTask failed: {created.get('error_code')} {created.get('error_description')}")

task_id = created["task_id"]
print("task_id:", task_id)

# Keep at least three seconds between polls: the result endpoint is
# rate limited per task.
deadline = time.time() + 180

while time.time() < deadline:
    time.sleep(3)

    result = session.post(
        f"{BASE_URL}/getTaskResult", json={"task_id": task_id}, timeout=30
    ).json()
    status = result.get("status")

    if status == "processing":
        continue

    if status == "ready":
        print("solution:", result["solution"])
    else:
        print("failed:", result.get("error_code"), result.get("error_description"))

    break
else:
    print("timed out while waiting for the solution")