Verify AI API

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

npm install @switchlabs/verify-ai-react-native expo-camera expo-image-manipulator

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"

{ "error": "Missing API key" }      // 401
{ "error": "Invalid API key format" } // 401
{ "error": "Invalid API key" }        // 401
{ "error": "Rate limit exceeded" }    // 429 + Retry-After

{
  "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",
    "category": "unsafe",
    "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');
const MAX_SKEW_SECONDS = 300; // 5 minutes

function verifySignature(rawBody, signatureHeader, secret) {
  if (!signatureHeader) return false;
  const parts = Object.fromEntries(
    signatureHeader.split(',').map(part => part.split('='))
  );

  const timestamp = Number(parts.t);
  const signature = parts.v1;
  if (!timestamp || !signature) return false;

  const now = Math.floor(Date.now() / 1000);
  if (Math.abs(now - timestamp) > MAX_SKEW_SECONDS) return false;

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

  const providedBuf = Buffer.from(signature, 'hex');
  const expectedBuf = Buffer.from(expected, 'hex');
  if (providedBuf.length !== expectedBuf.length) return false;
  return crypto.timingSafeEqual(providedBuf, expectedBuf);
}

[
  { "id": "compliant", "label": "Compliant", "color": "#22c55e", "isCompliant": true,
    "description": "Meets all requirements" },
  { "id": "improvable", "label": "Improvable", "color": "#eab308", "isCompliant": false,
    "description": "Minor issues that could be improved" },
  { "id": "unsafe", "label": "Unsafe", "color": "#ef4444", "isCompliant": false,
    "description": "Fails critical safety requirements" },
  { "id": "lacks_info", "label": "Lacks Information", "color": "#6b7280", "isCompliant": false,
    "description": "Not enough information to determine compliance" }
]

[
  { "id": "vehicle_visible", "label": "Vehicle Visible", "severity": "critical",
    "required": true, "description": "A scooter or bike must be clearly visible" },
  { "id": "kickstand_deployed", "label": "Kickstand Deployed", "severity": "critical",
    "required": true, "description": "Vehicle kickstand must be down" },
  { "id": "clear_of_sidewalk", "label": "Clear of Sidewalk", "severity": "warning",
    "required": false, "description": "Vehicle should not block pedestrian path" }
]

import { VerifyAIClient } from '@switchlabs/verify-ai-react-native';
import { VerifyAIScanner } from '@switchlabs/verify-ai-react-native/scanner';
import { useEffect, useState } from 'react';

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

function ScannerScreen() {
  const [config, setConfig] = useState(null);

  useEffect(() => {
    client.fetchPolicyConfig('scooter_parking').then(setConfig);
  }, []);

  if (!config) return null; // or a loading spinner

  return (
    <VerifyAIScanner
      onCapture={(base64) =>
        client.verify({ image: base64, policy: 'scooter_parking' })
      }
      onResult={(result) => console.log(result.category, result.is_compliant)}
      overlay={{
        title: config.uiCopy.scannerTitle,
        instructions: config.uiCopy.scannerInstructions,
        processingMessage: config.uiCopy.processingMessage,
        successMessage: config.uiCopy.successMessage,
        failureMessage: config.uiCopy.failureMessage,
        retryMessage: config.uiCopy.retryMessage,
        exhaustedMessage: config.uiCopy.exhaustedMessage,
        maxAttempts: config.maxAttempts,
        autoApproveOnExhaust: config.autoApproveOnExhaust,
        showGuideFrame: true,
      }}
    />
  );
}

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

npm install @switchlabs/verify-ai-react-native expo-camera expo-image-manipulator

// Core SDK — no native dependencies beyond react-native
import { VerifyAIClient, useVerifyAI } from '@switchlabs/verify-ai-react-native';

// Scanner component — requires expo-camera
import { VerifyAIScanner } from '@switchlabs/verify-ai-react-native/scanner';

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.isRetryable;    // true for 408, 429, 5xx
    err.upgradeUrl;     // URL to upgrade plan (if 403)
  }
}

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

// verify() auto-queues transient failures 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?, processingMessage?, ... }
  PolicyConfigResponse,   // { maxAttempts, autoApproveOnExhaust, uiCopy, categories }
} from '@switchlabs/verify-ai-react-native';

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

function ScannerScreen() {
  const { verify, client } = useVerifyAI({ apiKey: 'vai_your_api_key' });
  const [config, setConfig] = useState(null);

  useEffect(() => {
    client.fetchPolicyConfig('scooter_parking').then(setConfig);
  }, []);

  if (!config) return null;

  return (
    <VerifyAIScanner
      onCapture={(base64) => verify({ image: base64, policy: 'scooter_parking' })}
      onResult={(result) => console.log(result.category)}
      overlay={{
        title: config.uiCopy.scannerTitle,
        instructions: config.uiCopy.scannerInstructions,
        processingMessage: config.uiCopy.processingMessage,
        successMessage: config.uiCopy.successMessage,
        failureMessage: config.uiCopy.failureMessage,
        retryMessage: config.uiCopy.retryMessage,
        exhaustedMessage: config.uiCopy.exhaustedMessage,
        maxAttempts: config.maxAttempts,
        autoApproveOnExhaust: config.autoApproveOnExhaust,
        showGuideFrame: true,
      }}
    />
  );
}

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

