SDK Overview

Official SDKs and integration libraries for LoomAPI.

SDK Overview

Official SDKs and integration libraries to accelerate your LoomAPI integration. Choose from our supported languages or use our REST API directly.

Available SDKs

<Card> <CardHeader> <CardTitle>🚀 Node.js SDK</CardTitle> <CardDescription>Official Node.js library with TypeScript support</CardDescription> </CardHeader> <CardContent> ```bash npm install @loomapi/node-sdk ``` 
- Full TypeScript support
- Built-in retry logic
- Webhook signature verification
- Promise-based API
</CardContent> </Card> <Card> <CardHeader> <CardTitle>🐍 Python SDK</CardTitle> <CardDescription>Python library for Django and Flask applications</CardDescription> </CardHeader> <CardContent> ```bash pip install loomapi ``` 
- Async/await support
- Django integration helpers
- Automatic retries
- Comprehensive error handling
</CardContent> </Card>

SDK Features

🔧 Common Features

All our SDKs include:

  • Type Safety: Full TypeScript/Flow support where applicable
  • Error Handling: Comprehensive error handling with retry logic
  • Rate Limiting: Built-in rate limit handling and backoff
  • Webhook Support: Easy webhook signature verification
  • Documentation: Extensive inline documentation
  • Testing: Test utilities and mock responses

📦 Installation

Node.js

npm install @loomapi/node-sdk
# or
yarn add @loomapi/node-sdk
# or
pnpm add @loomapi/node-sdk

Python

pip install loomapi
# or
poetry add loomapi
# or
pipenv install loomapi

Quick Start

Node.js Example

import { LoomAPI } from '@loomapi/node-sdk'

const client = new LoomAPI({
  apiKey: process.env.LOOM_API_KEY,
  baseURL: 'https://api.loomapi.com'
})

// Basic verification
const result = await client.verify({
  documentType: 'passport',
  documentData: base64ImageData,
  verificationType: 'age_only'
})

console.log(`Verified age: ${result.verified_age}`)

Python Example

from loomapi import LoomAPI

client = LoomAPI(
    api_key=os.getenv('LOOM_API_KEY'),
    base_url='https://api.loomapi.com'
)

# Basic verification
result = client.verify(
    document_type='passport',
    document_data=base64_image_data,
    verification_type='age_only'
)

print(f"Verified age: {result.verified_age}")

Advanced Usage

Custom Configuration

const client = new LoomAPI({
  apiKey: 'your_api_key',
  baseURL: 'https://api.loomapi.com',
  timeout: 30000, // 30 seconds
  maxRetries: 3,
  retryDelay: 1000, // 1 second base delay
  testMode: false
})

Webhook Handling

import { verifyWebhookSignature } from '@loomapi/node-sdk'

app.post('/webhooks/loom', (req, res) => {
  const signature = req.headers['x-loom-signature']
  const secret = process.env.LOOM_WEBHOOK_SECRET

  if (!verifyWebhookSignature(req.body, signature, secret)) {
    return res.status(401).send('Invalid signature')
  }

  // Process webhook
  const { event, verification } = req.body

  switch (event) {
    case 'verification.completed':
      handleSuccess(verification)
      break
    case 'verification.failed':
      handleFailure(verification)
      break
  }

  res.sendStatus(200)
})

Error Handling

try {
  const result = await client.verify({
    documentType: 'passport',
    documentData: imageData
  })

  if (result.status === 'verified') {
    console.log(`User is ${result.verified_age} years old`)
  } else {
    console.log('Verification failed:', result.error)
  }
} catch (error) {
  if (error.code === 'RATE_LIMIT_EXCEEDED') {
    // Handle rate limit
    await delay(error.retryAfter * 1000)
    // Retry logic
  } else if (error.code === 'DOCUMENT_QUALITY_LOW') {
    // Prompt user for better image
    console.log('Please provide a clearer image')
  } else {
    console.error('Unexpected error:', error)
  }
}

Framework Integrations

Express.js Middleware

import { createWebhookMiddleware } from '@loomapi/node-sdk/express'

const webhookSecret = process.env.LOOM_WEBHOOK_SECRET

app.use('/webhooks/loom',
  createWebhookMiddleware(webhookSecret),
  (req, res) => {
    const { event, verification } = req.body

    // Webhook is already verified
    handleVerificationEvent(event, verification)

    res.sendStatus(200)
  }
)

Django Integration

# settings.py
LOOM_API_KEY = os.getenv('LOOM_API_KEY')
LOOM_WEBHOOK_SECRET = os.getenv('LOOM_WEBHOOK_SECRET')

# views.py
from django.http import JsonResponse
from django.views.decorators.csrf import csrf_exempt
from loomapi import LoomAPI, verify_webhook_signature

client = LoomAPI(api_key=settings.LOOM_API_KEY)

@csrf_exempt
def loom_webhook(request):
    if not verify_webhook_signature(
        request.body,
        request.headers.get('X-Loom-Signature'),
        settings.LOOM_WEBHOOK_SECRET
    ):
        return JsonResponse({'error': 'Invalid signature'}, status=401)

    data = json.loads(request.body)
    handle_verification_event(data['event'], data['verification'])

    return JsonResponse({'status': 'ok'})

def verify_user(request):
    try:
        result = client.verify(
            document_type='passport',
            document_data=request.POST['document_data']
        )
        return JsonResponse({
            'verified': result.status == 'verified',
            'age': result.verified_age
        })
    except Exception as e:
        return JsonResponse({'error': str(e)}, status=400)

Testing

Mock Client

import { MockLoomAPI } from '@loomapi/node-sdk/test-utils'

const mockClient = new MockLoomAPI({
  defaultResponse: {
    status: 'verified',
    verified_age: 25,
    confidence_score: 0.95
  }
})

// Use in tests
const result = await mockClient.verify({
  documentType: 'passport',
  documentData: 'mock_data'
})

Test Scenarios

const testClient = new MockLoomAPI()

// Configure different responses
testClient.setScenario('success', {
  status: 'verified',
  verified_age: 25,
  confidence_score: 0.98
})

testClient.setScenario('underage', {
  status: 'rejected',
  reason: 'underage',
  verified_age: 16
})

testClient.setScenario('error', {
  status: 'error',
  error: { code: 'DOCUMENT_QUALITY_LOW' }
})

Coming Soon

We're actively working on SDKs for additional languages:

  • Go: Planned Q2 2024
  • PHP: Planned Q3 2024
  • Ruby: Planned Q4 2024
  • Java: Planned Q1 2025

Want a specific language? Let us know at sdk-requests@loomapi.com.

Migration Guide

From REST API to SDK

// Before (REST)
const response = await fetch('https://api.loomapi.com/v1/verify', {
  method: 'POST',
  headers: {
    'Authorization': `Bearer ${apiKey}`,
    'Content-Type': 'application/json'
  },
  body: JSON.stringify({
    document_type: 'passport',
    document_data: imageData
  })
})
const result = await response.json()

// After (SDK)
import { LoomAPI } from '@loomapi/node-sdk'
const client = new LoomAPI({ apiKey })
const result = await client.verify({
  documentType: 'passport',
  documentData: imageData
})

Support

Documentation

Community

Getting Help

Changelog

v2.1.0 (Latest)

  • Added batch verification support
  • Improved error handling
  • Enhanced webhook signature verification

v2.0.0

  • Complete rewrite with TypeScript
  • Added Python SDK
  • Improved retry logic

v1.5.0

  • Added webhook utilities
  • Enhanced test utilities
  • Better error messages
Next
Overview