Skip to content
capzy
Login

FunCaptcha · Arkose Labs

Connect Arkose's public key and challenge context. Find the Arkose public key in its loader URL, then capture the current blob when the integration supplies it. Both must describe the same tenant and session.

Get the integration code
POST /createTask · example
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "FunCaptchaTaskProxyLess",
    "websiteURL": "https://example.com/signup",
    "websiteKey": "00000000-0000-0000-0000-000000000000"
  }
}

Illustrative values. Replace the inputs with values from your current integration.

Page URL + public key + optional blobProxyless or your own proxyArkose response token

Find the Arkose public key.

Find the Arkose public key in its loader URL, then capture the current blob when the integration supplies it. Both must describe the same tenant and session.

Your API key authenticates Capzy.
Provider keys, challenge IDs, images, and session values belong inside task.

Read the UUID from the loader path.

  1. In Network, filter for api.js and locate the Arkose loader, usually /v2/<public-key>/api.js.
  2. Copy the UUID in that path into websiteKey. Copy the loader's host into funcaptchaApiJSSubdomain, without https:// or the path.
  3. Use the full parent form URL as websiteURL. Alternatively, search Sources for publicKey or data-pkey on the matching widget.
Input collection example - replace illustrative values
https://YOUR_ARKOSE_HOST/v2/YOUR_PUBLIC_KEY/api.js

websiteKey: YOUR_PUBLIC_KEY
funcaptchaApiJSSubdomain: YOUR_ARKOSE_HOST

Use the loader belonging to this form; a tenant-specific host may differ from the default Arkose host.

How FunCaptcha · Arkose Labs works

FunCaptcha (by Arkose Labs) presents interactive puzzles: rotating 3D objects to match a target, selecting matching images, or identifying objects in scenes. Arkose deployments vary by site. Each site loads `api.js` from its own subdomain and many gate token issuance behind a session-scoped `data` blob the site's frontend generates. Both values come from the page you're targeting — you pass them through to us on `createTask`.

Capzy's proprietary solver returns valid FunCaptcha tokens for rotation, matching, and selection puzzles. Designed for authorized testing and automation.

  • Rotation, matching, and selection puzzles
  • Standard + Enterprise variants
  • Customer-supplied subdomain + blob for full per-site control
  • ML-powered image classification
  • Proxy support for IP-sensitive deployments

Know what goes in.

Choose a field to see its purpose, where to get it, and its place in the request. Optional values omitted from the example can be added when your flow uses them.

The request below follows your selected task configuration.

Request authentication

Required task inputs

Optional context

websiteURL

stringRequired

Full URL of the page that loads the FunCaptcha widget

Where it comes from

Copy the full page URL from the address bar or the document request in Network, including the path where this flow runs.

Open the input guide
Example valuehttps://example.com/signup
POST /createTask · selected configuration
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "FunCaptchaTaskProxyLess",
    "websiteURL": "https://example.com/signup",
    "websiteKey": "00000000-0000-0000-0000-000000000000"
  }
}

The selected field is highlighted when present. Preserve the declared value type and current challenge context.

Make your first request.

Create the task, keep its taskId, and poll until status is ready. Then read the selected variant's solution.

More examples
  1. Create the task

    Send clientKey and the selected task to /createTask from your server. Keep the returned taskId.

  2. Wait for the solution

    Send that same key and ID to /getTaskResult. While processing, wait two seconds before checking again. Stop on Ready or an error.

  3. Apply the result

    Pass solution.token to the application's existing Arkose completion handler or token field. Keep the full opaque string, including its separators, and continue the original session's action.

FunCaptchaTaskProxyLess · Price unavailable / 1,000
solve_funcaptcha.py
import json, os, time
import requests

API = "https://api.capzy.ai"
KEY = os.environ["CAPZY_API_KEY"]
task = json.loads("{\"type\":\"FunCaptchaTaskProxyLess\",\"websiteURL\":\"https://example.com/signup\",\"websiteKey\":\"00000000-0000-0000-0000-000000000000\"}")

