Skip to content
capzy
Login

Binance bCAPTCHA

Carry a fresh challenge through to its verified token. Trigger the original action to obtain a fresh validateId. This task cannot discover that challenge identifier from the page URL alone.

Get the integration code
POST /createTask · example
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "BinanceCaptchaTask",
    "websiteURL": "https://accounts.binance.com/en/login",
    "validateId": "YOUR_FRESH_VALIDATE_ID",
    "bizId": "login"
  }
}

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

Current validateId + business flowDirect task integrationVerified token + matching validateId

Trigger the challenge in your client.

Trigger the original action to obtain a fresh validateId. This task cannot discover that challenge identifier from the page URL alone.

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

Read the challenge response for this attempt.

  1. Enable Preserve log in Network, then trigger the CAPTCHA in the original login or account flow.
  2. Inspect the challenge response or getCaptcha request and copy the fresh validateId into the required field.
  3. Keep the application cookies and action state that issued this ID. Obtain a new ID when starting a separate attempt.
Input collection example - replace illustrative values
{
  "validateId": "YOUR_FRESH_VALIDATE_ID",
  "websiteURL": "https://accounts.binance.com/en/login"
}

websiteURL is optional page context. validateId is required and must come from the current action.

How Binance bCAPTCHA works

Binance bCAPTCHA protects account actions with a slider challenge. The current task consumes the validateId created by the original flow and returns a token after validating the slider.

Capture a fresh validateId from the action that triggered the challenge. Capzy fetches the puzzle, determines the slide trajectory, and validates it using the matching bizId. The result contains token and validateId for continuing that same action.

  • Consumes the current challenge's validateId
  • Matches the original business flow with bizId
  • Validates the slider before returning the token
  • Returns token and validateId together

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

validateId

stringRequired

The fresh challenge identifier from the original action. Trigger the challenge in your client first; the solver does not discover this value from websiteURL.

Where it comes from

Trigger the original Binance action, then copy its fresh validateId from the challenge response or getCaptcha request in Network. A page URL alone does not supply it.

Open the input guide
Example valueYOUR_FRESH_VALIDATE_ID
POST /createTask · selected configuration
{
  "clientKey": "capzy_YOUR_API_KEY",
  "task": {
    "type": "BinanceCaptchaTask",
    "websiteURL": "https://accounts.binance.com/en/login",
    "validateId": "YOUR_FRESH_VALIDATE_ID",
    "bizId": "login"
  }
}

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

    Forward solution.token and solution.validateId together through the original action's expected transport. Preserve the session that requested the challenge and avoid mixing attempts.

BinanceCaptchaTask · Price unavailable / 1,000
solve_binance.py
import json, os, time
import requests

API = "https://api.capzy.ai"
KEY = os.environ["CAPZY_API_KEY"]
task = json.loads("{\"type\":\"BinanceCaptchaTask\",\"websiteURL\":\"https://accounts.binance.com/en/login\",\"validateId\":\"YOUR_FRESH_VALIDATE_ID\",\"bizId\":\"login\"}")

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.

Verified token + matching validateId

Forward solution.token and solution.validateId together through the original action's expected transport. Preserve the session that requested the challenge and avoid mixing attempts.

string
The token returned after validating this slider challenge. Supply it through the original action's expected token transport.
string
The matching challenge identifier echoed from your task. Keep it paired with this token.
POST /getTaskResult · example response
{
  "errorId": 0,
  "status": "ready",
  "solution": {
    "token": "YOUR_VERIFIED_BCAPTCHA_TOKEN",
    "validateId": "YOUR_FRESH_VALIDATE_ID"
  }
}

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

Continue with the verified challenge token

The current Binance task returns token and validateId after validating the slider. Continue the same action using its expected token transport; it is not a GeeTest five-field result. Replace YOUR_ACTION and include the original application fields.

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
sol = result["solution"]
# The solver already validated this bCAPTCHA attempt. Continue the original action.
payload = {"token": sol["token"], "validateId": sol["validateId"]}
# Merge with the original action's fields and match its token transport.
response = session.post("https://target.example.com/YOUR_ACTION",
    json=payload, timeout=30)
response.raise_for_status()

When something doesn't work.

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

Where do I get validateId?

Trigger the original account action in your client. In Network, inspect its challenge response or getCaptcha request and copy the fresh validateId from that same attempt. Also capture bizId when the flow is not login.

Can I send only websiteURL?

No. The current solver requires validateId to retrieve and validate the puzzle; the page URL alone does not discover it.

How do I use the result?

Continue the original action with solution.token through the token field or header that action expects, preserving its matching validateId and session. The current output is token plus validateId, rather than a GeeTest validation tuple.

Connect Binance bCAPTCHA 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

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