Troubleshooting Knowledge Base

curl -X POST https://app.verifyhuman.io/api/verify \
  -F "clientKey=vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6" \
  -F "file=@test-selfie.jpg"

{
  "error": "Invalid API key",
  "status": "ERROR"
}

# WRONG - missing prefix
headers = {'Authorization': 'Bearer abc123xyz'}

# WRONG - wrong product prefix
api_key = 'vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6'  # Using VerifyHuman key for VerifyAge
response = requests.post('/api/v1/verify-age/init', ...)

# CORRECT - matching product and key
api_key = 'vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6'  # VerifyAge key for VerifyAge endpoint
response = requests.post('/api/v1/verify-age/init', 
    data={'apiKey': api_key})

import requests

def verify_api_key(api_key):
    """Test if API key is valid and check its properties"""
    # Determine product from prefix
    prefix = api_key.split('_')[0] if '_' in api_key else 'unknown'

    endpoints = {
        'vhk': '/api/verify',
        'vage': '/api/v1/verify-age/init',
        'kyc': '/api/identity/v1/submit',
        'ident': '/api/identity/v1/submit',
        'kycp': '/api/kyc/v1/submit_plus'
    }

    if prefix not in endpoints:
        return {'valid': False, 'error': f'Unknown prefix: {prefix}'}

    # Perform a minimal validation request
    # (actual verification requires proper payload)
    return {'valid': True, 'product': prefix, 'endpoint': endpoints[prefix]}

# Usage
result = verify_api_key('vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6')
print(result)

{
  "error": "Insufficient credits",
  "credits_required": 30,
  "credits_available": 15
}

{
  "error": "Rate limit exceeded",
  "retry_after": 60,
  "limit": "60 requests/minute"
}

async function verifyWithRetry(file, maxRetries = 5) {
  for (let attempt = 0; attempt < maxRetries; attempt++) {
    try {
      return await verify(file);
    } catch (error) {
      if (error.status === 429) {
        const retryAfter = error.headers?.['Retry-After'] || Math.pow(2, attempt);
        console.log(`Rate limited. Waiting ${retryAfter} seconds...`);
        await sleep(retryAfter * 1000);
        continue;
      }
      throw error;
    }
  }
  throw new Error('Max retries exceeded');
}

function sleep(ms) {
  return new Promise(resolve => setTimeout(resolve, ms));
}

import time
from collections import deque
from threading import Lock

class RateLimiter:
    def __init__(self, max_requests, window_seconds):
        self.max_requests = max_requests
        self.window_seconds = window_seconds
        self.requests = deque()
        self.lock = Lock()

    def acquire(self):
        with self.lock:
            now = time.time()
            # Remove old requests outside window
            while self.requests and self.requests[0] < now - self.window_seconds:
                self.requests.popleft()

            if len(self.requests) >= self.max_requests:
                wait_time = self.requests[0] + self.window_seconds - now
                time.sleep(wait_time)
                return self.acquire()

            self.requests.append(now)
            return True

# Usage
limiter = RateLimiter(max_requests=60, window_seconds=60)
limiter.acquire()
response = verify_api_call()

from functools import lru_cache
import hashlib

@lru_cache(maxsize=1000)
def get_cached_verification(image_hash, user_id):
    """Cache verifications for the same user/image combination"""
    # Only hits API if not in cache
    return perform_verification(image_hash, user_id)

def verify_user(image_data, user_id):
    # Create hash of image for caching
    image_hash = hashlib.sha256(image_data).hexdigest()
    return get_cached_verification(image_hash, user_id)

{
  "error": "File size exceeds maximum allowed (10MB)",
  "file_size": "15.2MB",
  "max_size": "10MB"
}

async function compressImage(file, options = {}) {
  const {
    maxSizeMB = 5,
    maxWidth = 1920,
    maxHeight = 1080,
    quality = 0.85
  } = options;

  // Skip if already small enough
  if (file.size <= maxSizeMB * 1024 * 1024) {
    return file;
  }

  return new Promise((resolve, reject) => {
    const img = new Image();
    const canvas = document.createElement('canvas');
    const ctx = canvas.getContext('2d');

    img.onload = () => {
      let { width, height } = img;

      // Calculate new dimensions
      if (width > maxWidth) {
        height = (height / width) * maxWidth;
        width = maxWidth;
      }
      if (height > maxHeight) {
        width = (width / height) * maxHeight;
        height = maxHeight;
      }

      canvas.width = width;
      canvas.height = height;
      ctx.drawImage(img, 0, 0, width, height);

      canvas.toBlob(
        (blob) => {
          if (blob) {
            resolve(new File([blob], file.name, { type: 'image/jpeg' }));
          } else {
            reject(new Error('Failed to compress image'));
          }
        },
        'image/jpeg',
        quality
      );
    };

    img.onerror = () => reject(new Error('Failed to load image'));
    img.src = URL.createObjectURL(file);
  });
}

