$0.016 per solve

reCAPTCHA Mobile

Mobile application reCAPTCHA integration

Average solve time: 15-20 seconds | Success rate: 99.2%

Overview

reCAPTCHA Mobile is specifically designed for iOS and Android applications. It provides seamless integration with mobile apps while maintaining the same security standards as web-based reCAPTCHA implementations.

Request Parameters

Parameter	Type	Required	Description
`type`	string	Yes	Must be "recaptcha_mobile"
`websiteKey`	string	Yes	The mobile app site key
`packageName`	string	Yes	App package name (com.example.app)
`action`	string	No	Action name for v3-style mobile
`apiDomain`	string	No	Custom API domain

Code Examples

# Submit CAPTCHA task
curl -X POST https://api.ai4cap.com/api/captcha/solve \
  -H "X-API-Key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "type": "recaptcha_mobile",
    "websiteKey": "6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9",
    "packageName": "com.example.myapp",
    "action": "login"
  }'

# Response
{
  "success": true,
  "taskId": "mob789ghi012"
}

# Get result
curl -X GET https://api.ai4cap.com/api/captcha/result/mob789ghi012 \
  -H "X-API-Key: YOUR_API_KEY"

# Response when solved
{
  "success": true,
  "status": "solved",
  "solution": {
    "gRecaptchaResponse": "03AGdBq27PBCbw..."
  },
  "cost": 0.016,
  "solveTime": 17500
}

import requests
import time

API_KEY = "YOUR_API_KEY"
API_URL = "https://api.ai4cap.com/api"

def solve_recaptcha_mobile(site_key, package_name, action=None):
    # Submit task
    request_data = {
        "type": "recaptcha_mobile",
        "websiteKey": site_key,
        "packageName": package_name
    }
    
    if action:
        request_data["action"] = action
    
    response = requests.post(
        f"{API_URL}/captcha/solve",
        headers={"X-API-Key": API_KEY},
        json=request_data
    )
    
    task_id = response.json()["taskId"]
    
    # Poll for result
    for _ in range(40):  # Max 80 seconds
        result = requests.get(
            f"{API_URL}/captcha/result/{task_id}",
            headers={"X-API-Key": API_KEY}
        )
        
        data = result.json()
        if data["status"] == "solved":
            return data["solution"]["gRecaptchaResponse"]
        elif data["status"] == "failed":
            raise Exception(f"Task failed: {data.get('error')}")
        
        time.sleep(2)
    
    raise Exception("Timeout waiting for solution")

# Example usage for Android app
solution = solve_recaptcha_mobile(
    "6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9",
    "com.example.myapp",
    action="login"
)
print(f"Mobile Token: {solution}")

# Example for iOS app
ios_solution = solve_recaptcha_mobile(
    "6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9",
    "com.example.MyIOSApp"
)
print(f"iOS Token: {ios_solution}")

const axios = require('axios');

const API_KEY = 'YOUR_API_KEY';
const API_URL = 'https://api.ai4cap.com/api';

async function solveReCaptchaMobile(siteKey, packageName, action = null) {
  try {
    // Build request data
    const requestData = {
      type: 'recaptcha_mobile',
      websiteKey: siteKey,
      packageName: packageName
    };
    
    if (action) {
      requestData.action = action;
    }
    
    // Submit task
    const submitResponse = await axios.post(
      `${API_URL}/captcha/solve`,
      requestData,
      {
        headers: { 'X-API-Key': API_KEY }
      }
    );
    
    const taskId = submitResponse.data.taskId;
    
    // Poll for result
    for (let i = 0; i < 40; i++) { // Max 80 seconds
      const resultResponse = await axios.get(
        `${API_URL}/captcha/result/${taskId}`,
        {
          headers: { 'X-API-Key': API_KEY }
        }
      );
      
      const data = resultResponse.data;
      
      if (data.status === 'solved') {
        return data.solution.gRecaptchaResponse;
      } else if (data.status === 'failed') {
        throw new Error(`Task failed: ${data.error || 'Unknown error'}`);
      }
      
      await new Promise(resolve => setTimeout(resolve, 2000));
    }
    
    throw new Error('Timeout waiting for solution');
  } catch (error) {
    console.error('Error solving CAPTCHA:', error.message);
    throw error;
  }
}

