Error Handling

{
  "success": false,
  "service": "MyDisct Solver",
  "message": "Brief error description",
  "error": {
    "code": 400,
    "message": "Detailed error message"
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "API_KEY_REQUIRED",
    "message": "API Key is required. Please provide it in the header as x-api-key or apikey."
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "INVALID_API_KEY",
    "message": "Invalid or inactive API Key. Please check your credentials."
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "ACCOUNT_SUSPENDED",
    "message": "Your account has been suspended. Please contact support for more information."
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "ACCOUNT_INACTIVE",
    "message": "Your account is inactive. Please activate your account or contact support."
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "INSUFFICIENT_BALANCE",
    "message": "Insufficient balance"
  },
  "required": 0.002,
  "current_balance": 0.001
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "INVALID_REQUEST",
    "message": "Invalid request body format"
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "MISSING_REQUIRED_FIELD",
    "message": "Missing required field: siteKey"
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "MISSING_SITE_URL",
    "message": "Missing required field: siteUrl. Please provide the website URL where the captcha appears."
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "EMPTY_FIELD_VALUE",
    "message": "siteUrl cannot be empty"
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "INVALID_URL_FORMAT",
    "message": "Invalid URL format. URL must start with http:// or https://"
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "EMPTY_ARRAY_ELEMENTS",
    "message": "images array contains empty elements"
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "INVALID_IMAGE_COUNT",
    "message": "Temu captcha requires exactly 4 images, received 2"
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "MISSING_PROXY_PORT",
    "message": "Missing proxy port. Proxy must include port field (1-65535)."
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "INVALID_PROXY_PORT",
    "message": "Invalid proxy port: 99999. Must be between 1-65535"
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "INVALID_DATA_TYPE",
    "message": "siteKey must be a string"
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "TASK_NOT_FOUND",
    "message": "Task not found or does not belong to this user"
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "INCORRECT_CAPTCHA_SOLUTION",
    "message": "The provided solution was rejected by the target website. Your balance has been refunded. Please request a new captcha and try again."
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "SERVICE_ERROR",
    "message": "Internal server error"
  }
}

{
  "success": false,
  "service": "MyDisct Solver",
  "error": {
    "code": "SERVICE_TIMEOUT",
    "message": "Request timeout - please try again"
  }
}

// ✅ Valid URLs
"https://example.com"
"http://subdomain.example.com/path"
"https://example.com:8080/captcha"

"example.com"           // Missing protocol
""                      // Empty string
"   "                   // Whitespace only
"ftp://example.com"     // Wrong protocol

// ✅ Valid image arrays
["base64string1", "base64string2"]
["data:image/png;base64,iVBORw0KG..."]

[]                          // Empty array (for types requiring images)
["image1", "", "image3"]    // Contains empty element
["image1", "   ", "image3"] // Contains whitespace-only element
"not-an-array"              // Wrong type
null                        // Null value

// ✅ Valid proxy
{
  "protocol": "http",
  "host": "proxy.example.com",
  "port": 8080,
  "username": "user",
  "password": "pass"
}

{
  "host": "proxy.example.com",
  "port": 8080
}

{
  "protocol": "ftp",  // Invalid protocol
  "host": "proxy.example.com",
  "port": 8080
}

{
  "protocol": "http",
  "host": "",  // Empty host
  "port": 8080
}

{
  "protocol": "http",
  "host": "proxy.example.com",
  "port": 99999  // Port out of range
}

// ✅ Correct types
{
  "siteUrl": "https://example.com",     // string
  "siteKey": "abc123",                  // string
  "images": ["base64..."],              // array
  "questionType": "grid",               // string
  "proxy": { "protocol": "http", ... }  // object
}

{
  "siteUrl": 12345,            // number instead of string
  "siteKey": ["key"],          // array instead of string
  "images": "single-image",    // string instead of array
  "questionType": null,        // null instead of string
  "proxy": "http://proxy:80"   // string instead of object
}

async function solveCaptchaWithErrorHandling(captchaData) {
  const MAX_RETRIES = 3;
  let retryCount = 0;
  
  while (retryCount < MAX_RETRIES) {
    try {
      const response = await fetch('https://solver-api.mydisct.com/createTask', {
        method: 'POST',
        headers: {
          'Content-Type': 'application/json',
          'apikey': API_KEY
        },
        body: JSON.stringify(captchaData)
      });
      
      const data = await response.json();
      
      if (!data.success) {
        const httpStatus = response.status;
        const errorMessage = data.message || data.error?.message || 'Unknown error';
        
        if (httpStatus === 401) {
          throw new Error(`API key required: ${errorMessage}`);
        }

        if (httpStatus === 403) {
          if (errorMessage.includes('suspended') || errorMessage.includes('SUSPENDED')) {
            throw new Error('Your account has been suspended. Please contact support.');
          }
          if (errorMessage.includes('inactive') || errorMessage.includes('INACTIVE')) {
            throw new Error('Your account is inactive. Please activate your account.');
          }
          throw new Error(`Authentication error: ${errorMessage}`);
        }
        
        if (httpStatus === 402) {
          throw new Error(`Insufficient balance. Please add funds to your account.`);
        }
        
        if (httpStatus === 400) {
          throw new Error(`Invalid request: ${errorMessage}`);
        }
        
        if (httpStatus === 404) {
          throw new Error(`Task not found: ${errorMessage}`);
        }
        
        if (httpStatus === 429) {
          if (retryCount < MAX_RETRIES) {
            const waitTime = 60; // Wait 60 seconds
            console.log(`Rate limit exceeded. Waiting ${waitTime} seconds...`);
            await new Promise(resolve => setTimeout(resolve, waitTime * 1000));
            retryCount++;
            continue;
          }
          throw new Error('Rate limit exceeded. Please try again later.');
        }
        
        if (httpStatus >= 500) {
          if (retryCount < MAX_RETRIES) {
            console.log(`Server error. Retrying... (attempt ${retryCount + 1}/${MAX_RETRIES})`);
            await new Promise(resolve => setTimeout(resolve, 5000));
            retryCount++;
            continue;
          }
          throw new Error(`Server error: ${errorMessage}`);
        }
        
        throw new Error(`API error: ${errorMessage}`);
      }
      
      return data.task.id;
      
    } catch (error) {
      if (retryCount >= MAX_RETRIES - 1) {
        throw error;
      }
      retryCount++;
    }
  }
}