// Usage
const compressedFile = await compressImage(originalFile);
formData.append('file', compressedFile);

from PIL import Image
import io

def compress_image(image_data, max_size_mb=5, quality=85):
    """Compress image to meet size requirements"""
    img = Image.open(io.BytesIO(image_data))

    # Convert to RGB if necessary (for PNG with transparency)
    if img.mode in ('RGBA', 'P'):
        img = img.convert('RGB')

    # Resize if too large
    max_dimension = 1920
    if max(img.size) > max_dimension:
        ratio = max_dimension / max(img.size)
        new_size = tuple(int(dim * ratio) for dim in img.size)
        img = img.resize(new_size, Image.LANCZOS)

    # Compress with decreasing quality until under max size
    output = io.BytesIO()
    current_quality = quality

    while current_quality > 10:
        output.seek(0)
        output.truncate()
        img.save(output, format='JPEG', quality=current_quality, optimize=True)

        if output.tell() <= max_size_mb * 1024 * 1024:
            break
        current_quality -= 10

    return output.getvalue()

const sharp = require('sharp');

async function compressImage(buffer) {
  return await sharp(buffer)
    .resize(1920, 1080, { fit: 'inside', withoutEnlargement: true })
    .jpeg({ quality: 85, progressive: true })
    .toBuffer();
}

{
  "error": "API key restricted to whitelisted domains",
  "your_domain": "unauthorized-site.com",
  "whitelisted_domains": ["example.com", "app.example.com"]
}

{
  "error": "Unsupported file format",
  "received": "image/gif",
  "supported": ["image/jpeg", "image/png", "image/webp"]
}

const SUPPORTED_FORMATS = ['image/jpeg', 'image/jpg', 'image/png', 'image/webp'];

function validateFile(file) {
  if (!SUPPORTED_FORMATS.includes(file.type)) {
    throw new Error(`Unsupported format: ${file.type}. Use JPG, PNG, or WebP.`);
  }
  return true;
}

async function convertToJpeg(file) {
  const canvas = document.createElement('canvas');
  const ctx = canvas.getContext('2d');
  const img = await createImageBitmap(file);

  canvas.width = img.width;
  canvas.height = img.height;
  ctx.drawImage(img, 0, 0);

  return new Promise(resolve => {
    canvas.toBlob(blob => {
      resolve(new File([blob], 'photo.jpg', { type: 'image/jpeg' }));
    }, 'image/jpeg', 0.92);
  });
}

{
  "error": "Request timeout",
  "timeout": 30000,
  "message": "Verification processing exceeded time limit"
}

import requests

response = requests.post(
    'https://app.verifyhuman.io/api/verify',
    files={'file': image_file},
    data={'clientKey': API_KEY},
    timeout=(10, 60)  # (connect timeout, read timeout)
)

import asyncio
import aiohttp

async def verify_async(session, image_data, api_key):
    async with session.post(
        'https://app.verifyhuman.io/api/verify',
        data={'clientKey': api_key, 'file': image_data},
        timeout=aiohttp.ClientTimeout(total=60)
    ) as response:
        return await response.json()

async def batch_verify(images, api_key):
    async with aiohttp.ClientSession() as session:
        tasks = [verify_async(session, img, api_key) for img in images]
        return await asyncio.gather(*tasks, return_exceptions=True)

async function verifyWithPolling(file, apiKey) {
  // Submit verification
  const submitResponse = await fetch('/api/verify', {
    method: 'POST',
    body: createFormData(file, apiKey)
  });

  const { verification_id } = await submitResponse.json();

  // Poll for result
  for (let i = 0; i < 30; i++) {
    await sleep(1000);

    const statusResponse = await fetch(`/api/status/${verification_id}`);
    const status = await statusResponse.json();

    if (status.status !== 'PROCESSING') {
      return status;
    }
  }

  throw new Error('Verification timeout');
}

