Capy Puzzle

Keep the puzzle answer and verification keys together. Collect the Capy puzzle's public key and any configured API host. Verification uses three related result fields from one solved puzzle.

Get the integration code

POST /createTask · example

{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "CapyTaskProxyLess",
    "websiteURL": "https://example.jp/form",
    "websiteKey": "PUZZLE_abc123def456"
  }
}

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

Page URL + Capy public keyProxyless or your own proxycaptchakey + challengekey + answer

Find the Capy widget configuration.

Collect the Capy puzzle's public key and any configured API host. Verification uses three related result fields from one solved puzzle.

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

Read the widget initialization.

In Sources, locate the Capy puzzle initialization or its public widget configuration.
Copy the public puzzle key into websiteKey and the full form page URL into websiteURL.
If you maintain the integration, compare the configured public key with the puzzle widget on that form.

Input collection example - replace illustrative values

{
  "websiteURL": "https://example.com/form",
  "websiteKey": "YOUR_CAPY_PUBLIC_PUZZLE_KEY"
}

The public puzzle key is an input; returned challengekey and captchakey are verification output.

How Capy Puzzle works

Capy (capy.me) is a Japanese captcha service that presents a jigsaw puzzle — the user drags a puzzle piece to complete an image. It's used primarily on Japanese websites and some international sites.

Capzy's proprietary solver returns the Capy Puzzle solution payload ready for direct submission. Designed for authorized testing and automation.

Solves the jigsaw puzzle reliably
Rare-coverage captcha — most solvers don't support it
Japanese site compatibility
High-quality solves

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

The page URL

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.jp/form

POST /createTask · selected configuration

{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "CapyTaskProxyLess",
    "websiteURL": "https://example.jp/form",
    "websiteKey": "PUZZLE_abc123def456"
  }
}

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

Create the task
Send clientKey and the selected task to /createTask from your server. Keep the returned taskId.
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.
Apply the result
Submit solution.captchakey, solution.challengekey, and solution.answer together to the original Capy verification flow, retaining its form session.

CapyTaskProxyLess · $2.00 / 1,000

solve_capy.py

import json, os, time
import requests

API = "https://api.capzy.ai"
KEY = os.environ["CAPZY_API_KEY"]
task = json.loads("{\"type\":\"CapyTaskProxyLess\",\"websiteURL\":\"https://example.jp/form\",\"websiteKey\":\"PUZZLE_abc123def456\"}")

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.

captchakey + challengekey + answer

Submit solution.captchakey, solution.challengekey, and solution.answer together to the original Capy verification flow, retaining its form session.

string: Challenge identifier
string: Per-session challenge value
string: Hex-encoded solved puzzle answer

POST /getTaskResult · example response

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "captchakey": "<challenge identifier>",
    "challengekey": "<per-session challenge value>",
    "answer": "8a3f<hex-encoded solved puzzle position>"
  }
}

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

Use the result

Submit solution.captchakey, solution.challengekey, and solution.answer together to the original Capy verification flow, retaining its form session.

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: Capy — submit all three values to the form
sol = result["solution"]
requests.post("https://target.example.com/submit", data={
    "capy_captchakey":  sol["captchakey"],
    "capy_challengekey": sol["challengekey"],
    "capy_answer":      sol["answer"],
})

When something doesn't work.

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

Connect Capy Puzzle to your workflow.

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

Get an API key Full API documentation

$2.00Per 1,000 solves

3.9sAverage solve time

CapyTaskProxyLess · Live configuration