• Introduction
• Key Benefits
• Use cases
• Endpoints
• Schemas
• Integration guidelines
• Samples
• Contacts

YouLive API

Welcome to YouLive API, part of the Youverse Services suite.

The YouLive API provides generic facial liveness detection — verifying whether a presented face image or video originates from a real, live person rather than a spoof (e.g., a photo, screen replay, or deepfake).

This API is designed to be easily integrated into onboarding, KYC, and authentication workflows, helping ensure that biometric verifications are performed only on live individuals.

iBeta Compliance

YouLive has successfully passed iBeta Presentation Attack Detection (PAD) testing in accordance with ISO/IEC 30107-3 standards.
This certification confirms that the system meets internationally recognized criteria for detecting and preventing biometric spoofing attacks.
The evaluation, conducted by iBeta Quality Assurance, validated YouLive’s ability to reliably distinguish between live users and various types of presentation attacks — including printed photos, digital displays, and mask-based attempts.
Achieving iBeta compliance demonstrates Youverse’s commitment to industry-grade security, regulatory trustworthiness, and continuous validation of its biometric technologies.

YouLive supports two levels of liveness assurance:

• ISO/IEC 30107-3 Level 1
  Detects simple presentation attacks such as printed photos or digital replays. Ideal for rapid, low-latency use cases where user experience is highly prioritized.

• ISO/IEC 30107-3 Level 2 (Advanced Liveness)
  Adds robustness against sophisticated attacks including 3D masks, deepfake videos, and face injections. This level uses multi-frame temporal analysis and micro-movement cues for higher accuracy.

Both modes are accessible via the same endpoint, with the level defined in the request payload.

Key Benefits

Enhanced Security

YouLive applies advanced anti-spoofing algorithms to detect both simple and complex presentation attacks, including printed photos, screen replays, and 3D masks.
This ensures that biometric authentication is performed only on genuine, live users.

Frictionless User Experience

The API is optimized for speed and simplicity — a single selfie or short video is enough to complete the liveness check.
Users experience near-instant feedback, allowing seamless integration into mobile apps and web onboarding flows.

Scalable and Flexible Integration

YouLive can be deployed in various environments — cloud, hybrid, or on-premise — and easily integrates with existing identity systems, KYC platforms, or custom verification pipelines through simple REST endpoints.

Privacy and Compliance Ready

All processing is compliant with GDPR and aligned with ISO 27001 and ISO 42001 principles for AI governance.
YouLive performs liveness detection without retaining identifiable biometric data beyond the verification session, ensuring privacy by design.

Continuous Evolution

As part of the Youverse verification ecosystem, YouLive continuously evolves with new model versions, threat intelligence updates, and adaptive anti-spoofing mechanisms.
This ensures long-term resilience against emerging attack vectors and evolving compliance standards.

Use Cases

Banking & Fintech

YouLive enhances digital onboarding, loan approval, and account recovery processes by ensuring that users are physically present and not using spoofed or replayed images.

It helps prevent identity theft and synthetic fraud, enabling financial institutions to meet regulatory requirements for strong biometric authentication.

Gaming & eSports

In gaming environments, YouLive can be used to verify player identity, enforce age restrictions, and detect multi-account abuse.

It supports fair play in identity-based tournaments and helps build a trusted environment for both competitive and social gaming.

Telecommunications

Telecom providers can integrate YouLive to secure SIM registration, mobile account creation, and number portability workflows.

By ensuring that each face verification corresponds to a live individual, operators reduce the risk of fraudulent activations and account takeovers.

E-commerce & Marketplace Platforms

YouLive strengthens trust and safety by verifying the authenticity of users during high-value transactions, account creation, or delivery handovers.

It protects both merchants and customers against impersonation and fraudulent claims.

Mobility & On-demand Services

In ride-sharing, delivery, and other gig-economy platforms, YouLive ensures that the person providing or receiving a service matches the verified user profile.