// Add to browser console
console.log('VerifyHuman object:', typeof VerifyHuman);
// Should output: 'VerifyHuman object: object'

console.log('Container:', document.getElementById('verifyhuman-widget'));
// Should output the DOM element, not null

<!-- WRONG - script runs before container exists -->
<script>
  VerifyHuman.init({ apiKey: 'vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6' });
</script>
<div id="verifyhuman-widget"></div>

<!-- CORRECT - container first, then script -->
<div id="verifyhuman-widget"></div>
<script src="https://app.verifyhuman.io/widget.js"></script>
<script>
  VerifyHuman.init({ apiKey: 'vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6' });
</script>

<!-- BEST - wait for DOM ready -->
<script src="https://app.verifyhuman.io/widget.js"></script>
<script>
  document.addEventListener('DOMContentLoaded', function() {
    VerifyHuman.init({ apiKey: 'vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6' });
  });
</script>

import { useEffect, useRef } from 'react';

function VerifyHumanWidget({ apiKey, onSuccess, onFailure }) {
  const containerRef = useRef(null);
  const initialized = useRef(false);

  useEffect(() => {
    // Only initialize once
    if (initialized.current) return;

    // Load script dynamically
    const script = document.createElement('script');
    script.src = 'https://app.verifyhuman.io/widget.js';
    script.async = true;

    script.onload = () => {
      if (window.VerifyHuman && containerRef.current) {
        window.VerifyHuman.init({
          apiKey,
          container: containerRef.current,
          onSuccess,
          onFailure
        });
        initialized.current = true;
      }
    };

    document.head.appendChild(script);

    return () => {
      // Cleanup on unmount
      if (window.VerifyHuman?.destroy) {
        window.VerifyHuman.destroy();
      }
    };
  }, [apiKey, onSuccess, onFailure]);

  return <div ref={containerRef} id="verifyhuman-widget" />;
}

<template>
  <div ref="widgetContainer" id="verifyhuman-widget"></div>
</template>

<script>
export default {
  props: ['apiKey'],
  mounted() {
    this.loadWidget();
  },
  methods: {
    loadWidget() {
      const script = document.createElement('script');
      script.src = 'https://app.verifyhuman.io/widget.js';
      script.onload = () => {
        window.VerifyHuman.init({
          apiKey: this.apiKey,
          container: this.$refs.widgetContainer,
          onSuccess: this.handleSuccess,
          onFailure: this.handleFailure
        });
      };
      document.head.appendChild(script);
    },
    handleSuccess(result) {
      this.$emit('verification-success', result);
    },
    handleFailure(error) {
      this.$emit('verification-failure', error);
    }
  }
}
</script>

✗ http://example.com (camera will NOT work)
✓ https://example.com (camera works)
✓ http://localhost:3000 (allowed for development)
✓ http://127.0.0.1:8080 (allowed for development)

VerifyHuman.init({
  apiKey: 'vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6',
  onCameraError: function(error) {
    switch(error.name) {
      case 'NotAllowedError':
        showMessage('Please allow camera access in your browser settings.');
        break;
      case 'NotFoundError':
        showMessage('No camera found. Please connect a camera and try again.');
        break;
      case 'NotReadableError':
        showMessage('Camera is in use by another application. Please close other apps using the camera.');
        break;
      case 'OverconstrainedError':
        showMessage('Camera does not meet requirements. Please try a different camera.');
        break;
      default:
        showMessage('Camera error: ' + error.message);
    }
  }
});

1. Click lock icon in address bar
2. Click "Site settings"
3. Find "Camera" and set to "Allow"
4. Refresh the page

1. Click lock icon in address bar
2. Click "Connection secure" → "More Information"
3. Go to "Permissions" tab
4. Find "Use the Camera" and select "Allow"

1. Safari → Preferences → Websites → Camera
2. Find your site and set to "Allow"

VerifyHuman.init({
  apiKey: 'vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6',
  captureMode: 'auto', // Try camera first, fallback to file
  allowFileUpload: true,
  onCameraError: function(error) {
    console.log('Camera unavailable, using file upload');
  }
});

/* Ensure widget is above other elements */
#verifyhuman-widget {
  position: relative;
  z-index: 1000;
}

/* If using modal dialogs */
.verifyhuman-modal {
  z-index: 10000 !important;
}

