VitePress

Appearance

YeboVerify Code Examples ​

cURL ​

Selfie Match Verification ​

bash
curl -X POST https://api.yeboverify.com/v1/verify/selfie-match \
  -H "X-API-Key: your_api_key" \
  -F "selfie=@/path/to/selfie.jpg" \
  -F "profilePictureUrl=https://example.com/user/profile.jpg" \
  -F "externalRef=user_123"

ID Document Verification ​

bash
curl -X POST https://api.yeboverify.com/v1/verify/id-document \
  -H "X-API-Key: your_api_key" \
  -F "selfie=@/path/to/selfie.jpg" \
  -F "idFront=@/path/to/id-front.jpg" \
  -F "idBack=@/path/to/id-back.jpg" \
  -F "externalRef=user_123"

List Verifications ​

bash
curl -X GET "https://api.yeboverify.com/v1/verifications?page=1&limit=20" \
  -H "X-API-Key: your_api_key"

Get Verification Details ​

bash
curl -X GET https://api.yeboverify.com/v1/verifications/vrf_id_abc123 \
  -H "X-API-Key: your_api_key"

Node.js ​

Installation ​

bash
npm install node-fetch form-data
# or with axios
npm install axios form-data

Selfie Match Verification ​

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

async function verifySelfieMatch(selfiePath, profilePictureUrl, externalRef) {
  const form = new FormData();
  form.append('selfie', fs.createReadStream(selfiePath));
  form.append('profilePictureUrl', profilePictureUrl);
  if (externalRef) {
    form.append('externalRef', externalRef);
  }

  const response = await fetch('https://api.yeboverify.com/v1/verify/selfie-match', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.YEBOVERIFY_API_KEY,
      ...form.getHeaders(),
    },
    body: form,
  });

  const result = await response.json();
  
  if (!result.success) {
    throw new Error(result.error.message);
  }
  
  return result.data;
}

// Usage
const result = await verifySelfieMatch(
  './selfie.jpg',
  'https://example.com/profile.jpg',
  'user_123'
);

console.log('Same person:', result.samePerson);
console.log('Match score:', result.matchScore);
console.log('Confidence:', result.confidence);

ID Document Verification ​

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

async function verifyIDDocument(selfiePath, idFrontPath, idBackPath, externalRef) {
  const form = new FormData();
  form.append('selfie', fs.createReadStream(selfiePath));
  form.append('idFront', fs.createReadStream(idFrontPath));
  
  if (idBackPath) {
    form.append('idBack', fs.createReadStream(idBackPath));
  }
  
  if (externalRef) {
    form.append('externalRef', externalRef);
  }

  const response = await fetch('https://api.yeboverify.com/v1/verify/id-document', {
    method: 'POST',
    headers: {
      'X-API-Key': process.env.YEBOVERIFY_API_KEY,
      ...form.getHeaders(),
    },
    body: form,
  });

  const result = await response.json();
  
  if (!result.success) {
    throw new Error(result.error.message);
  }
  
  return result.data;
}

// Usage
const result = await verifyIDDocument(
  './selfie.jpg',
  './id-front.jpg',
  './id-back.jpg',
  'user_123'
);

console.log('Decision:', result.decision);
console.log('Name:', result.documentData.names, result.documentData.surname);
console.log('ID Number:', result.documentData.idNumber);

YeboVerify Client Class ​

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

class YeboVerifyClient {
  constructor(apiKey) {
    this.apiKey = apiKey;
    this.baseUrl = 'https://api.yeboverify.com';
  }

  async selfieMatch(selfiePath, profilePictureUrl, options = {}) {
    const form = new FormData();
    form.append('selfie', fs.createReadStream(selfiePath));
    form.append('profilePictureUrl', profilePictureUrl);
    
    if (options.externalRef) {
      form.append('externalRef', options.externalRef);
    }

    return this._request('POST', '/v1/verify/selfie-match', form);
  }

  async idDocument(selfiePath, idFrontPath, options = {}) {
    const form = new FormData();
    form.append('selfie', fs.createReadStream(selfiePath));
    form.append('idFront', fs.createReadStream(idFrontPath));
    
    if (options.idBackPath) {
      form.append('idBack', fs.createReadStream(options.idBackPath));
    }
    
    if (options.externalRef) {
      form.append('externalRef', options.externalRef);
    }
    
    if (options.documentType) {
      form.append('documentType', options.documentType);
    }

    return this._request('POST', '/v1/verify/id-document', form);
  }

