Temu CAPTCHA

Match the mode to its images.

Identify swap, slide, or click before collecting images. The required companion image or instruction and the returned answer depend on that mode.

import base64
from pathlib import Path

def image_bytes(filename):
    return base64.b64encode(Path(filename).read_bytes()).decode("ascii")

task_inputs = {
    "challengeType": "slide",
    "image": image_bytes("background.png"),
    "pieceImage": image_bytes("piece.png")
}

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.

Send the scrambled image. Include refImage when available; without it the solver uses edge matching. Drag the first returned coordinate to the second in the same puzzle session.

{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "TemuCaptchaTaskProxyLess",
    "challengeType": "swap",
    "image": "<base64 scrambled image>",
    "refImage": "<base64 reference image, when available>"
  }
}

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

   Use the selected mode's output: slideDistance/slideProportion for sliding or coordinates/clickTargets for click tasks. Apply any swap answer using that puzzle's verification contract, preserving image geometry and session context.

import json, os, time
import requests

API = "https://api.capzy.ai"
KEY = os.environ["CAPZY_API_KEY"]
task = json.loads("{\"type\":\"TemuCaptchaTaskProxyLess\",\"challengeType\":\"swap\",\"image\":\"<base64 scrambled image>\",\"refImage\":\"<base64 reference image, when available>\"}")

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.")

Understand what comes back.

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

{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "coordinates": [
      {
        "x": 80,
        "y": 60
      },
      {
        "x": 240,
        "y": 180
      }
    ]
  }
}

sol = result["solution"]
image = page.locator("img[data-captcha-image]")  # Replace with the puzzle image.
image.scroll_into_view_if_needed()
rect = image.bounding_box()
size = image.evaluate("img => ({width: img.naturalWidth, height: img.naturalHeight})")
if not rect or not size["width"] or not size["height"]:
    raise RuntimeError("Puzzle image is not ready")
width = task.get("puzzleWidth") or size["width"]
points = [(rect["x"] + p["x"] / width * rect["width"],
           rect["y"] + p["y"] / size["height"] * rect["height"]) for p in sol["coordinates"]]
start, end = points
page.mouse.move(*start)
page.mouse.down()
page.mouse.move(*end, steps=20)
page.mouse.up()

When something doesn't work.

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