#verifyhuman-widget {
  width: 100%;
  max-width: 500px;
  min-height: 400px;
  margin: 0 auto;
}

/* Responsive sizing */
@media (max-width: 768px) {
  #verifyhuman-widget {
    max-width: 100%;
    min-height: 350px;
  }
}

VerifyHuman.init({
  apiKey: 'vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6',
  theme: 'dark',
  customStyles: {
    primaryColor: '#4F46E5',
    backgroundColor: '#1F2937',
    textColor: '#F9FAFB',
    borderRadius: '12px',
    fontFamily: 'Inter, system-ui, sans-serif'
  }
});

/* Reset potential conflicts */
#verifyhuman-widget * {
  box-sizing: border-box;
}

#verifyhuman-widget button {
  all: unset;
  /* Apply widget-specific styles */
}

Access to fetch at 'https://app.verifyhuman.io/api/verify' from origin 
'https://yoursite.com' has been blocked by CORS policy

// WRONG - Direct API call from browser
fetch('https://app.verifyhuman.io/api/verify', {
  method: 'POST',
  body: formData
});

// CORRECT - Use the widget
VerifyHuman.init({
  apiKey: 'vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6',
  onSuccess: (result) => {
    // Send token to your backend
    sendToBackend(result.token);
  }
});

# Flask backend proxy
@app.route('/api/verify', methods=['POST'])
def verify_proxy():
    # Receive file from frontend
    file = request.files['file']

    # Forward to VerifyHuman API
    response = requests.post(
        'https://app.verifyhuman.io/api/verify',
        files={'file': file},
        data={'clientKey': os.environ['VERIFYHUMAN_API_KEY']}
    )

    return jsonify(response.json())

const express = require('express');
const multer = require('multer');
const fetch = require('node-fetch');
const FormData = require('form-data');

const upload = multer();

app.post('/api/verify', upload.single('file'), async (req, res) => {
  const formData = new FormData();
  formData.append('clientKey', process.env.VERIFYHUMAN_API_KEY);
  formData.append('file', req.file.buffer, req.file.originalname);

  const response = await fetch('https://app.verifyhuman.io/api/verify', {
    method: 'POST',
    body: formData
  });

  const result = await response.json();
  res.json(result);
});

✗ https://verify.verifyhuman.io/flow/abc123 (incomplete)
✓ https://verify.verifyhuman.io/flow/vh_abc123xyz789 (complete with prefix)

curl -I "https://verify.verifyhuman.io/flow/vh_abc123xyz789"
# Look for 200 OK, not 404 Not Found

Success URL: https://yoursite.com/verified?id={VERIFICATION_ID}&status={STATUS}
Failure URL: https://yoursite.com/failed?error={ERROR}&id={VERIFICATION_ID}

@app.route('/verified')
def verification_complete():
    verification_id = request.args.get('id')
    status = request.args.get('status')

    if status == 'PASS':
        # Store verification in database
        save_verification(verification_id)
        return render_template('success.html')
    else:
        return render_template('retry.html')