This prevents impersonation, builds user trust, and ensures regulatory compliance in identity-sensitive contexts.

Government & Identity Programs

YouLive can be integrated into eID, digital passport, and citizen verification systems to guarantee that each biometric submission comes from a real person.

It supports both online and kiosk-based identity verification while maintaining compliance with privacy and data protection standards.

Endpoints

Liveness

Endpoint to perform facial liveness estimation. It accepts an image in Base64 format and a configuration set, returning a confidence score, status, and confidence level.

POST | {base_url}/liveness

Accepts: Process request

Success

Error responses

Schemas

Process request

Request processing of an image in base64 and the liveness configurations.

{
    "image": "string",
    "configuration": [configA, configB]
}

Properties

Process request config

Extensible configurations for biometric processing.

{
    "name": "string",
    "value": "string"
}

Properties

Enumerable types

Process Response

Processed image results. Each element of the array corresponds to a different face detected.

{
    "score": float,
    "status": string,
    "confidence_level": string
}

Properties

Enumerable types

Error response

{
  "status_code": 400,
  "phrase": "string",
  "message": "string"
}

Integration guidelines

The YouLive API is designed for secure server-side (backend) integrations only.

Because the API requires an x-api-key for authentication and processes sensitive biometric data, all calls should be made from a trusted server environment — never directly from a web or mobile frontend.

Why Backend Integration?

warning Security of API Keys

Exposing your private x-api-key in frontend code (JavaScript, mobile apps, or browsers) risks unauthorized use and potential data breaches.

By keeping requests on the server, you ensure that credentials and traffic remain protected.

info Data Privacy & Compliance

Backend integration allows you to handle user images securely, apply encryption or anonymization, and comply with GDPR, ISO 27001, and AI governance requirements.

info Scalability & Control

Integrating on the backend gives you full control over logging, retries, monitoring, and model-level versioning without impacting the user experience.

info Centralized Decision Logic

Backend flows allow combining YouLive with other verification steps (e.g., YouAge or YouFace) through a single API gateway or orchestration layer.

Recommended Setup

primary Frontend Capture

Capture the user’s selfie using the official Youverse WebComponent or your own frontend implementation.

Send the Base64-encoded image securely to your backend.

primary Backend Processing

Your backend server (Node.js, Python, etc.) calls the YouLive API endpoint using your private x-api-key, receives the liveness response, and forwards only the decision back to the frontend.

primary Decision & Logging

Store the result and any relevant metadata securely for audit or analytics purposes.

Samples

The examples below demonstrate how to securely call the YouLive API in a backend context.

Python

import requests
import base64

# Encode your image (binary or path)
with open("selfie.jpg", "rb") as f:
    image_b64 = base64.b64encode(f.read()).decode("utf-8")

url = f'{base_url}/liveness'
headers = {
    "x-api-key": "YOUR_API_KEY"
}

payload = {
    "configuration": [
        {"name": "liveness_method", "value": value}
    ],
    "image": image_b64
}

response = requests.post(url, json=payload, headers=headers)
print(response.json())

Node.js

import axios from "axios";
import fs from "fs";

const url = `${baseUrl}/liveness`;

// Read and encode image as base64
const imageBuffer = fs.readFileSync("selfie.jpg");
const imageBase64 = imageBuffer.toString("base64");

const payload = {
  configuration: [
    { name: "liveness_method", value: value }
  ],
  image: imageBase64
};

axios.post(url, payload, {
  headers: {
    "Content-Type": "application/json",
    "x-api-key": "YOUR_API_KEY"
  }
})
  .then(response => console.log(response.data))
  .catch(error => console.error("Error:", error.response?.data || error.message));

OpenAPI Specification

The following OpenAPI 3.0 YAML defines the YouLive API endpoints, schemas, and security settings.
You can import it directly into tools such as Swagger UI, Postman, or Insomnia.

Contacts

Please check our github space for more information about our integration SDKs.
We are working to expand our current SDK offering. If you want to contribute please contact us.