Verify AI API

npx expo install @switchlabs/verify-ai-react-native expo-camera @react-native-async-storage/async-storage

import { useVerifyAI } from '@switchlabs/verify-ai-react-native';

function ParkingScreen() {
  const { verify, loading, lastResult } = useVerifyAI({
    apiKey: 'vai_your_api_key',
  });

  const handlePhoto = async (base64Image: string) => {
    const result = await verify({
      image: base64Image,
      policy: 'scooter_parking',
    });
    if (result?.is_compliant) {
      console.log('Parking approved!');
    }
  };

  return <>{/* your camera UI */}</>;
}

import { useVerifyAI } from '@switchlabs/verify-ai-react-native';
import { VerifyAIScanner } from '@switchlabs/verify-ai-react-native/scanner';

function ScannerScreen() {
  const { verify } = useVerifyAI({ apiKey: 'vai_your_api_key' });

  return (
    <VerifyAIScanner
      onCapture={(base64) => verify({ image: base64, policy: 'scooter_parking' })}
      onResult={(result) => console.log(result.is_compliant ? 'PASS' : 'FAIL')}
      overlay={{ title: 'Parking Check', instructions: 'Center the scooter', showGuideFrame: true }}
    />
  );
}

curl -X POST https://verify.switchlabs.dev/api/v1/verify \
  -H "X-API-Key: vai_your_api_key" \
  -F "image=@photo.jpg" \
  -F "policy=scooter_parking"

# Response:
# { "is_compliant": false, "confidence": 0.98,
#   "violation_reasons": ["blocking_sidewalk"],
#   "feedback": "Please move away from the walkway." }

curl https://verify.switchlabs.dev/api/v1/verifications \
  -H "X-API-Key: vai_your_api_key_here"

{
  "event": "verification.completed",
  "data": {
    "id": "ver_8x92m4k9",
    "created_at": "2026-01-10T14:30:00Z",
    "status": "success",
    "is_compliant": false,
    "confidence": 0.98,
    "policy": "scooter_parking",
    "violation_reasons": ["blocking_sidewalk"],
    "feedback": "Please move away from the walkway.",
    "metadata": {},
    "image_url": "https://...signed-url..."
  }
}

// Verify webhook signature (Node.js)
const crypto = require('crypto');

function verifySignature(payload, header, secret) {
  const [tPart, sigPart] = header.split(',');
  const timestamp = tPart.split('=')[1];
  const signature = sigPart.split('=')[1];

  const expected = crypto
    .createHmac('sha256', secret)
    .update(timestamp + '.' + payload)
    .digest('hex');

  return crypto.timingSafeEqual(
    Buffer.from(signature),
    Buffer.from(expected)
  );
}

npm install @switchlabs/verify-ai-react-native

try {
  const result = await client.verify({ image, policy: 'scooter_parking' });
} catch (err) {
  if (err instanceof VerifyAIRequestError) {
    err.status;         // HTTP status code
    err.body;           // { error, status, current_usage?, limit?, upgrade_url? }
    err.isRateLimited;  // true if 429
    err.isUnauthorized; // true if 401
    err.upgradeUrl;     // URL to upgrade plan (if 403)
  }
}

const {
  verify, loading, error, lastResult, queueSize
} = useVerifyAI({ apiKey: 'vai_...', offlineMode: true });

// verify() auto-queues on network failure when offlineMode is on
const result = await verify({ image: base64, policy: 'scooter_parking' });
// result is null if queued, VerificationResult if successful

import type {
  VerifyAIConfig,         // { apiKey, baseUrl?, timeout?, offlineMode? }
  VerificationRequest,    // { image: string, policy: string, metadata?, provider? }
  VerificationResult,     // { id, created_at, status, is_compliant, confidence, ... }
  VerificationListResponse,  // { data: Result[], has_more, next_cursor }
  VerificationListParams, // { limit?, cursor?, policy?, status?, is_compliant?, ... }
  QueueItem,              // { id, request, createdAt, retryCount }
  VerifyAIError,          // { error, status, current_usage?, limit?, upgrade_url? }
  ScannerStatus,          // 'idle' | 'capturing' | 'processing' | 'success' | 'error'
  ScannerOverlayConfig,   // { title?, instructions?, showGuideFrame?, guideFrameAspectRatio? }
} from '@switchlabs/verify-ai-react-native';

{
  "expo": {
    "plugins": [
      [
        "expo-camera",
        {
          "cameraPermission": "Allow $(PRODUCT_NAME) to access the camera for photo verification."
        }
      ]
    ]
  }
}

curl -X POST https://verify.switchlabs.dev/api/v1/verify \
  -H "X-API-Key: vai_your_api_key" \
  -F "image=@photo.jpg" \
  -F "policy=scooter_parking"

const formData = new FormData();
formData.append('image', fileInput.files[0]);
formData.append('policy', 'scooter_parking');
formData.append('metadata', JSON.stringify({
  device_id: 'dev_123',
  user_id: 'usr_456',
}));

const response = await fetch(
  'https://verify.switchlabs.dev/api/v1/verify',
  {
    method: 'POST',
    headers: { 'X-API-Key': 'vai_your_api_key' },
    body: formData,
  }
);

const result = await response.json();
console.log(result.is_compliant); // true or false
console.log(result.feedback);     // User-friendly message

import requests
import json

response = requests.post(
    'https://verify.switchlabs.dev/api/v1/verify',
    headers={'X-API-Key': 'vai_your_api_key'},
    files={'image': open('photo.jpg', 'rb')},
    data={
        'policy': 'scooter_parking',
        'metadata': json.dumps({
            'device_id': 'dev_123',
            'user_id': 'usr_456',
        }),
    },
)

result = response.json()
print(f"Compliant: {result['is_compliant']}")
print(f"Feedback: {result['feedback']}")

import { VerifyAIClient } from '@switchlabs/verify-ai-react-native';

const client = new VerifyAIClient({ apiKey: 'vai_your_api_key' });

// Verify a photo
const result = await client.verify({
  image: base64ImageData,
  policy: 'scooter_parking',
  metadata: { device_id: 'dev_123' },
});

// List recent verifications
const { data, has_more } = await client.listVerifications({
  limit: 10,
  policy: 'scooter_parking',
});

// Get a specific verification
const detail = await client.getVerification('ver_8x92m4k9');

import { VerifyAIRequestError } from '@switchlabs/verify-ai-react-native';

try {
  const result = await client.verify({ image, policy: 'scooter_parking' });
} catch (err) {
  if (err instanceof VerifyAIRequestError) {
    if (err.isRateLimited) {
      // Back off and retry
    } else if (err.isUnauthorized) {
      // Invalid API key
    } else if (err.upgradeUrl) {
      // Plan limit reached — show upgrade prompt
      Linking.openURL(err.upgradeUrl);
    }
  }
}

const { verify, queueSize, processQueue } = useVerifyAI({
  apiKey: 'vai_your_api_key',
  offlineMode: true, // queues failed requests automatically
});

// verify() returns null when queued offline
const result = await verify({ image: base64, policy: 'scooter_parking' });

// Queue processes automatically on app foreground, or manually:
await processQueue();

// Show pending count to user
<Text>{queueSize} photos waiting to upload</Text>