Face Match API

async function submitFaceMatch(accessToken: string, userImageFile: File, referenceImageFile: File, options = null) {
 
  const url = `https://verification.didit.me/v2/face-match`;
 
  const formData = new FormData();
  formData.append('user_image', userImageFile);
  formData.append('ref_image', referenceImageFile);
 
  // Add options if provided
  if (options) {
    formData.append('options', JSON.stringify(options));
  }
 
  const requestOptions = {
    method: 'POST',
    headers: {
      'Authorization': `Bearer ${accessToken}`
    },
    body: formData
  };
 
  try {
    const response = await fetch(url, requestOptions);
 
    if (!response.ok) {
      const errorData = await response.json();
      throw new Error(errorData.detail || errorData.error?.message || 'Unknown error occurred');
    }
 
    return await response.json();
  } catch (error) {
    console.error('Error in face match:', error);
    throw error;
  }
}
 
// Example usage
async function performFaceMatch() {
  try {
    // 1. Get client token (implement based on auth documentation)
    const token = await getClientToken();
 
    // 2. Get image files (from file input or other source)
    const userImageFile = document.getElementById('user-image-input').files[0];
    const referenceImageFile = document.getElementById('reference-image-input').files[0];
 
    // 3. Custom options (optional)
    const options = {
      face_match_score_decline_threshold: 35,
    };
 
    // 4. Submit face match
    const result = await submitFaceMatch(
      token.access_token,
      userImageFile,
      referenceImageFile,
      options
    );
 
    console.log('Face match result:', result);
    return result;
  } catch (error) {
    console.error('Error:', error);
    throw error;
  }
}

import requests
import json
 
def submit_face_match(access_token: str, user_image_file: bytes, ref_image_file: bytes, options=None):
    """
    Submit two facial images for comparison.
 
    Args:
        access_token (str): The access token for authorization.
        user_image_file (file): The user's face image file object.
        ref_image_file (file): The reference face image file object.
        options (dict, optional): Custom threshold options for face matching.
 
    Returns:
        dict: The face match results.
    """
    url = "https://verification.didit.me/v2/face-match"
    headers = {
        "Authorization": f"Bearer {access_token}"
    }
    files = {
        "user_image": user_image_file,
        "ref_image": ref_image_file
    }
 
    # Add options if provided
    data = {}
    if options:
        data['options'] = json.dumps(options)
 
    try:
        response = requests.post(url, headers=headers, files=files, data=data)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f"Error in face match: {e}")
        if hasattr(e, 'response') and e.response:
            print(f"Response: {e.response.text}")
        raise
 
# Example usage
def perform_face_match():
    try:
        # 1. Get client token (implement based on auth documentation)
        token = get_client_token()
 
        # 2. Custom options (optional)
        options = {
            "face_match_score_decline_threshold": 35,
        }
 
        # 3. Get image files (from file input or other source)
        with open("user_image.jpg", "rb") as user_img, open("ref_image.jpg", "rb") as ref_img:
            # 4. Submit face match
            result = submit_face_match(
                token["access_token"],
                user_img,
                ref_img,
                options
            )
 
        print('Face match result:', result)
        return result
    except Exception as e:
        print(f"Error: {e}")
        raise