✗ "blue"           (won't work)
✗ "rgb(0,0,255)"   (won't work)
✓ "#0000FF"        (correct)
✓ "#00f"           (correct shorthand)

{
  "status": "PASS",
  "confidence": 62,
  "warning": "Low confidence score"
}

VerifyHuman.init({
  apiKey: 'vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6',
  instructions: [
    'Face the camera directly',
    'Keep your face centered in the frame',
    'Fill at least 1/3 of the frame',
    'Remove glasses, hats, or masks'
  ],
  minFaceSize: 0.3 // 30% of frame
});

function handleVerification(result) {
  if (result.confidence >= 90) {
    // High confidence - auto approve
    approveUser();
  } else if (result.confidence >= 70) {
    // Medium confidence - accept with note
    approveUser({ requireReview: true });
  } else if (result.confidence >= 50) {
    // Low confidence - request retry
    showRetryPrompt('Please try again with better lighting');
  } else {
    // Very low - likely fraud attempt
    flagForReview(result.verification_id);
  }
}

{
  "status": "FAIL",
  "error": "No face detected in image",
  "confidence": 0
}

<div class="verification-tips">
  <h4>For Best Results:</h4>
  <ul>
    <li>✅ Face camera directly</li>
    <li>✅ Good front lighting</li>
    <li>✅ Plain background</li>
    <li>✅ Remove sunglasses/masks</li>
    <li>❌ Avoid backlighting</li>
    <li>❌ Don't use side profile</li>
  </ul>
</div>

async function preCheckImage(imageFile) {
  // Use local face detection before API call
  const faceDetector = new FaceDetector();
  const faces = await faceDetector.detect(imageFile);

  if (faces.length === 0) {
    throw new Error('No face detected. Please ensure your face is visible and well-lit.');
  }
  if (faces.length > 1) {
    throw new Error('Multiple faces detected. Please ensure only you are in the frame.');
  }

  return true;
}

{
  "status": "FAIL",
  "error": "Liveness check failed - possible photo of photo",
  "liveness_score": 35
}

VerifyHuman.init({
  apiKey: 'vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6',
  captureMode: 'camera', // Disable file upload
  requireLiveness: true,
  minLivenessScore: 70
});

<div class="liveness-notice">
  <p><strong>Real-time verification required</strong></p>
  <p>Please use your device's camera for live capture. 
     Photos of photos or screens will not be accepted.</p>
</div>

VerifyAge.init({
  apiKey: 'vhk-a1b2c3d4e5f6g7h8i9j0k1l2m3n4o5p6',
  minAge: 21,
  useCase: 'alcohol',
  fallbackToId: true, // Auto-request ID if face estimate is borderline
  borderlineRange: 5   // Years margin for ID fallback
});

def handle_age_verification(result):
    estimated_age = result.get('estimated_age')
    confidence = result.get('confidence')
    min_age = 21

    if estimated_age is None:
        return require_id_verification()

    # Clear pass
    if estimated_age >= min_age + 5 and confidence >= 80:
        return approve_user()

    # Clear fail
    if estimated_age < min_age - 3 and confidence >= 80:
        return reject_user()

    # Borderline - require ID
    return require_id_verification()

# US State Age Requirements
STATE_REQUIREMENTS = {
    'alcohol': {
        'default': 21,
        # All US states are 21 for alcohol
    },
    'tobacco': {
        'default': 21,
        'AL': 19,  # Alabama
        'AK': 19,  # Alaska
        # Federal law now 21, but some grandfathering
    },
    'cannabis': {
        'default': 21,
        'CO': 21,
        'CA': 21,
        'WA': 21,
        # Only legal in certain states
    },
    'gambling': {
        'default': 21,
        'MT': 18,
        'OK': 18,
        'WY': 18,
    }
}

def get_age_requirement(use_case, state):
    case_requirements = STATE_REQUIREMENTS.get(use_case, {})
    return case_requirements.get(state, case_requirements.get('default', 21))

{
  "status": "FAIL",
  "error": "Unable to extract data from document",
  "document_quality": "poor"
}

<div class="id-requirements">
  <h4>ID Document Guidelines:</h4>
  <ul>
    <li>Valid government-issued photo ID</li>
    <li>Not expired</li>
    <li>All corners visible</li>
    <li>No glare or reflections</li>
    <li>High resolution (at least 1000px wide)</li>
    <li>Color photo (not black & white)</li>
  </ul>

  <h4>Supported Documents:</h4>
  <ul>
    <li>Driver's License</li>
    <li>State ID Card</li>
    <li>Passport</li>
    <li>Passport Card</li>
    <li>Military ID</li>
  </ul>
</div>

function validateIdImage(file) {
  return new Promise((resolve, reject) => {
    const img = new Image();
    img.onload = () => {
      // Check minimum resolution
      if (img.width < 1000 || img.height < 600) {
        reject(new Error('Image resolution too low. Please capture a higher quality photo.'));
        return;
      }

      // Check aspect ratio (ID cards are typically ~1.586:1)
      const aspectRatio = img.width / img.height;
      if (aspectRatio < 1.3 || aspectRatio > 2.0) {
        reject(new Error('Please capture the full ID card with all corners visible.'));
        return;
      }

      resolve(true);
    };
    img.src = URL.createObjectURL(file);
  });
}

{
  "status": "FAIL",
  "error": "Selfie does not match ID photo",
  "match_confidence": 45
}

<div class="matching-tips">
  <h4>For Best Match Results:</h4>
  <ul>
    <li>Take selfie in similar conditions to ID photo</li>
    <li>Remove accessories not worn in ID (glasses, hat)</li>
    <li>Use good lighting</li>
    <li>Face camera directly</li>
  </ul>
</div>

def handle_face_match(result):
    match_score = result.get('match_confidence', 0)

    if match_score >= 90:
        return approve_verification()
    elif match_score >= 70:
        # Possible match, flag for review
        return flag_for_manual_review(result)
    elif match_score >= 50:
        # Retry with better photo
        return request_retry("Please retake your selfie with better lighting")
    else:
        # Potential fraud
        return flag_security_review(result)

{
  "status": "REVIEW",
  "compliance_screening": {
    "total_hits": 2,
    "sanctions_hits": 0,
    "pep_hits": 1,
    "adverse_media_hits": 1
  }
}

def handle_compliance_result(result):
    screening = result.get('compliance_screening', {})

    # Immediate reject for sanctions
    if screening.get('sanctions_hits', 0) > 0:
        return reject_with_reason("sanctions_match")

    # Review required for PEP
    if screening.get('pep_hits', 0) > 0:
        return flag_for_enhanced_due_diligence(result)

    # Adverse media - depends on severity
    if screening.get('adverse_media_hits', 0) > 0:
        return flag_for_manual_review(result)

    # No hits
    if screening.get('total_hits', 0) == 0:
        return approve_verification()

{
  "error": "VerifyTrust requires Pro or Enterprise plan",
  "current_plan": "Growth"
}

requests.exceptions.SSLError: [SSL: CERTIFICATE_VERIFY_FAILED]

pip install --upgrade certifi
python -c "import certifi; print(certifi.where())"

# Debian/Ubuntu
sudo apt-get update && sudo apt-get install ca-certificates

# CentOS/RHEL
sudo yum install ca-certificates

import requests

# ONLY for debugging - never use in production
response = requests.post(url, verify=False)

import asyncio
import aiohttp

# WRONG - nested event loops
async def verify():
    return asyncio.run(do_verification())  # This will fail

# CORRECT - proper async structure
async def verify():
    async with aiohttp.ClientSession() as session:
        return await do_verification(session)

# For Jupyter notebooks
import nest_asyncio
nest_asyncio.apply()

def stream_upload(file_path, api_key):
    """Stream large files to avoid memory issues"""
    with open(file_path, 'rb') as f:
        # Use streaming upload
        response = requests.post(
            'https://app.verifyhuman.io/api/verify',
            files={'file': ('image.jpg', f, 'image/jpeg')},
            data={'clientKey': api_key},
            stream=True
        )
    return response.json()

Error: Cannot find module 'verifyhuman'
SyntaxError: Cannot use import statement outside a module

// CommonJS (default for Node.js < 14)
const VerifyHuman = require('verifyhuman');

// ES Modules (package.json: "type": "module")
import VerifyHuman from 'verifyhuman';

{
  "type": "module",
  "dependencies": {
    "verifyhuman": "^2.0.0"
  }
}

const fs = require('fs');
const FormData = require('form-data');
const fetch = require('node-fetch');

async function uploadFile(filePath, apiKey) {
  const form = new FormData();

  // CORRECT - stream from file
  form.append('file', fs.createReadStream(filePath));
  form.append('clientKey', apiKey);

  const response = await fetch('https://app.verifyhuman.io/api/verify', {
    method: 'POST',
    body: form,
    headers: form.getHeaders() // Important!
  });

  return response.json();
}

const { Readable } = require('stream');

async function processWithCleanup(imageBuffer) {
  let response;
  try {
    response = await verify(imageBuffer);
    return response;
  } finally {
    // Clean up buffer
    imageBuffer = null;
    if (global.gc) {
      global.gc(); // Force garbage collection if available
    }
  }
}

cURL error 60: SSL certificate problem
cURL error 28: Operation timed out

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://app.verifyhuman.io/api/verify');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, true);
curl_setopt($ch, CURLOPT_CAINFO, '/path/to/cacert.pem');

curl -o /etc/ssl/certs/cacert.pem https://curl.se/ca/cacert.pem

<?php
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 10);
curl_setopt($ch, CURLOPT_TIMEOUT, 60);

<?php
function verifyImage($filePath, $apiKey) {
    $ch = curl_init();

    $postFields = [
        'clientKey' => $apiKey,
        'file' => new CURLFile($filePath, 'image/jpeg', 'photo.jpg')
    ];

    curl_setopt_array($ch, [
        CURLOPT_URL => 'https://app.verifyhuman.io/api/verify',
        CURLOPT_POST => true,
        CURLOPT_POSTFIELDS => $postFields,
        CURLOPT_RETURNTRANSFER => true,
        CURLOPT_HTTPHEADER => ['Content-Type: multipart/form-data']
    ]);

    $response = curl_exec($ch);

    if (curl_errno($ch)) {
        throw new Exception('cURL error: ' . curl_error($ch));
    }

    curl_close($ch);
    return json_decode($response, true);
}

<key>NSCameraUsageDescription</key>
<string>Camera access is required for identity verification</string>
<key>NSPhotoLibraryUsageDescription</key>
<string>Photo library access is needed to select verification photos</string>

import AVFoundation

func requestCameraPermission(completion: @escaping (Bool) -> Void) {
    switch AVCaptureDevice.authorizationStatus(for: .video) {
    case .authorized:
        completion(true)
    case .notDetermined:
        AVCaptureDevice.requestAccess(for: .video) { granted in
            DispatchQueue.main.async {
                completion(granted)
            }
        }
    case .denied, .restricted:
        completion(false)
    @unknown default:
        completion(false)
    }
}

import WebKit

class VerificationViewController: UIViewController, WKUIDelegate {
    var webView: WKWebView!

    override func viewDidLoad() {
        super.viewDidLoad()

        let config = WKWebViewConfiguration()
        config.allowsInlineMediaPlayback = true
        config.mediaTypesRequiringUserActionForPlayback = []

        webView = WKWebView(frame: view.bounds, configuration: config)
        webView.uiDelegate = self

        // Allow camera access
        if #available(iOS 14.0, *) {
            webView.configuration.defaultWebpagePreferences.allowsContentJavaScript = true
        }
    }
}

