Chat with us, powered by LiveChat
← Return to MyDisct Solver

Binance Captcha Image Solving

Solve Binance exchange captcha challenges including grid selection and slide puzzles. Binance uses custom captcha systems for account security and trading verification.

What is Binance Captcha?

Binance, one of the world's largest cryptocurrency exchanges, uses custom captcha systems to protect user accounts and trading activities. These challenges include grid-based image selection, slide puzzles, and sequential clicking tasks. Our service can solve all Binance captcha variants to ensure seamless automated trading and account management.

Captcha Type 

"type": "BINANCE_IMAGE"

Challenge Types

Type Description
grid Select matching images from 3x3 grid
slide Slide puzzle piece to complete image
sequential Click images in specific order
Note

You only need to provide the questionType parameter (e.g., "grid", "slide"). The API automatically formats the question internally. Do not add prefixes like "binance_grid:" to your question text.

Request Format

POST /createTask

Request Parameters

Parameter Type Required Description
captcha.type string required Must be "BINANCE_IMAGE"
captcha.metadata.siteUrl string required Binance page URL
captcha.metadata.siteKey string optional Binance bncUuid parameter
captcha.payload.images array required Array of base64-encoded images
captcha.payload.question string required Question with type prefix
captcha.payload.questionType string required "grid", "slide", or "sequential"
captcha.payload.referenceImages array optional Reference images for comparison

Grid Example

JavaScript 
const response = await fetch('https://solver-api.mydisct.com/createTask', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json',
    'apikey': 'YOUR_API_KEY'
  },
  body: JSON.stringify({
    auth: { token: 'YOUR_API_KEY' },
    context: { source: 'api', version: '1.0.0' },
    captcha: {
      type: 'BINANCE_IMAGE',
      metadata: {
        siteUrl: 'https://www.binance.com',
        siteKey: 'bnc_uuid_here'
      },
      payload: {
        images: [
          'image_1_base64',
          'image_2_base64',
        ],
        question: '请选择所有包含猫的图片',
        questionType: 'grid',
        referenceImages: []
      }
    }
  })
});

Response Format

Create Task Response

JSON 
{
  "success": true,
  "service": "MyDisct Solver",
  "message": "Captcha is being processed",
  "task": {
    "id": "MyDisctSolver_abc123",
    "status": "processing"
  }
}

Fetch Result Response (Processing)

JSON 
{
  "success": true,
  "service": "MyDisct Solver",
  "message": "Captcha is being processed",
  "task": {
    "id": "MyDisctSolver_abc123",
    "status": "processing"
  }
}

Fetch Result Response (Completed)

JSON 
{
  "success": true,
  "service": "MyDisct Solver",
  "message": "Captcha solved successfully",
  "task": {
    "id": "MyDisctSolver_abc123",
    "status": "completed",
    "result": {
      "answers": [0, 3, 7],
      "timestamp": "2025-11-05T12:34:56.789Z"
    }
  }
}

For grid: array of selected image indices. For slide: [x_position, y_position].

Python Example

Python 
import requests
import time

def solve_binance(images, question, question_type, site_url, api_key):
    create_response = requests.post(
        'https://solver-api.mydisct.com/createTask',
        headers={'Content-Type': 'application/json', 'apikey': api_key},
        json={
            'auth': {'token': api_key},
            'context': {'source': 'api', 'version': '1.0.0'},
            'captcha': {
                'type': 'BINANCE_IMAGE',
                'metadata': {'siteUrl': site_url},
                'payload': {
                    'images': images,
                    'question': question,
                    'questionType': question_type,
                    'referenceImages': []
                }
            }
        }
    )
    
    create_data = create_response.json()
    if not create_data['success']:
        raise Exception(create_data['error']['message'])
    
    task_id = create_data['task']['id']
    
    while True:
        time.sleep(3)
        result_response = requests.post(
            'https://solver-api.mydisct.com/fetchResult',
            headers={'Content-Type': 'application/json', 'apikey': api_key},
            json={'taskId': task_id}
        )
        
        result_data = result_response.json()
        if result_data['task']['status'] == 'completed':
            return result_data['task']['result']['answers']
        elif result_data['task']['status'] == 'failed':
            raise Exception('Captcha solving failed')

solution = solve_binance(
    images=['img1', 'img2', 'img3', 'img4', 'img5', 'img6', 'img7', 'img8', 'img9'],
    question='请选择所有包含猫的图片',
    question_type='grid',
    site_url='https://www.binance.com',
    api_key='YOUR_API_KEY'
)
print(f'Selected indices: {solution}')

Implementation Guide

Step 1: Extract Binance Captcha Challenge

First, you need to extract the captcha challenge from Binance's login/trading page:

