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

FaucetPay Captcha Image Solving

Solve FaucetPay captcha challenges including slider puzzles and icon click captchas. FaucetPay uses these captcha types to protect faucet claims and user actions.

What is FaucetPay Captcha?

FaucetPay, a popular cryptocurrency microwallet and faucet platform, uses two types of image-based captcha challenges: Slider (drag puzzle piece to correct position) and Icons (click icons in the correct order). Our service automatically solves both types, returning precise coordinates for seamless automation.

Captcha Type 

"type": "FAUCETPAY_IMAGE"

Supported Question Types

Question Type Description Response Format
slider Slide puzzle piece to correct position [x_offset, 0] - Pixel offset for slider
icons Click icons in specified order [[x1,y1], [x2,y2], ...] - Click coordinates

Pricing

Service Price per Solve Average Time
FaucetPay Slider $0.0015 ~3 seconds
FaucetPay Icons $0.0015 ~5 seconds

Slider Captcha Request

POST /createTask

Request Parameters

Parameter Type Required Description
captcha.type string required Must be "FAUCETPAY_IMAGE"
captcha.payload.questionType string required Must be "slider"
captcha.payload.images array required Array of 2 base64 images: [background, piece]

Slider Request 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',
      appId: 0 
    },
    context: { 
      source: 'api', 
      version: '1.0.0' 
    },
    captcha: {
      type: 'FAUCETPAY_IMAGE',
      metadata: {
        siteUrl: 'https://faucetpay.io'
      },
      payload: {
        questionType: 'slider',
        images: [
          'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...',  // Background image
          'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...'   // Slider piece
        ]
      }
    }
  })
});

const data = await response.json();
console.log(data);

Slider Response (Completed)

JSON 
{
  "success": true,
  "service": "MyDisct Solver",
  "message": "Captcha solved successfully",
  "task": {
    "id": "MyDisctSolver_1234567890",
    "status": "completed",
    "result": {
      "answers": [142, 0],
      "timestamp": "2025-01-01T12:00:00.000Z"
    }
  }
}
Understanding Slider Response

The answers array contains [x_offset, 0] where:
• 142 - Number of pixels to move the slider horizontally
• 0 - Y offset (always 0 for horizontal sliders)

Icons Captcha Request

POST /createTask

Request Parameters

Parameter Type Required Description
captcha.type string required Must be "FAUCETPAY_IMAGE"
captcha.payload.questionType string required Must be "icons"
captcha.payload.images array required Array with 1 base64 image (body/main image)
captcha.payload.question string required Order of icons to click (e.g., "calendar,buy,star")
Important: Question Parameter

The question parameter must contain the order of icons to click, separated by commas. This is typically displayed on the FaucetPay page as "Click: calendar, buy, star" or similar. Extract the icon names and pass them in order.

Icons Request 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',
      appId: 0 
    },
    context: { 
      source: 'api', 
      version: '1.0.0' 
    },
    captcha: {
      type: 'FAUCETPAY_IMAGE',
      metadata: {
        siteUrl: 'https://faucetpay.io'
      },
      payload: {
        questionType: 'icons',
        question: 'calendar,buy,star',  // Order of icons to click
        images: [
          'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA...'  // Main image with icons
        ]
      }
    }
  })
});

const data = await response.json();
console.log(data);

Icons Response (Completed)

JSON 
{
  "success": true,
  "service": "MyDisct Solver",
  "message": "Captcha solved successfully",
  "task": {
    "id": "MyDisctSolver_1234567890",
    "status": "completed",
    "result": {
      "answers": [[45, 120], [180, 85], [290, 150]],
      "timestamp": "2025-01-01T12:00:00.000Z"
    }
  }
}
Understanding Icons Response

The answers array contains click coordinates in order:
• [45, 120] - First click (calendar icon) at x=45, y=120
• [180, 85] - Second click (buy icon) at x=180, y=85
• [290, 150] - Third click (star icon) at x=290, y=150

Python Example

Python 
import requests
import time
import base64