<uses-permission android:name="android.permission.CAMERA" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-feature android:name="android.hardware.camera" android:required="true" />

class VerificationActivity : AppCompatActivity() {
    private val CAMERA_PERMISSION_CODE = 100

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        if (checkCameraPermission()) {
            startVerification()
        } else {
            requestCameraPermission()
        }
    }

    private fun checkCameraPermission(): Boolean {
        return ContextCompat.checkSelfPermission(
            this, Manifest.permission.CAMERA
        ) == PackageManager.PERMISSION_GRANTED
    }

    private fun requestCameraPermission() {
        ActivityCompat.requestPermissions(
            this,
            arrayOf(Manifest.permission.CAMERA),
            CAMERA_PERMISSION_CODE
        )
    }

    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        if (requestCode == CAMERA_PERMISSION_CODE) {
            if (grantResults.isNotEmpty() && 
                grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                startVerification()
            } else {
                showPermissionDeniedMessage()
            }
        }
    }
}

class VerificationWebView : WebView {
    init {
        settings.apply {
            javaScriptEnabled = true
            mediaPlaybackRequiresUserGesture = false
            domStorageEnabled = true
        }

        webChromeClient = object : WebChromeClient() {
            override fun onPermissionRequest(request: PermissionRequest) {
                request.grant(request.resources)
            }
        }
    }
}