def call(path, payload):
    response = requests.post(f"{API}/{path}", json={"clientKey": KEY, **payload}, timeout=30)
    response.raise_for_status()
    data = response.json()
    if data.get("errorId", 0) or data.get("status") == "failed":
        raise RuntimeError(data.get("errorDescription") or data.get("errorCode") or "Task failed")
    return data

created = call("createTask", {"task": task})
for attempt in range(60):
    result = call("getTaskResult", {"taskId": created["taskId"]})
    if result.get("status") == "ready":
        solution = result["solution"]
        print(solution)
        break
    time.sleep(2)
else:
    raise TimeoutError("Task is still processing; keep the taskId to check it later.")

Before runningReplace all illustrative inputs with your captured values. Set CAPZY_API_KEY in your environment. Install requests with pip install requests.

Polling and failuresThe example checks HTTP/API failures, uses 30-second request timeouts, and stops after 60 result checks. Retain taskId if your task is still processing.

Understand what comes back.

Follow this task from creation to completion. Response fields and usage follow your selected request variant.

Arkose response token

Pass solution.token to the application's existing Arkose completion handler or token field. Keep the full opaque string, including its separators, and continue the original session's action.

string
The solved FunCaptcha token — pass this in your form's `fc-token` field or `verification-token` request.
POST /getTaskResult · example response
{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "token": "5e98aaef3c70d7e7f.7732870915|r=us-west-2|metabgclr=transparent|..."
  }
}

Illustrative values. Additional metadata may be returned; only Ready contains a completed solution.

Use the result

Pass solution.token to the application's existing Arkose completion handler or token field. Keep the full opaque string, including its separators, and continue the original session's action.

Execution context result is the parsed Ready response from the polling example. session, when referenced, is your existing requests.Session (or browser-compatible session) with the original cookie jar, headers, and solving proxy configured in session.proxies for both http and https. Keep this client for the complete flow. task is the task object you submitted. For Shape, action_body is the original protected request body as bytes or a string, with its original Content-Type in session.headers. Install curl_cffi when the fragment imports it; match the target's required browser/TLS identity.

Use the result · Python

# Step 3: Use the result — paste the token into the site's captcha form field
token = result["solution"]["token"]
# Browser side: set the textarea value or the hidden input. Then submit.
# Server-to-server: post the token alongside the form fields you normally send.
resp = requests.post("https://target.example.com/submit", data={
    "username": "...",
    "captcha_response": token,   # <-- replace with the field name your site uses
})
print(resp.status_code)

When something doesn't work.

Check your captured values, the selected variant, and the response before starting another task.

Where do I find the public key?

On the target page, open DevTools → Network and look for the Arkose api.js URL — it's `https://<subdomain>.arkoselabs.com/v2/<your-pkey>/api.js`. The 36-char UUID in the path IS your public key. You can also grep the page source for `publicKey:` or `data-pkey=`.

Do I need the `data` blob?

Most production Arkose deployments require it. If your first solve returns `ERROR_FUNCAPTCHA_PARAMS_MISSING`, the blob is almost always why. We can't mint the blob — it's signed against your authentic browser session and a key only the target site and Arkose share. See the docs on how to extract it.

How do I capture the blob?

Open DevTools → Network tab BEFORE the captcha iframe loads (once it loads, the blob is consumed). Filter for `gt2` or `arkoselabs`. Find the request to `POST https://<subdomain>.arkoselabs.com/fc/gt2/public_key/<your-pkey>`. Open its payload — `data[blob]` is the value you want. Pass that string as the `data` parameter on createTask.

Do I need `funcaptchaApiJSSubdomain`?

Yes for almost all production sites — only the default `client-api.arkoselabs.com` deployments work without it. Find your site's subdomain in the api.js script URL on the target page (`https://<this-part>.arkoselabs.com/v2/<pkey>/api.js`) and pass that.

Connect FunCaptcha · Arkose Labs to your workflow.

Get your Capzy API key and use this guide's integration.

Get an API key Full API documentation
UnavailablePer 1,000 solves
UnavailableAverage solve time

FunCaptchaTaskProxyLess · Live configuration
Current stats are unavailable. Check the solver catalog.