def solve_faucetpay_slider(background_image, piece_image, api_key):
    """
    Solve FaucetPay slider captcha
    
    Args:
        background_image: Path to background image or base64 string
        piece_image: Path to slider piece image or base64 string
        api_key: Your API key
    
    Returns:
        int: Pixel offset for slider movement
    """
    
    def to_base64(image):
        if image.startswith('data:image'):
            return image
        with open(image, 'rb') as f:
            encoded = base64.b64encode(f.read()).decode()
            return f'data:image/png;base64,{encoded}'
    
    images = [to_base64(background_image), to_base64(piece_image)]
    
    # Create task
    create_response = requests.post(
        'https://solver-api.mydisct.com/createTask',
        headers={'Content-Type': 'application/json', 'apikey': api_key},
        json={
            'auth': {'token': api_key, 'appId': 0},
            'context': {'source': 'api', 'version': '1.0.0'},
            'captcha': {
                'type': 'FAUCETPAY_IMAGE',
                'metadata': {'siteUrl': 'https://faucetpay.io'},
                'payload': {
                    'questionType': 'slider',
                    'images': images
                }
            }
        }
    )
    
    create_data = create_response.json()
    if not create_data['success']:
        raise Exception(f"Task creation failed: {create_data.get('error', {}).get('message')}")
    
    task_id = create_data['task']['id']
    print(f"Task created: {task_id}")
    
    # Poll for result
    while True:
        time.sleep(3)
        result_response = requests.get(
            f'https://solver-api.mydisct.com/getTaskResult?taskId={task_id}',
            headers={'apikey': api_key}
        )
        result_data = result_response.json()
        
        if result_data['task']['status'] == 'completed':
            offset = result_data['task']['result']['answers'][0]
            print(f"Slider solved! Move {offset} pixels")
            return offset
        elif result_data['task']['status'] == 'failed':
            raise Exception('Captcha solving failed')
        
        print("Processing...")

def solve_faucetpay_icons(body_image, icon_order, api_key):
    """
    Solve FaucetPay icons captcha
    
    Args:
        body_image: Path to main image or base64 string
        icon_order: Comma-separated icon names (e.g., "calendar,buy,star")
        api_key: Your API key
    
    Returns:
        list: Click coordinates [[x1,y1], [x2,y2], ...]
    """
    
    def to_base64(image):
        if image.startswith('data:image'):
            return image
        with open(image, 'rb') as f:
            encoded = base64.b64encode(f.read()).decode()
            return f'data:image/png;base64,{encoded}'
    
    # Create task
    create_response = requests.post(
        'https://solver-api.mydisct.com/createTask',
        headers={'Content-Type': 'application/json', 'apikey': api_key},
        json={
            'auth': {'token': api_key, 'appId': 0},
            'context': {'source': 'api', 'version': '1.0.0'},
            'captcha': {
                'type': 'FAUCETPAY_IMAGE',
                'metadata': {'siteUrl': 'https://faucetpay.io'},
                'payload': {
                    'questionType': 'icons',
                    'question': icon_order,
                    'images': [to_base64(body_image)]
                }
            }
        }
    )
    
    create_data = create_response.json()
    if not create_data['success']:
        raise Exception(f"Task creation failed: {create_data.get('error', {}).get('message')}")
    
    task_id = create_data['task']['id']
    print(f"Task created: {task_id}")
    
    # Poll for result
    while True:
        time.sleep(3)
        result_response = requests.get(
            f'https://solver-api.mydisct.com/getTaskResult?taskId={task_id}',
            headers={'apikey': api_key}
        )
        result_data = result_response.json()
        
        if result_data['task']['status'] == 'completed':
            coords = result_data['task']['result']['answers']
            print(f"Icons solved! Click coordinates: {coords}")
            return coords
        elif result_data['task']['status'] == 'failed':
            raise Exception('Captcha solving failed')
        
        print("Processing...")