// Install required packages
// npm install react-native-camera react-native-permissions

import { Camera } from 'react-native-camera';
import { check, request, PERMISSIONS, RESULTS } from 'react-native-permissions';

async function checkAndRequestCamera() {
  const permission = Platform.OS === 'ios' 
    ? PERMISSIONS.IOS.CAMERA 
    : PERMISSIONS.ANDROID.CAMERA;

  const result = await check(permission);

  if (result === RESULTS.DENIED) {
    const requestResult = await request(permission);
    return requestResult === RESULTS.GRANTED;
  }

  return result === RESULTS.GRANTED;
}

{
  "error": "API key does not have permission for this product",
  "required_scope": "verifyage",
  "key_scopes": ["verifyhuman"]
}

{
  "valid": false,
  "error": "Token expired"
}

import jwt
import time

def is_token_valid(token):
    try:
        # Decode without verification to check expiry
        payload = jwt.decode(token, options={"verify_signature": False})
        exp = payload.get('exp', 0)
        return time.time() < exp
    except jwt.exceptions.DecodeError:
        return False

async function getValidToken(userId) {
  const storedToken = await getStoredToken(userId);

  if (storedToken && isTokenValid(storedToken)) {
    return storedToken;
  }

  // Token expired or invalid, require new verification
  return await requestNewVerification(userId);
}