flutter pub add verify_ai_flutter

<key>NSCameraUsageDescription</key>
<string>Camera is used for photo verification</string>

import 'package:verify_ai_flutter/verify_ai_flutter.dart';

final client = VerifyAIClient(
  const VerifyAIConfig(apiKey: 'vai_your_api_key'),
);

try {
  final result = await client.verify(
    const VerificationRequest(image: base64, policy: 'scooter_parking'),
  );
} on VerifyAIRequestError catch (e) {
  e.status;         // HTTP status code
  e.body;           // VerifyAIError with error, upgradeUrl, etc.
  e.isRateLimited;  // true if 429
  e.isUnauthorized; // true if 401
  e.isRetryable;    // true for 0, 408, 429, 5xx
  e.upgradeUrl;     // URL to upgrade plan (if 403)
}

final provider = VerifyAIProvider(
  const VerifyAIConfig(apiKey: 'vai_...', offlineMode: true),
);

final result = await provider.verifyMultipart(
  imageBytes: bytes,
  policy: 'scooter_parking',
);

// Use with ListenableBuilder
ListenableBuilder(
  listenable: provider,
  builder: (context, child) {
    if (provider.loading) return CircularProgressIndicator();
    if (provider.lastResult != null) {
      return Text('Compliant: ${provider.lastResult!.isCompliant}');
    }
    return ElevatedButton(
      onPressed: () => provider.verify(
        const VerificationRequest(image: base64, policy: 'scooter_parking'),
      ),
      child: Text('Verify'),
    );
  },
)

import 'package:verify_ai_flutter/verify_ai_flutter.dart';

// All exported types:
// VerifyAIConfig         — { apiKey, baseUrl?, timeout?, offlineMode? }
// VerificationRequest    — { image, policy, metadata?, provider? }
// VerificationResult     — { id, createdAt, status, isCompliant, confidence, ... }
// VerificationListResponse — { data, hasMore, nextCursor }
// VerificationListParams — { limit?, cursor?, policy?, status?, isCompliant?, ... }
// QueueItem              — { id, idempotencyKey, request, createdAt, retryCount }
// VerifyAIError          — { error, status?, currentUsage?, limit?, upgradeUrl? }
// ScannerStatus          — idle | capturing | processing | success | error
// ScannerOptions         — convenience config for VerifyAI.presentScanner()
// ScannerOverlayConfig   — { title?, instructions?, showGuideFrame?, guideFrameAspectRatio?, processingMessage?, ... }
// VerifyAIRequestError   — Exception with status, body, isRetryable, etc.
// PolicyConfigResponse   — fetchPolicyConfig() returns Map<String, dynamic>
// VerifyAI               — high-level wrapper with presentScanner()
// VerifyAIClient         — HTTP client
// VerifyAIProvider       — ChangeNotifier state manager
// VerifyAIScanner        — Camera widget
// VerifyAIScannerController — Programmatic capture controller
// OfflineQueue           — Offline request storage

import 'package:verify_ai_flutter/verify_ai_flutter.dart';

class ScannerScreen extends StatefulWidget {
  @override
  State<ScannerScreen> createState() => _ScannerScreenState();
}

class _ScannerScreenState extends State<ScannerScreen> {
  final client = VerifyAIClient(
    const VerifyAIConfig(apiKey: 'vai_your_api_key'),
  );
  Map<String, dynamic>? config;

  @override
  void initState() {
    super.initState();
    client.fetchPolicyConfig('scooter_parking').then((c) {
      setState(() => config = c);
    });
  }

  @override
  Widget build(BuildContext context) {
    if (config == null) return const CircularProgressIndicator();
    final uiCopy = config!['uiCopy'] as Map<String, dynamic>? ?? {};

    return VerifyAIScanner(
      onCapture: (bytes) => client.verifyMultipart(
        imageBytes: bytes,
        policy: 'scooter_parking',
      ),
      onResult: (result) => print(result.isCompliant),
      overlay: ScannerOverlayConfig(
        title: uiCopy['scannerTitle'],
        instructions: uiCopy['scannerInstructions'],
        processingMessage: uiCopy['processingMessage'],
        successMessage: uiCopy['successMessage'],
        failureMessage: uiCopy['failureMessage'],
        retryMessage: uiCopy['retryMessage'],
        exhaustedMessage: uiCopy['exhaustedMessage'],
        maxAttempts: config!['maxAttempts'],
        autoApproveOnExhaust: config!['autoApproveOnExhaust'] ?? false,
        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"

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 'package:verify_ai_flutter/verify_ai_flutter.dart';

final client = VerifyAIClient(
  const VerifyAIConfig(apiKey: 'vai_your_api_key'),
);

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

// List recent verifications
final list = await client.listVerifications(
  const VerificationListParams(limit: 10, policy: 'scooter_parking'),
);

// Get a specific verification
final 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 transient failures 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>

{ "error": "Missing API key" }
{ "error": "Invalid policy: your_policy_id" }
{ "error": "Rate limit exceeded" }