// Example usage for Android
(async () => {
  try {
    const androidToken = await solveReCaptchaMobile(
      '6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9',
      'com.example.myapp',
      'login'
    );
    console.log('Android Token:', androidToken);
    
    // Example for iOS
    const iosToken = await solveReCaptchaMobile(
      '6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9',
      'com.example.MyIOSApp'
    );
    console.log('iOS Token:', iosToken);
  } catch (error) {
    console.error('Failed:', error.message);
  }
})();

<?php
$API_KEY = 'YOUR_API_KEY';
$API_URL = 'https://api.ai4cap.com/api';

function solveReCaptchaMobile($siteKey, $packageName, $action = null) {
    global $API_KEY, $API_URL;
    
    // Build request data
    $requestData = [
        'type' => 'recaptcha_mobile',
        'websiteKey' => $siteKey,
        'packageName' => $packageName
    ];
    
    if ($action) {
        $requestData['action'] = $action;
    }
    
    // Submit task
    $ch = curl_init($API_URL . '/captcha/solve');
    curl_setopt($ch, CURLOPT_POST, 1);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($requestData));
    curl_setopt($ch, CURLOPT_HTTPHEADER, [
        'X-API-Key: ' . $API_KEY,
        'Content-Type: application/json'
    ]);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    
    $response = json_decode(curl_exec($ch), true);
    curl_close($ch);
    
    if (!$response['success']) {
        throw new Exception('Failed to submit task');
    }
    
    $taskId = $response['taskId'];
    
    // Poll for result
    for ($i = 0; $i < 40; $i++) { // Max 80 seconds
        $ch = curl_init($API_URL . '/captcha/result/' . $taskId);
        curl_setopt($ch, CURLOPT_HTTPHEADER, ['X-API-Key: ' . $API_KEY]);
        curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
        
        $result = json_decode(curl_exec($ch), true);
        curl_close($ch);
        
        if ($result['status'] === 'solved') {
            return $result['solution']['gRecaptchaResponse'];
        } elseif ($result['status'] === 'failed') {
            throw new Exception('Task failed: ' . ($result['error'] ?? 'Unknown error'));
        }
        
        sleep(2);
    }
    
    throw new Exception('Timeout waiting for solution');
}

// Example usage for Android
try {
    $androidToken = solveReCaptchaMobile(
        '6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9',
        'com.example.myapp',
        'login'
    );
    echo "Android Token: $androidToken\n";
    
    // Example for iOS
    $iosToken = solveReCaptchaMobile(
        '6LfW6wATAAAAAHLqO2pb8bDBahxlMxNdo9g947u9',
        'com.example.MyIOSApp'
    );
    echo "iOS Token: $iosToken\n";
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . "\n";
}
?>

Response Format

{
  "success": true,
  "status": "solved",
  "solution": {
    "gRecaptchaResponse": "03AGdBq27PBCbw..."  // The token for mobile verification
  },
  "cost": 0.016,
  "solveTime": 17500  // Time in milliseconds
}

Mobile Integration Guide

Android Integration

For Android apps, use the SafetyNet API:

// In your Android app
SafetyNet.getClient(this).verifyWithRecaptcha(YOUR_SITE_KEY)
    .addOnSuccessListener { response ->
        // Send response.tokenResult to your server
        // Then use our API to verify
    }

iOS Integration

For iOS apps, use the reCAPTCHA SDK:

// In your iOS app
let recaptchaClient = RecaptchaClient(siteKey: YOUR_SITE_KEY)
recaptchaClient.execute(action: .login) { token, error in
    // Send token to your server
    // Then use our API to verify
}

Important Notes

• Package name must match your app's actual package/bundle identifier

• Mobile tokens have similar expiration times to web tokens (1-2 minutes)

• The action parameter is optional but recommended for v3-style mobile

• Mobile CAPTCHAs may take slightly longer to solve due to additional verification

• Ensure your mobile app is properly registered in Google reCAPTCHA console