# Usage examples
try:
    # Slider example
    offset = solve_faucetpay_slider('background.png', 'piece.png', 'YOUR_API_KEY')
    print(f"Move slider {offset} pixels to the right")
    
    # Icons example
    coords = solve_faucetpay_icons('captcha.png', 'calendar,buy,star', 'YOUR_API_KEY')
    for i, (x, y) in enumerate(coords):
        print(f"Click {i+1}: x={x}, y={y}")
        
except Exception as e:
    print(f"Error: {e}")

Implementation Guide

Step 1: Extract FaucetPay Captcha

JavaScript 
// Extract FaucetPay captcha images
function extractFaucetPayCaptcha() {
  const captchaContainer = document.querySelector('.captcha-container') ||
                          document.querySelector('[class*="captcha"]');

  if (!captchaContainer) {
    console.error('Captcha container not found');
    return null;
  }

  const isSlider = captchaContainer.querySelector('.slider-piece') !== null;
  const isIcons = captchaContainer.querySelector('.icon-grid') !== null;

  function imageToBase64(img) {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    canvas.width = img.naturalWidth;
    canvas.height = img.naturalHeight;
    ctx.drawImage(img, 0, 0);
    return canvas.toDataURL('image/png');
  }

  if (isSlider) {
    const background = captchaContainer.querySelector('.slider-background img');
    const piece = captchaContainer.querySelector('.slider-piece img');
    
    return {
      questionType: 'slider',
      images: [imageToBase64(background), imageToBase64(piece)]
    };
  }

  if (isIcons) {
    const bodyImage = captchaContainer.querySelector('.icon-grid img');
    const taskText = captchaContainer.querySelector('.captcha-task')?.textContent;
    const iconOrder = taskText?.replace(/Click:|click:/gi, '').trim();
    
    return {
      questionType: 'icons',
      question: iconOrder,
      images: [imageToBase64(bodyImage)]
    };
  }

  return null;
}

const captchaData = extractFaucetPayCaptcha();
console.log('Extracted:', captchaData);

Step 2: Apply Solution

JavaScript 
// Apply slider solution
function applySliderSolution(offset) {
  const slider = document.querySelector('.slider-handle');
  const track = document.querySelector('.slider-track');
  
  if (!slider || !track) return;
  
  const startX = slider.getBoundingClientRect().left;
  const endX = startX + offset;
  
  slider.dispatchEvent(new MouseEvent('mousedown', { clientX: startX, bubbles: true }));
  document.dispatchEvent(new MouseEvent('mousemove', { clientX: endX, bubbles: true }));
  document.dispatchEvent(new MouseEvent('mouseup', { clientX: endX, bubbles: true }));
}

function applyIconsSolution(coordinates) {
  const container = document.querySelector('.icon-grid');
  const rect = container.getBoundingClientRect();
  
  coordinates.forEach(([x, y], index) => {
    setTimeout(() => {
      const clickX = rect.left + x;
      const clickY = rect.top + y;
      
      container.dispatchEvent(new MouseEvent('click', {
        clientX: clickX,
        clientY: clickY,
        bubbles: true
      }));
    }, index * 200); // 200ms delay between clicks
  });
}

Best Practices

Recommendations
  • Image Quality: Use original resolution images for best accuracy
  • Question Format: For icons, extract the exact icon names from the page
  • Base64 Format: Include the data URI prefix (data:image/png;base64,...)
  • Polling Interval: Poll every 3 seconds for optimal response time
  • Error Handling: Implement retry logic for failed requests
  • Timeout: Set a maximum timeout of 2 minutes for polling

Common Issues

Issue: "FaucetPay slider captcha requires exactly 2 images"

Solution: Ensure you're sending exactly 2 images for slider type: the background image first, then the slider piece image.

Issue: "FaucetPay icons captcha requires question parameter"

Solution: For icons type, you must provide the question parameter with the order of icons to click (e.g., "calendar,buy,star").

Issue: Solution not working on FaucetPay

Solution: FaucetPay may update their captcha implementation. Ensure you're extracting images correctly and applying coordinates relative to the captcha container.