try {
  const taskId = await solveCaptchaWithErrorHandling(captchaData);
  console.log('Task created:', taskId);
} catch (error) {
  console.error('Failed to create task:', error.message);
}

import requests
import time

class CaptchaSolverError(Exception):
    """Base exception for captcha solver errors"""
    pass

class InsufficientBalanceError(CaptchaSolverError):
    """Raised when account balance is too low"""
    pass

class RateLimitError(CaptchaSolverError):
    """Raised when rate limit is exceeded"""
    def __init__(self, message, retry_after=None):
        super().__init__(message)
        self.retry_after = retry_after

def solve_captcha_with_error_handling(captcha_data, api_key, max_retries=3):
    """
    Solve captcha with comprehensive error handling
    
    Args:
        captcha_data: Captcha task data
        api_key: API key
        max_retries: Maximum number of retry attempts
    
    Returns:
        Task ID string
    
    Raises:
        CaptchaSolverError: For various error conditions
    """
    retry_count = 0
    
    while retry_count < max_retries:
        try:
            response = requests.post(
                'https://solver-api.mydisct.com/createTask',
                headers={
                    'Content-Type': 'application/json',
                    'apikey': api_key
                },
                json=captcha_data,
                timeout=30
            )
            
            data = response.json()
            http_status = response.status_code
            
            # Check for errors
            if not data.get('success'):
                error_message = data.get('message') or data.get('error', {}).get('message', 'Unknown error')
                
                # Handle specific HTTP status codes
                if http_status == 401:
                    # API key missing - don't retry
                    raise CaptchaSolverError(f'API key required: {error_message}')

                elif http_status == 403:
                    # Authentication/account errors - don't retry
                    if 'suspended' in error_message.lower() or 'SUSPENDED' in error_message:
                        raise CaptchaSolverError('Your account has been suspended. Please contact support.')
                    elif 'inactive' in error_message.lower() or 'INACTIVE' in error_message:
                        raise CaptchaSolverError('Your account is inactive. Please activate your account.')
                    else:
                        # Other 403 errors (invalid API key)
                        raise CaptchaSolverError(f'Authentication error: {error_message}')
                
                elif http_status == 402:
                    # Insufficient balance - don't retry
                    raise InsufficientBalanceError('Insufficient balance. Please add funds.')
                
                elif http_status == 400:
                    # Bad request - don't retry
                    raise CaptchaSolverError(f'Invalid request: {error_message}')
                
                elif http_status == 404:
                    # Not found - don't retry
                    raise CaptchaSolverError(f'Task not found: {error_message}')
                
                elif http_status == 429:
                    # Rate limit - retry with backoff
                    if retry_count < max_retries:
                        wait_time = 60  # Wait 60 seconds
                        print(f'Rate limit exceeded. Waiting {wait_time} seconds...')
                        time.sleep(wait_time)
                        retry_count += 1
                        continue
                    raise RateLimitError('Rate limit exceeded', 60)
                
                elif http_status >= 500:
                    # Server errors - retry
                    if retry_count < max_retries:
                        print(f'Server error. Retrying... (attempt {retry_count + 1}/{max_retries})')
                        time.sleep(5)
                        retry_count += 1
                        continue
                    raise CaptchaSolverError(f'Server error: {error_message}')
                
                else:
                    # Other errors
                    raise CaptchaSolverError(f'API error: {error_message}')
            
            # Success - return task ID
            return data['task']['id']
            
        except requests.exceptions.Timeout:
            if retry_count >= max_retries - 1:
                raise CaptchaSolverError('Request timeout')
            retry_count += 1
            time.sleep(5)
        
        except requests.exceptions.RequestException as e:
            if retry_count >= max_retries - 1:
                raise CaptchaSolverError(f'Network error: {str(e)}')
            retry_count += 1
            time.sleep(5)

# Usage
try:
    task_id = solve_captcha_with_error_handling(captcha_data, API_KEY)
    print(f'Task created: {task_id}')
except InsufficientBalanceError as e:
    print(f'Balance error: {e}')
    # Redirect user to add balance
except RateLimitError as e:
    print(f'Rate limit error: {e}')
    if e.retry_after:
        print(f'Retry after {e.retry_after} seconds')
except CaptchaSolverError as e:
    print(f'Solver error: {e}')
    # Handle error appropriately

async function retryWithExponentialBackoff(fn, maxRetries = 3) {
  let retryCount = 0;
  let delay = 1000; // Start with 1 second
  
  while (retryCount < maxRetries) {
    try {
      return await fn();
    } catch (error) {
      if (error.retryable === false) {
        throw error;
      }
      
      retryCount++;
      
      if (retryCount >= maxRetries) {
        throw error;
      }
      
      const jitter = Math.random() * 1000;
      const waitTime = delay + jitter;
      
      console.log(`Retry ${retryCount}/${maxRetries} after ${Math.round(waitTime)}ms`);
      await new Promise(resolve => setTimeout(resolve, waitTime));
      
      delay *= 2;
    }
  }
}

const result = await retryWithExponentialBackoff(async () => {
  return await createCaptchaTask(captchaData);
});