  async listVerifications(options = {}) {
    const params = new URLSearchParams();
    if (options.page) params.append('page', options.page);
    if (options.limit) params.append('limit', options.limit);
    if (options.status) params.append('status', options.status);

    const query = params.toString() ? `?${params.toString()}` : '';
    return this._request('GET', `/v1/verifications${query}`);
  }

  async getVerification(verificationId) {
    return this._request('GET', `/v1/verifications/${verificationId}`);
  }

  async _request(method, path, body = null) {
    const headers = {
      'X-API-Key': this.apiKey,
    };

    if (body instanceof FormData) {
      Object.assign(headers, body.getHeaders());
    }

    const response = await fetch(`${this.baseUrl}${path}`, {
      method,
      headers,
      body,
    });

    const result = await response.json();
    
    if (!result.success) {
      const error = new Error(result.error.message);
      error.code = result.error.code;
      throw error;
    }
    
    return result.data;
  }
}

// Usage
const client = new YeboVerifyClient(process.env.YEBOVERIFY_API_KEY);

// Selfie match
const selfieResult = await client.selfieMatch('./selfie.jpg', 'https://example.com/profile.jpg');

// ID document verification
const idResult = await client.idDocument('./selfie.jpg', './id-front.jpg', {
  idBackPath: './id-back.jpg',
  externalRef: 'user_123',
});

// List verifications
const verifications = await client.listVerifications({ page: 1, limit: 10 });

Python ​

Installation ​

bash
pip install requests

Selfie Match Verification ​

python
import requests
import os

def verify_selfie_match(selfie_path, profile_picture_url, external_ref=None):
    url = 'https://api.yeboverify.com/v1/verify/selfie-match'
    
    headers = {
        'X-API-Key': os.environ.get('YEBOVERIFY_API_KEY')
    }
    
    with open(selfie_path, 'rb') as selfie_file:
        files = {
            'selfie': selfie_file
        }
        data = {
            'profilePictureUrl': profile_picture_url
        }
        
        if external_ref:
            data['externalRef'] = external_ref
        
        response = requests.post(url, headers=headers, files=files, data=data)
    
    result = response.json()
    
    if not result.get('success'):
        raise Exception(result['error']['message'])
    
    return result['data']


# Usage
result = verify_selfie_match(
    './selfie.jpg',
    'https://example.com/profile.jpg',
    'user_123'
)

print(f"Same person: {result['samePerson']}")
print(f"Match score: {result['matchScore']}")
print(f"Confidence: {result['confidence']}")

ID Document Verification ​

python
import requests
import os

def verify_id_document(selfie_path, id_front_path, id_back_path=None, external_ref=None):
    url = 'https://api.yeboverify.com/v1/verify/id-document'
    
    headers = {
        'X-API-Key': os.environ.get('YEBOVERIFY_API_KEY')
    }
    
    files = {}
    data = {}
    
    try:
        files['selfie'] = open(selfie_path, 'rb')
        files['idFront'] = open(id_front_path, 'rb')
        
        if id_back_path:
            files['idBack'] = open(id_back_path, 'rb')
        
        if external_ref:
            data['externalRef'] = external_ref
        
        response = requests.post(url, headers=headers, files=files, data=data)
    finally:
        for f in files.values():
            f.close()
    
    result = response.json()
    
    if not result.get('success'):
        raise Exception(result['error']['message'])
    
    return result['data']


# Usage
result = verify_id_document(
    './selfie.jpg',
    './id-front.jpg',
    './id-back.jpg',
    'user_123'
)

print(f"Decision: {result['decision']}")
print(f"Name: {result['documentData']['names']} {result['documentData']['surname']}")
print(f"ID Number: {result['documentData']['idNumber']}")

YeboVerify Client Class ​

python
import requests
import os
from typing import Optional, Dict, Any


