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

FunCaptcha Image Solving

Solve Arkose Labs FunCaptcha image challenges. FunCaptcha presents interactive puzzles requiring image analysis and pattern matching. Our AI handles various FunCaptcha game types with 99.2% accuracy.

What is FunCaptcha Image?

FunCaptcha (also known as Arkose Labs captcha) is a sophisticated anti-bot system that uses interactive puzzles instead of traditional text or image challenges. It presents users with various game-like tasks that require image analysis, such as matching objects, identifying patterns, or solving simple puzzles. Our API supports all FunCaptcha game types and provides accurate solutions.

Captcha Type

Use the following captcha type identifier in your API requests: 

"type": "FUNCAPTCHA_IMAGE"

Request Format

POST /createTask

Request Parameters

Parameter Type Required Description
auth.token string required Your API key
captcha.type string required Must be "FUNCAPTCHA_IMAGE"
captcha.metadata.siteUrl string required URL where captcha appears
captcha.payload.images array required Array with single base64-encoded image
captcha.payload.question string required Challenge instruction text

Example Request

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: 'FUNCAPTCHA_IMAGE',
      metadata: {
        siteUrl: 'https://example.com'
      },
      payload: {
        images: ['/9j/4AAQSkZJRgABAQAAAQABAAD...'],  // Single image
        question: 'Use the arrows to rotate the animal to face in the direction of the hand'
      }
    }
  })
});

const data = await response.json();
console.log('Task ID:', data.task.id);

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": [2],
      "timestamp": "2025-11-05T12:34:56.789Z"
    }
  }
}
Understanding the Response

The answers array contains the solution. For rotation challenges, the number represents rotation clicks (0-5). For selection challenges, it contains selected indices. For matching challenges, it contains pairs of indices to match.

Python Example

Python 
import requests
import time

def solve_funcaptcha(image_base64, question, site_url, api_key):
    # 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},
            'context': {'source': 'api', 'version': '1.0.0'},
            'captcha': {
                'type': 'FUNCAPTCHA_IMAGE',
                'metadata': {'siteUrl': site_url},
                'payload': {
                    'images': [image_base64],
                    'question': question
                }
            }
        }
    )
    
    create_data = create_response.json()
    if not create_data['success']:
        raise Exception(create_data['error']['message'])
    
    task_id = create_data['task']['id']
    
    # Poll for result
    while True:
        time.sleep(5)  # FunCaptcha takes longer
        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')

# Usage
solution = solve_funcaptcha(
    image_base64='base64_encoded_image',
    question='Use the arrows to rotate the animal to face in the direction of the hand',
    site_url='https://example.com',
    api_key='YOUR_API_KEY'
)
print(f'Solution: {solution}')

Implementation Guide

Step 1: Extract Images from FunCaptcha

FunCaptcha iframes are complex and may change. Here's how to extract the required data:

JavaScript 
// Extract FunCaptcha data
function extractFunCaptchaData() {
  const iframe = document.querySelector('iframe[src*="arkoselabs"]');
  if (!iframe) return null;

  const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;

  const instruction = iframeDoc.querySelector('.instructions-text')?.textContent ||
                     iframeDoc.querySelector('.prompt-text')?.textContent;

  const imageElement = iframeDoc.querySelector('.captcha-image img') ||
                      iframeDoc.querySelector('img[alt*="captcha"]') ||
                      iframeDoc.querySelector('.game-canvas img');

  let imageBase64 = null;
  if (imageElement) {
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');
    canvas.width = imageElement.naturalWidth;
    canvas.height = imageElement.naturalHeight;
    ctx.drawImage(imageElement, 0, 0);
    imageBase64 = canvas.toDataURL('image/png').split(',')[1];
  }

  return { instruction, imageBase64 };
}

Step 2: Handle Multiple Rounds

FunCaptcha often requires multiple rounds of interaction. Handle this by polling and resubmitting:

JavaScript 
async function solveFunCaptchaRounds(siteUrl) {
  let roundNumber = 0;
  const maxRounds = 10; // Safety limit

  while (roundNumber < maxRounds) {
    roundNumber++;

    const { instruction, imageBase64 } = extractFunCaptchaData();

    if (!instruction || !imageBase64) {
      throw new Error('Could not extract FunCaptcha data');
    }

    console.log(`Solving round ${roundNumber}...`);

    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: 'FUNCAPTCHA_IMAGE',
          metadata: { siteUrl },
          payload: {
            images: [imageBase64],
            question: instruction
          }
        }
      })
    });

    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, 5000));

      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') {
        const solution = resultData.task.result.answers;

        applyFunCaptchaSolution(solution);

        await new Promise(resolve => setTimeout(resolve, 2000));

        if (isFunCaptchaCompleted()) {
          console.log('FunCaptcha completed successfully!');
          return true;
        }

        break; // Go to next round

      } else if (resultData.task.status === 'failed') {
        throw new Error('FunCaptcha solving failed');
      }
    }
  }

  throw new Error('FunCaptcha exceeded maximum rounds');
}

function applyFunCaptchaSolution(solution) {
  const iframe = document.querySelector('iframe[src*="arkoselabs"]');
  const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;

  console.log('Applying solution:', solution);
}

function isFunCaptchaCompleted() {
  const iframe = document.querySelector('iframe[src*="arkoselabs"]');
  const iframeDoc = iframe.contentDocument || iframe.contentWindow.document;

  return iframeDoc.querySelector('.completed') ||
         iframeDoc.querySelector('.success') ||
         !iframeDoc.querySelector('.captcha-image');
}

await solveFunCaptchaRounds('https://example.com');

Best Practices

Recommendations
  • FunCaptcha requires 5-10 seconds solving time per round
  • Include complete question text with all instructions
  • Send high-quality images (avoid compression artifacts)
  • Handle multiple rounds (FunCaptcha often requires 3-10 rounds)
  • Poll every 5 seconds instead of 3 seconds
  • Implement proper error handling for failed rounds
  • Monitor for interface changes as Arkose Labs updates frequently

Common Issues

Issue: Multiple rounds required

Solution: FunCaptcha often requires 3-10 rounds of interaction. Implement polling logic to handle multiple rounds automatically.

Issue: Game interface changes frequently

Solution: Arkose Labs updates their interface regularly. Monitor for changes in CSS selectors and update your extraction logic accordingly.

Issue: Long solving times

Solution: FunCaptcha solving takes 5-10 seconds per round. Increase polling intervals to 5 seconds and implement proper timeout handling.

Issue: Image extraction fails

Solution: FunCaptcha uses canvas elements and complex DOM structures. Ensure you're extracting images at the right time and handling canvas-to-base64 conversion properly.