JavaScript 
// Extract Binance captcha images and question
function extractBinanceCaptcha() {
  const captchaContainer = document.querySelector('[class*="captcha"]') ||
                          document.querySelector('[data-testid*="captcha"]') ||
                          document.querySelector('.binance-captcha');

  if (!captchaContainer) return null;

  const questionElement = captchaContainer.querySelector('.captcha-question') ||
                         captchaContainer.querySelector('[class*="question"]');
  const question = questionElement ? questionElement.textContent.trim() : '';

  const imageElements = captchaContainer.querySelectorAll('img');
  const images = [];

  for (const img of imageElements) {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    canvas.width = img.naturalWidth;
    canvas.height = img.naturalHeight;
    ctx.drawImage(img, 0, 0);
    const base64 = canvas.toDataURL('image/jpeg').split(',')[1];
    images.push(base64);
  }

  const questionType = question.includes('顺序') || question.includes('sequential') ?
                      'sequential' : 'grid';

  const bncUuid = captchaContainer.getAttribute('data-bnc-uuid') ||
                 document.querySelector('input[name="bncUuid"]')?.value;

  return { question, images, questionType, bncUuid };
}

const captchaData = extractBinanceCaptcha();

Step 2: Send to API and Poll for Result

JavaScript 
async function solveBinanceCaptcha(images, question, questionType, siteUrl, bncUuid) {
  const createResponse = await fetch('https://solver-api.mydisct.com/createTask', {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'apikey': 'YOUR_API_KEY'
    },
    body: JSON.stringify({
      auth: { token: 'YOUR_API_KEY' },
      context: { source: 'api', version: '1.0.0' },
      captcha: {
        type: 'BINANCE_IMAGE',
        metadata: { siteUrl },
        payload: {
          images,
          question,
          questionType,
          bncUuid  // Include if available
        }
      }
    })
  });

  const createData = await createResponse.json();

  if (!createData.success) {
    throw new Error(createData.error.message);
  }

  const taskId = createData.task.id;

  while (true) {
    await new Promise(resolve => setTimeout(resolve, 3000)); // Wait 3 seconds

    const resultResponse = await fetch('https://solver-api.mydisct.com/fetchResult', {
      method: 'POST',
      headers: {
        'Content-Type': 'application/json',
        'apikey': 'YOUR_API_KEY'
      },
      body: JSON.stringify({ taskId })
    });

    const resultData = await resultResponse.json();

    if (resultData.task.status === 'completed') {
      return resultData.task.result.answers;
    } else if (resultData.task.status === 'failed') {
      throw new Error('Binance captcha solving failed');
    }
  }
}

const { images, question, questionType, bncUuid } = extractBinanceCaptcha();
const solution = await solveBinanceCaptcha(images, question, questionType, 'https://www.binance.com', bncUuid);

console.log('Solution:', solution); // [0, 2, 5] for grid, [0, 2, 5] for sequential

Step 3: Apply Solution to Binance

JavaScript 
function applyBinanceSolution(solution, questionType) {
  const captchaContainer = document.querySelector('[class*="captcha"]') ||
                          document.querySelector('.binance-captcha');

  if (questionType === 'grid' || questionType === 'sequential') {
    const imageTiles = captchaContainer.querySelectorAll('img');

    solution.forEach(index => {
      if (imageTiles[index]) {
        const clickEvent = new MouseEvent('click', {
          view: window,
          bubbles: true,
          cancelable: true,
          clientX: imageTiles[index].getBoundingClientRect().left + 10,
          clientY: imageTiles[index].getBoundingClientRect().top + 10
        });
        imageTiles[index].dispatchEvent(clickEvent);
      }
    });
  }

  setTimeout(() => {
    const submitButton = captchaContainer.querySelector('button[type="submit"]') ||
                        captchaContainer.querySelector('.captcha-submit') ||
                        document.querySelector('.login-button');
    if (submitButton) {
      submitButton.click();
    }
  }, 1000);
}

applyBinanceSolution(solution, questionType);

Best Practices

Recommendations
  • Include bncUuid when available for better accuracy
  • Question text often in Chinese - include as-is without translation
  • Grid challenges use 3x3 format (9 images)
  • Sequential challenges require clicking images in the correct order
  • Provide questionType parameter - the API handles formatting automatically
  • Poll every 3 seconds for faster response
  • Implement proper error handling for failed tasks

Common Issues

Issue: Captcha container not found

Solution: Binance frequently updates their captcha implementation. Check for new class names and selectors. The captcha may appear in iframes or dynamic containers.

Issue: Question text in Chinese not recognized

Solution: Always include the question text exactly as it appears, including Chinese characters. Do not translate or modify the text.

Issue: Wrong question type detected

Solution: Check for keywords like "顺序" (sequential) or "选择" (select) to properly determine the question type. Sequential challenges require ordered clicking.

Issue: bncUuid parameter missing

Solution: The bncUuid is optional but improves accuracy. Look for it in hidden inputs or data attributes. It's not always required for solving.