class YeboVerifyClient:
    def __init__(self, api_key: str):
        self.api_key = api_key
        self.base_url = 'https://api.yeboverify.com'
    
    def selfie_match(
        self,
        selfie_path: str,
        profile_picture_url: str,
        external_ref: Optional[str] = None
    ) -> Dict[str, Any]:
        """Compare a selfie against a profile picture URL."""
        with open(selfie_path, 'rb') as selfie_file:
            files = {'selfie': selfie_file}
            data = {'profilePictureUrl': profile_picture_url}
            
            if external_ref:
                data['externalRef'] = external_ref
            
            return self._request('POST', '/v1/verify/selfie-match', files=files, data=data)
    
    def id_document(
        self,
        selfie_path: str,
        id_front_path: str,
        id_back_path: Optional[str] = None,
        external_ref: Optional[str] = None,
        document_type: Optional[str] = None
    ) -> Dict[str, Any]:
        """Full ID document verification with OCR and face matching."""
        files = {}
        data = {}
        
        try:
            files['selfie'] = open(selfie_path, 'rb')
            files['idFront'] = open(id_front_path, 'rb')
            
            if id_back_path:
                files['idBack'] = open(id_back_path, 'rb')
            
            if external_ref:
                data['externalRef'] = external_ref
            
            if document_type:
                data['documentType'] = document_type
            
            return self._request('POST', '/v1/verify/id-document', files=files, data=data)
        finally:
            for f in files.values():
                f.close()
    
    def list_verifications(
        self,
        page: int = 1,
        limit: int = 20,
        status: Optional[str] = None
    ) -> Dict[str, Any]:
        """List verifications for your business."""
        params = {'page': page, 'limit': limit}
        if status:
            params['status'] = status
        
        return self._request('GET', '/v1/verifications', params=params)
    
    def get_verification(self, verification_id: str) -> Dict[str, Any]:
        """Get details of a specific verification."""
        return self._request('GET', f'/v1/verifications/{verification_id}')
    
    def _request(
        self,
        method: str,
        path: str,
        files: Optional[Dict] = None,
        data: Optional[Dict] = None,
        params: Optional[Dict] = None
    ) -> Dict[str, Any]:
        headers = {'X-API-Key': self.api_key}
        
        response = requests.request(
            method,
            f'{self.base_url}{path}',
            headers=headers,
            files=files,
            data=data,
            params=params
        )
        
        result = response.json()
        
        if not result.get('success'):
            raise YeboVerifyError(
                result['error']['message'],
                result['error']['code']
            )
        
        return result['data']


class YeboVerifyError(Exception):
    def __init__(self, message: str, code: str):
        self.message = message
        self.code = code
        super().__init__(f"[{code}] {message}")


# Usage
client = YeboVerifyClient(os.environ.get('YEBOVERIFY_API_KEY'))

# Selfie match
selfie_result = client.selfie_match('./selfie.jpg', 'https://example.com/profile.jpg')

# ID document verification
id_result = client.id_document(
    './selfie.jpg',
    './id-front.jpg',
    id_back_path='./id-back.jpg',
    external_ref='user_123'
)

# List verifications
verifications = client.list_verifications(page=1, limit=10)

Browser (JavaScript/TypeScript) ​

Selfie Match with File Input ​

javascript
async function verifySelfie(selfieFile, profilePictureUrl) {
  const formData = new FormData();
  formData.append('selfie', selfieFile);
  formData.append('profilePictureUrl', profilePictureUrl);

  const response = await fetch('https://api.yeboverify.com/v1/verify/selfie-match', {
    method: 'POST',
    headers: {
      'X-API-Key': 'your_api_key', // Note: Don't expose API keys in client-side code!
    },
    body: formData,
  });

  return response.json();
}

// Usage with file input
document.getElementById('verifyBtn').addEventListener('click', async () => {
  const selfieInput = document.getElementById('selfieInput');
  const selfieFile = selfieInput.files[0];
  
  if (!selfieFile) {
    alert('Please select a selfie');
    return;
  }

  try {
    const result = await verifySelfie(selfieFile, 'https://example.com/profile.jpg');
    
    if (result.success) {
      console.log('Match score:', result.data.matchScore);
      console.log('Same person:', result.data.samePerson);
    } else {
      console.error('Error:', result.error.message);
    }
  } catch (error) {
    console.error('Request failed:', error);
  }
});

Using Base64 Images ​

javascript
// Convert file to base64
function fileToBase64(file) {
  return new Promise((resolve, reject) => {
    const reader = new FileReader();
    reader.readAsDataURL(file);
    reader.onload = () => resolve(reader.result);
    reader.onerror = reject;
  });
}

// Convert base64 to Blob for FormData
function base64ToBlob(base64, mimeType) {
  const byteString = atob(base64.split(',')[1]);
  const ab = new ArrayBuffer(byteString.length);
  const ia = new Uint8Array(ab);
  
  for (let i = 0; i < byteString.length; i++) {
    ia[i] = byteString.charCodeAt(i);
  }
  
  return new Blob([ab], { type: mimeType });
}

// Usage
const base64Image = await fileToBase64(file);
const blob = base64ToBlob(base64Image, 'image/jpeg');
const formData = new FormData();
formData.append('selfie', blob, 'selfie.jpg');

⚠️ Security Warning: Never expose your API key in client-side code. Always make API calls from your backend server.