{
  "valid": false,
  "error": "Invalid token signature"
}

def validate_token(token, client_secret):
    """Server-side token validation"""
    response = requests.post(
        'https://app.verifyhuman.io/api/validate',
        headers={
            'Authorization': f'Bearer {client_secret}',
            'Content-Type': 'application/json'
        },
        json={'token': token}
    )

    result = response.json()

    if not result.get('valid'):
        raise ValueError(f"Token validation failed: {result.get('error')}")

    return result

// WRONG - trusting client-side result
if (clientResult.token) {
  allowAccess();
}

// CORRECT - validate on backend
const backendResult = await fetch('/api/validate-verification', {
  method: 'POST',
  body: JSON.stringify({ token: clientResult.token })
});
if (backendResult.valid) {
  allowAccess();
}

// BAD - infinite retry loop
async function verify() {
  try {
    await verifyHuman();
  } catch (error) {
    verify(); // Endless loop consuming credits!
  }
}

// GOOD - limited retries
async function verify(attempt = 0, maxAttempts = 3) {
  try {
    return await verifyHuman();
  } catch (error) {
    if (attempt < maxAttempts && error.retryable) {
      await sleep(1000 * Math.pow(2, attempt));
      return verify(attempt + 1, maxAttempts);
    }
    throw error;
  }
}

import hashlib
from datetime import datetime, timedelta

# Simple in-memory cache (use Redis in production)
verification_cache = {}

def cached_verify(user_id, image_data, cache_duration_hours=1):
    """Cache verification results to avoid duplicate calls"""
    cache_key = f"{user_id}:{hashlib.md5(image_data).hexdigest()}"

    if cache_key in verification_cache:
        cached = verification_cache[cache_key]
        if datetime.now() < cached['expires']:
            return cached['result']

    # Not in cache, perform verification
    result = perform_verification(image_data)

    verification_cache[cache_key] = {
        'result': result,
        'expires': datetime.now() + timedelta(hours=cache_duration_hours)
    }

    return result

def verify_with_credit_check(api_key, product):
    credits_needed = {
        'verifyhuman': 1,
        'verifyage': 10,
        'verifyidentity': 30,
        'verifycompliance': 50
    }

    # Check credits before verification
    credits = get_credit_balance(api_key)
    needed = credits_needed[product]

    if credits < needed:
        send_low_credit_alert(credits, needed)
        raise InsufficientCreditsError(credits, needed)

    result = perform_verification()

    # Log credit usage
    log_credit_usage(api_key, product, needed)

    return result

{
  "error": "VerifyTrust requires Pro or Enterprise plan",
  "current_plan": "Growth"
}

async function optimizeForUpload(file) {
  const canvas = document.createElement('canvas');
  const ctx = canvas.getContext('2d');
  const img = await createImageBitmap(file);

  // Target dimensions
  const maxWidth = 1920;
  const maxHeight = 1080;

  let { width, height } = img;

  if (width > maxWidth || height > maxHeight) {
    const ratio = Math.min(maxWidth / width, maxHeight / height);
    width *= ratio;
    height *= ratio;
  }

  canvas.width = width;
  canvas.height = height;
  ctx.drawImage(img, 0, 0, width, height);

  return new Promise(resolve => {
    canvas.toBlob(resolve, 'image/jpeg', 0.85);
  });
}

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

def create_session_with_retry():
    session = requests.Session()

    retry_strategy = Retry(
        total=3,
        backoff_factor=1,
        status_forcelist=[429, 500, 502, 503, 504]
    )

    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("https://", adapter)

    return session

session = create_session_with_retry()
response = session.post(
    'https://app.verifyhuman.io/api/verify',
    files={'file': image_file},
    data={'clientKey': api_key},
    timeout=(5, 30)  # (connect, read) timeouts
)

async function verifyWithProgress(file, onProgress) {
  onProgress({ stage: 'uploading', percent: 0 });

  const formData = new FormData();
  formData.append('file', file);
  formData.append('clientKey', apiKey);

  const response = await fetch('/api/verify', {
    method: 'POST',
    body: formData
  });

  onProgress({ stage: 'processing', percent: 50 });

  const result = await response.json();

  onProgress({ stage: 'complete', percent: 100 });

  return result;
}