1 of 100

EN: Oz Knowledge Base

General

Oz Liveness and Biometry Key Concepts

Oz Forensics specializes in liveness and face matching: we develop products that help you identify your clients remotely and protect against spoofing and deepfake attacks. Oz software helps you to add facial recognition to your software systems and products. You can integrate Oz modules in many ways depending on your needs. We are constantly improving our components, increasing their quality.

Oz Liveness is responsible for recognizing a living person on a video it receives. Oz Liveness can distinguish a real human from their photo, video, mask, or other kinds of spoofing and deepfake attacks. The accuracy of our algorithms is confirmed by BixeLab, the independent biometric testing laboratory.

Here are the confirmation letters from the laboratory.

Solution Architecture

This article describes Oz components that can be integrated into your infrastructure in various combinations depending on your needs.

The typical integration scenarios are described in the Integration Quick Start Guides section.

Oz API

Oz API is the central component of the system. It provides RESTful application programming interface to the core functionality of Liveness and Face matching analyses, along with many important supplemental features:

Persistence: your media and analyses are stored for future reference unless you explicitly delete them,
Authentication, roles and access management,
Asynchronous analyses,
Ability to work with videos as well as images.

For more information, please refer to and . To test Oz API, please check the Postman collection .

Under the logical hood, Oz API has the following components:

File storage and database where media, analyses, and other data are stored,
The Oz BIO module that runs neural network models to perform facial biometry magic,
Licensing logic.

The front-end components (Oz Liveness Mobile or Web SDK) connect to Oz API to perform server-side analyses either directly or via customer's back end.

iOS and Android SDK are collectively referred to as Mobile SDKs or Native SDKs. They are written on Swift and Kotlin/Java, respectively, and designed to be integrated into your native mobile application.

Mobile SDKs implement the out-of-the-box customizable user interface for capturing Liveness video and ensure that the two main objectives are met:

The capture process is smooth for users,
The quality of a video is optimal for the subsequent Liveness analysis.

After Liveness video is recorded and available to your mobile application, you can run the server-side analysis. You can use corresponding SDK methods, call the API directly from your mobile application, or pass the media to your backend and interact with Oz API from there.

The basic integration option is described in the .

Mobile SDKs are also capable of On-device Liveness and Face matching when Oz API is not required.

Web Adapter and Web Plugin together constitute Web SDK.

Web SDK is designed to be integrated into your web applications and have the same main goals as Mobile SDKs:

The capture process is smooth for users,
The quality of a video is optimal for the subsequent Liveness analysis.

Web Adapter needs to be set up on a server side. Web Plugin is called by your web application and works in a browser context. It communicates with Web Adapter, which, in turn, communicates with Oz API.

Web SDK adds the two-layer protection against injection attacks:

Collects information about browser context and camera properties to detect usage of virtual cameras or other injection methods.
Records liveness video in a format that allows server-side neural networks to search for traces of injection attack in the video itself.

Check the for the basic integration scenario, and explore the for more details.

Web UI is a convenient user interface that allows to explore the stored API data in the easy way. It relies on API authentication and database and does not store any data on its own.

Web console has an intuitive interface, yet the user guide is available .

Passive and Active Liveness

Describing how passive and active liveness works.

The objective of the Liveness check is to verify the authenticity and physical presence of an individual in front of the camera. In the passive Liveness check, it is sufficient to capture a user's face while they look into the camera. Conversely, the active Liveness check requires the user to perform an action such as smiling, blinking, or turning their head. While passive Liveness is more user-friendly, active Liveness may be necessary in some situations to confirm that the user is aware of undergoing the Liveness check.

In our Mobile or Web SDKs, you can define what action the user is required to do. You can also combine several actions into a sequence. Actions vary in the following dimensions:

User experience,

Oz API Key Concepts

The Oz API is a comprehensive Rest API that enables facial biometrics, allowing for both face matching and liveness checks. This write-up provides an overview of the essential concepts that one should keep in mind while using the Oz API.

Authentication, roles, and access management

To ensure security, every Oz API call requires an access token in its HTTP headers. To obtain this token, execute the POST /api/authorize/auth method with login and password provided by us. Pass this token in X-Forensic-Access-Token header in subsequent Oz API calls.

This article provides comprehensive details on the authentication process. Kindly refer to it for further information.

Furthermore, the Oz API offers distinct user roles, ranging from CLIENT, who can perform checks and access reports but lacks administrative rights, e.g., deleting folders, to ADMIN, who enjoys nearly unrestricted access to all system objects. For additional information, please consult .

The unit of work in Oz API is a folder: you can upload interrelated media to a folder, run analyses on them, and check for the aggregated result. A folder can contain the unlimited number of media, and each of the media can be a target of several analyses. Also, analyses can be performed on a bunch of media.

Media OZ API works with photos and videos. Video can be either a regular video container, e.g., MP4 or MOV, or a ZIP archive with a sequence of images. Oz API uses the file mime type to define whether media is an image, a video, or a shot set.

It is also important to determine the semantics of a content, e.g., if an image is a photo of a document or a selfie of a person. This is achieved by using tags. The selection of tags impacts whether specific types of analyses will recognize or ignore particular media files. The most important tags are:

photo_id_front – for the front side of a photo ID
photo_selfie – for a non-document reference photo
video_selfie_blank

The full list of Oz media tags with their explanation and examples can be found .

Since video analysis may take a few seconds, the analyses are performed asynchronously. This implies that you initiate an analysis (/api/folders/{{folder_id}}/analyses/) and then monitor the outcomes by polling until processing is complete (/api/analyses/{{analysis_id}} for a single analysis or /api/folders/{{folder_id}}/analyses/ for all folder’s analyses). Alternatively, there is a webhook option available. To see an example of how to use both the polling and webhook options, please check .

These were the key concepts of Oz API. To gain a deeper understanding of its capabilities, please refer to the of our developer guide.

SaaS, On-premise, On-device: What to Choose

We offer different usage models for the Oz software to meet your specific needs. You can either utilize the software as a service from one of our cloud instances or integrate it into your existing infrastructure. Regardless of the usage model you choose, all Oz modules will function equally. It’s only up to you what to pick, depending on your needs.

When to choose SaaS

With the SaaS model, you can access one of our clouds without having to install our software in your own infrastructure.

Choose SaaS when you want:

Faster start as you don’t need to procure or allocate hardware within your company and set up a new instance.
Zero infrastructure cost as server components are located in Oz cloud.
Lower maintenance cost as Oz maintains and upgrades server components.
No cross-border data transfer for the regions where Oz has cloud instances.

The on-premise model implies that all the Oz components required are installed within your infrastructure. Choose on-premise for:

Your data not leaving your infrastructure.
Full and detailed control over the configuration.

We also provide an opportunity of using the on-device Liveness and Face matching. This model is available in Mobile SDKs.

Consider the on-device option when:

You can’t transmit facial images to any server due to privacy concerns
The network conditions whereon you plan using Oz products are extremely poor.

The choice is yours to make, but we're always available to provide assistance.

Oz Licensing Options

For commercial use of Oz Forensics products, a license is required. The license is time-limited and defines the software access parameters based on the terms of your agreement.

Once you initialize mobile SDK, run Web Plugin, or use Oz Bio, the system checks if your license is valid. The check runs in the background and has minimal impact on the user experience.

As you can see on the scheme above, the license is required for:

Mobile SDKs for iOS and Android,

Proprietary Format: OzCapsula Data Container

To improve the overall security level or Oz products, we’ve introduced a new proprietary data exchange format that provides improved data confidentiality and integrity: OzCapsula.

How it works

A proprietary data exchange format is a container that safely stores and transmits transaction-related media data.

When you capture video using Oz SDK, your media is placed into the OzCapsula container along with all required information. The package can be processed only in Oz API due to internal mechanisms, so it is significantly more difficult to access the package containing.

Please note: we do not disclose specific technical details for security reasons.

Benefits

Integrity and Authenticity Guaranteed. Each container’s content is verified by the API, ensuring data arriving from the user device is genuine, untampered, and fully intact.
Full Confidentiality of Internal Data. Multi-layered cryptographic protection keeps all data, metadata, and technical details hidden from unauthorized viewing, extraction, or interpretation.
Unified Data Package. All content is stored in a single, secure file, simplifying transmission and enabling consistent, predictable processing.
Built-In Investigation Tools. Every action within the container is logged, giving complete visibility for incident analysis and rapid troubleshooting.
Strict, Built-In Access Control. Only authorized systems can open or use the container, preventing misuse, tampering attempts, or unauthorized integration.
Ready for High-Volume Workflows. The container is designed to scale effortlessly, supporting any number of transmissions without performance or integration issues.

Minimal component versions:

API: 6.6.1.
Web SDK: 1.9.10.
Native SDKs: 10.0.0.

You will also require a new token: session_token.

Configure SDK and API:

Integration Quick Start Guides

This section contains the most common cases of integrating the Oz Forensics Liveness and face Biometry system.

The scenarios can be combined together, for example, integrating liveness into both web and mobile applications or integrating liveness with face matching.

How to Integrate Oz Liveness Using the Non-Persistent Oz API Mode How to Integrate Oz Liveness into Your Web Application How to Integrate Oz Liveness into Your Mobile Application How to Perform a Face Matching Analysis

You can also download Postman collections for Oz API. Please find them here.

Face Matching for Non-OzCapsula Flow

In this section, we listed the guides for the face matching checks.

Guides

Developer Guide

In this section, you will find the description of both API and SDK components of Oz Forensics Liveness and face biometric system. API is the backend component of the system, it is needed for all the system modules to interact with each other. SDK is the frontend component that is used to:

1) take videos or images which are then processed via API,

2) display results.

We provide two versions of API.

With full version, we provide you with all functionality of Oz API.

The Lite version is a simple and lightweight version with only the necessary functions included.

The SDK component consists of web SDK and mobile SDK.

API

Oz API

Oz API is the most important component of the system. It makes sure all other components are connected with each other. Oz API:

provides the unified Rest API interface to run the Liveness and Biometry analyses,
processes authorization and user permissions management,

Basic Scenarios

Liveness is checking that a person on a video is a real living person.

Liveness

Biometry compares two or more faces from different media files and shows whether the faces belong to the same person or not.

Biometry (Face Matching)

Best shot is an addition to the Liveness check. The system chooses the best frame from a video and saves it as a picture for later use.

Best Shot

Blacklist checks whether a face on a photo or a video matches with one of the faces in the pre-created database.

Collection (1:N) Check

Liveness

The Liveness detection algorithm is intended to detect a real living person in a media.

Requirements

You're authorized.
You have already created a folder and added your media marked by correct tags into this folder. For API 4.0.8 and below, please note: the Liveness analysis works with videos and shotsets, images are ignored. If you want to analyze an image, upload it as a shotset (archive) with a single image and mark with the video_selfie_blank tag.

Processing Steps

1. Initiate the analysis for the folder: POST /api/folders/{{folder_id}}/analyses/

If you want to use a webhook for response, add it to the payload at this step, as described .

You'll needanalysis_id or folder_id from response.

2. If you use a webhook, just wait for it to return the information needed. Otherwise, initiate polling:

GET /api/analyses/{{analysis_id}} – for the analysis_id you have from the previous step.
GET api/folders/{{folder_id}}/analyses/ – for all analyses performed on media in the folder with the folder_id you have from the previous step.

Repeat the check until theresolution_status and resolution fields change status to any other except PROCESSING and treat this as a result.

For the Liveness Analysis, seek the confidence_spoofing value related to the video you need. It indicates a chance that a person is not a real one.

Best Shot

The "Best shot" algorithm is intended to choose the most high-quality and well-tuned frame with a face from a video record. This algorithm works as a part of the analysis, so here, we describe only the best shot part. Starting with API v6.0.1, the best shot is extracted and returned in the API response by default unless disabled for a specific purpose.

1. Initiate the analysis similar to , but make sure that extract_best_shot is set to true as shown below, or this line is omitted (for API 6.0.1 and newer):

If you want to use a webhook for response, add it to the payload at this step, as described .

2. Check and interpret results in the same way as for the pure analysis.

Collection (1:N) Check

How to compare a photo or video with ones from your database.

The collection check algorithm is designed to check the presence of a person using a database of preloaded photos. A video fragment and/or a photo can be used as a source for comparison.

Prerequisites:

You're authorized.
You have already created a folder and added your media marked by correct tags into this folder.
You have already uploaded a database of images for comparison. If not, please do it as described .

1. Initiate the analysis: POST/api/folders/{{folder_id}}/analyses/

If you want to use a webhook for response, add it to the payload at this step, as described .

You'll need analysis_id or folder_id from response.

2. If you use a webhook, just wait for it to return the information needed. Otherwise, initiate polling:

GET /api/analyses/{{analysis_id}} – for the analysis_id you have from the previous step.
GET /api/folders/{{folder_id}} – for all analyses performed on media in the folder with the folder_id you have from the previous step.

Wait for the resolution_status and resolution fields to change the status to anything other than PROCESSING and treat this as a result.

If you want to know which person from your collection matched with the media you have uploaded, find the collection analysis in the response, check results_media, and retrieve person_id. This is the ID of the person who matched with the person in your media. To get the information about this person, use GET /api/collections/{{collection_id}}/persons/{{person_id}} with IDs of your collection and person.

Collection (1:N) Management in Oz API

This article describes how to create a collection via API, how to add persons and photos to this collection and how to delete them and the collection itself if you no longer need it. You can do the same in , but this article covers API methods only.

Collection in Oz API is a database of facial photos that are used to compare with the face from the captured photo or video via the Collection analysis

Person represents a human in the collection. You can upload several photos for a single person.

The collection should be created within a company, so you require your company's company_id as a prerequisite.

OzCapsula Data Container

The main change in interaction with API is that you require to send data with another content type, as data container is a binary file: Content-Type = application/octet-stream. We've added support for this content type along with container functionality.

Also, Instant API now requires client’s private and public keys to function. The paths to these keys should be specified in OZ_JWT_PRIVATE_KEY_PATH and OZ_JWT_PUBLIC_KEY_PATH in the configuration file.

To generate them, use commands as listed below.

POST api/folders:

Instant API: Non-Persistent Mode

Instant API, or non-persistent operation mode, has been introduced in API 6.0.1. It is a mode where we do not save any data anywhere. All data is being used only within a request: you send it, receive the response, and that's all, nothing gets recorded. This ensures you do not store any sensitive data, which might be crucial for GDPR compliance. Also, it significantly reduces storage requirements.

To enable this mode, when you prepare the config.py file to run the API, set the OZ_APP_COMPONENTS parameter to stateless. Call POST /api/instant/folders/ to send the request without saving any data. Authorization for Instant API should be set on your side.

Please note: as Instant API doesn't store data, it is not intended to work with Blacklist (1:N).

If you use Instant API with Web SDK, in Web Adapter configuration, set architecture to lite. The version of Web SDK should be 1.7.14 or above.

CPU: 16 cores, 32 threads, base frequency – 2.3 GHz, single-core maximum turbo frequency – 4 GHz.
RAM: 32 GB, DDR 5, Dual Channel.

To evaluate your RPS and RPM and configure your system for optimal performance, please contact us.

Prior to the launch, prepare a configuration file with the parameters listed below.

These parameters are crucial to run Instant API.

You can find the Instant API methods or download the collection below.

Authentication and Non-Instant Data Handling

Authentication Uploading Media Quantitative Results Using a Webhook to Get Results

In API 6.0, we've implemented new analysis modes:

Single Request Instant API: Non-Persistent Mode

Authentication

Getting an access token

To get an access token, call POST /api/authorize/auth/ with credentials (which you've got from us) containing the email and password needed in the request body. The host address should be the API address (the one you've also got from us).

{
	"credentials": {
		"email": "{{user_email}}", // your login
		"password": "{{user_password}}" // your password
	}
}

The successful response will return a pair of tokens:access_token and expire_token.

access_token is a key that grants you access to system resources. To access a resource, you need to add your access_token to the header.

headers = {‘ X-Forensic-Access-Token’: <access_token>}

access_token is time-limited, the limits depend on the account type.

service accounts – OZ_SESSION_LONGLIVE_TTL (5 years by default),
other accounts – OZ_SESSION_TTL (15 minutes by default).

expire_token is the token you can use to renew your access token if necessary.

If the value ofexpire_date > current date, the value of current sessionexpire_date is set to current date + time period that is defined as shown above (depending on the account type).

To renewaccess_token and expire_token, call POST /api/authorize/refresh/. Add expire_token to the request body and X-Forensic-Access-Token to the header.

In case of success, you'll receive a new pair of access_token and expire_token. The "old" pair will be deleted upon the first authentication with the renewed tokens.

Uploading Media

To launch one or more analyses for your media files, you need to create a folder via Oz API (or use an existing folder) and put the files into this folder. Each file should be marked by tags: they describe what's pictured in a media and determine the applicable analyses.

For API 4.0.8 and below, please note: if you want to upload a photo for the subsequent Liveness analysis, put it into the ZIP archive and apply the tags.

To create a folder and upload media to it, call POST /api/folders/

To add files to the existing folder, call POST /api/folders/{{folder_id}}/media/

Add the files to the request body; tags should be specified in the payload.

Here's the example of the payload for a passive Liveness video and ID front side photo.

payload

{
    "media:tags": { // this section sets the tags for the media files that you upload
    // media files are referenced by the keys in a multipart form
        "video1": [ // your file key
        // a typical set of tags for a passive Liveness video
            "video_selfie", // video of a person
            "video_selfie_blank", // no gesture used
            "orientation_portrait" // video orientation
        ],
        "photo1": [
        // a typical set of tags for an ID front side
            "photo_id",
            "photo_id_front"
        ]
    }
}

An example of usage (Postman):

The successful response will return the folder data.

Quantitative Results

This article describes how to get the analysis scores.

When you perform an analysis, the result you get is a number. For biometry, it reflects a chance that the two or more people represented in your media are the same person. For liveness, it shows a chance of deepfake or a spoofing attack: that the person in uploaded media is not a real one. You can get these numbers via API from a JSON response.

Authorize.
Make a request to the folder or folder list to get a JSON response. Set the with_analyses parameter to true.
For the Biometry analysis, check the response for the min_confidence value:

This value is a quantitative result of matching the people on the media uploaded.

4. For the Liveness Analysis, seek the confidence_spoofing value related to the video you need:

This value is a chance that a person is not a real one.

To process a bunch of analysis results, you can parse the appropriate JSON response.

Using a Webhook to Get Results

The webhook feature simplifies getting analyses' results. Instead of polling after the analyses are launched, add a webhook that will call your website once the results are ready.

When you create a folder, add the webhook endpoint (resolution_endpoint) into the payload section of your request body:

Payload example

{    
  "resolution_endpoint": "address.com", // use address of your website here
    ... // other request details - folder etc.
}

You'll receive a notification each time the analyses are completed for this folder. The webhook request will contain information about the folder and its corresponding analyses.

Metadata

Metadata is any optional data you might need to add to a . In the meta_data section, you can include any information you want, simply by providing any number of fields with their values:

Metadata is available for most Oz system objects. Here is the list of these objects with the API methods required to add metadata. Please note: you can also add metadata to these objects during their creation.

Oz API Postman Collections

Download and install the Postman client from this Then download the JSON file needed:

Oz API 5.1.0 works with the same collection.

Launch the client and import Oz API collection for Postman by clicking the Import button:

Click files, locate the JSON needed, and hit Open to add it:

The collection will be imported and will appear in the Postman interface:

Oz API Lite (Deprecated)

What is Oz API Lite, when and how to use it.

Oz API Lite is the lightweight yet powerful version of Oz API. The Lite version is less resource-demanding, more productive, and easier to work with. The analyses are made within the API Lite image. As Oz API Lite doesn't include any additional services like statistics or data storage, this version is the one to use when you need a high performance.

To check the Liveness processor, GET /v1/face/liveness/health.

To check the Biometry processor, GET /v1/face/pattern/health.

To perform the liveness check for an image, POST /v1/face/liveness/detect (it takes an image as an input and displays the evaluation of spoofing attack chance in this image)

Oz API Lite Postman Collection

Download and install the Postman client from this Then download the JSON file needed:

Launch the client and import Oz API Lite collection for Postman by clicking the Import button:

Click files, locate the JSON needed, and hit Open to add it:

The collection will be imported and will appear in the Postman interface:

Changelog

API Lite (FaceVer) changes

1.2.3 – Nov., 2024

Fixed the bug with the time_created and folder_id parameters of the Detect method that sometimes might have been generated incorrectly.
Security updates.

1.2.2 – Oct. 17, 2024

Updated models.

The file size for the detect Liveness method is now capped at 15 MB, with a maximum of 10 files per request.
Updated the gesture list for best_shot analysis: it now supports head turns (left and right), tilts (up and down), smiling, and blinking.

Introduced the new that can process videos and archives as well.

Added the .

API Lite now accepts base64.

Improved the biometric model.
Added the 1:N mode.

Added the CORS policy.
Published the documentation.

Improved error messages – made them more detailed.
Simplified the Liveness/Detect methods.

Reworked and improved the core.
Added anti-spoofing algorithms.

Added the extract_and_compare method.

SDK

Oz Mobile SDK (iOS, Android, Flutter)

Oz Mobile SDK stands for the Software Developer’s Kit of the Oz Forensics Liveness and Face Biometric System, providing seamless integration with customers’ mobile apps for login and biometric identification.

Android iOS

Currently, both Android and iOS SDK work in the portrait mode.

Flutter

Android

To start using Oz Android SDK, follow the steps below.

Embed Oz Android SDK into your project as described .
Get a trial license for SDK on our or a production license by . We'll need your application id. Add the license to your project as described .

Master License for Android

Master license is the offline license that allows using Mobile SDKs with any bundle_id, unlike the regular licenses. To get a master license, create a pair of keys as shown below. Email us the public key, and we will email you the master license shortly after that. Your application needs to sign its bundle_id with the private key, and the Mobile SDK checks the signature using the public key from the master license. Master licenses are time-limited.

Generating Keys

This section describes the process of creating your private and public keys.

Creating a Private Key

To create a private key, run the commands below one by one.

openssl genpkey -algorithm RSA -outform DER -out privateKey.der -pkeyopt rsa_keygen_bits:2048
# for MacOS
base64 -i privateKey.der -o privateKey.txt
# for Linux 
base64 -w 0 privateKey.der > privateKey.txt

You will get these files:

privateKey.der is a private .der key;
privateKey.txt is privateKey.der encoded by base64. This key containing will be used as the host app bundle_id signature.

The OpenSSL command specification: https://www.openssl.org/docs/man1.1.1/man1/openssl-pkcs8.html

Creating a Public Key

To create a public key, run this command.

openssl rsa -pubout -in privateKey.der -out publicKey.pub

You will get the public key file: publicKey.pub. To get a license, please email us this file. We will email you the license.

SDK Integration

SDK initialization:

fun init(
    context: Context,
    licenseSources: List<LicenseSource>,
    masterLicenseSignature: String,
    statusListener: StatusListener<LicensePayload>? = null,
)

For Android 6.0 (API level 23) and older:

Add the implementation 'com.madgag.spongycastle:prov:1.58.0.0' dependency;

Prior to the SDK initializing, create a base64-encoded signature for the host app bundle_id using the private key.

Signature creation example:

private fun getMasterSignature(): String {
    Security.insertProviderAt(org.spongycastle.jce.provider.BouncyCastleProvider(), 1)

    val privateKeyBase64String = "the string copied from the privateKey.txt file"
    // with key example:
    // val privateKeyBase64String = "MIIEpAIBAAKCAQEAxnpv02nNR34uNS0yLRK1o7Za2hs4Rr0s1V1/e1JZpCaK8o5/3uGV+qiaTbKqU6x1tTrlXwE2BRzZJLLQdTfBL/rzqVLQC/n+kAmvsqtHMTUqKquSybSTY/zAxqHF3Fk59Cqisr/KQamPh2tmg3Gu61rr9gU1rOglnuqt7FioNMCMvjW7ciPv+jiawLxaPrzNiApLqHVN+xCFh6LLb4YlGRaNUXlOgnoLGWSQEsLwBZFkDJDSLTJheNVn9oa3PXg4OIlJIPlYVKzIDDcSTNKdzM6opkS5d+86yjI1aTKEH3Zs64+QoEuoDfXUxS3TOUFx8P+wfjOR5tYAT+7TRN4ocwIDAQABAoIBAATWJPV05ZCxbXTURh29D/oOToZ0FVn78CS+44Vgy1hprAcfG9SVkK8L/r6X9PiXAkNJTR+Uivly64Oua8//bNC7f8aHgxRXojFmWwayj8iOMBncFnad1N2h4hy1AnpNHlFp3I8Yh1g0RpAZOOVJFucbTxaup9Ev0wLdWyGgQ3ENmRXAyLU5iUDwUSXg59RCBFKcmsMT2GmmJt1BU4P3lL9KVyLBktqeDWR/l5K5y8pPo6K7m9NaOkynpZo+mHVoOTCtmTj5TC/MH9YRHlF15VxQgBbZXuBPxlYoQCsMDEcZlMBWNw3cNR6VBmGiwHIc/tzSHZVsbY0VRCYEbxhCBZkCgYEA+Uz0VYKnIWViQF2Na6LFuqlfljZlkOvdpU4puYTCdlfpKNT3txYzO0T00HHY9YG9k1AW78YxQwsopOXDCmCqMoRqlbn1SBe6v49pVB85fPYU2+L+lftpPlx6Wa0xcgzwOBZonHb4kvp1tWhUH+B5t27gnvRz/rx5jV2EfmWinycCgYEAy8/aklZcgoXWf93N/0EZcfzQo90LfftkKonpzEyxSzqCw7B9fHY68q/j9HoP4xgJXUKbx1Fa8Wccc0DSoXsSiQFrLhnT8pE2s1ZWvPaUqyT5iOZOW6R+giFSLPWEdwm6+BeFoPQQFHf8XH3Z2QoAepPrEPiDoGN1GSIXcCwoe9UCgYEAgoKj4uQsJJKT1ghj0bZ79xVWQigmEbE47qI1u7Zhq1yoZkTfjcykc2HNHBaNszEBks45w7qo7WU5GOJjsdobH6kst0eLvfsWO9STGoPiL6YQE3EJQHFGjmwRbUL7AK7/Tw2EJG0wApn150s/xxRYBAyasPxegTwgEj6j7xu7/78CgYEAxbkI52zG5I0o0fWBcf9ayx2j30SDcJ3gx+/xlBRW74986pGeu48LkwMWV8fO/9YCx6nl7JC9dHI+xIT/kk8OZUGuFBRUbP95nLPHBB0Hj50YRDqBjCBh5qaizSEGeGFFNIfFSKddri3U8nnZTNiKLGCx7E3bjE7QfCh5qoX8ZF0CgYAtsEPTNKWZKA23qTFI+XAg/cVZpbSjvbHDSE8QB6X8iaKJFXbmIC0LV5tQO/KT4sK8g40m2N9JWUnaryTiXClaUGU3KnSlBdkIA+I77VvMKMGSg+uf4OdfJvvcs4hZTqZRdTm3dez8rsUdiW1cX/iI/dJxF4964YIFR65wL+SoRg=="
    val sig = Signature.getInstance("SHA512WithRSA")
    val keySpec = PKCS8EncodedKeySpec(Base64.decode(privateKeyBase64String, Base64.DEFAULT))
    val keyFactory = KeyFactory.getInstance("RSA")
    sig.initSign(keyFactory.generatePrivate(keySpec))
    sig.update(packageName.toByteArray(Charsets.UTF_8))
    return Base64.encodeToString(sig.sign(), Base64.DEFAULT).replace("\n", "")
}

Pass the signature as the masterLicenseSignature parameter during the SDK initialization.

If the signature is invalid, the initialization continues as usual: the SDK checks the list of bundle_id included into the license, like it does it by default without a master license.

Adding SDK to a Project

Add the following URL to the build.gradle of the project:

Add this to the build.gradle of the module (VERSION is the version you need to implement. Please refer to ):

Please note: this is the default version.

Please note: the resulting file will be larger.

Also, regardless of the mode chosen, add:

How to Restore the Previous Design after an Update

If you want to get back to the previous (up to 6.4.2) versions' design, reset the customization settings of the capture screen and apply the parameters that are listed below.

OzLivenessSDK.config.customization = UICustomization(
    // customization parameters for the toolbar

OzLivenessSDK.INSTANCE.getConfig().setCustomization(new UICustomization(
// customization parameters for the toolbar
new ToolbarCustomization(
    R.drawable.ib_close,
    new Color.ColorHex("#FFFFFF"),
    new Color.ColorHex("#000000"),
    100, // toolbar text opacity (in %)
    ),
// customization parameters for the center hint
new CenterHintCustomization(
    70, // vertical position (in %)
),
// customization parameters for the hint animation
new HintAnimation(
    true, // hide animation
),
// customization parameters for the frame around the user face
new FaceFrameCustomization(     
    new Color.ColorHex("#EC574B"), 
    new Color.ColorHex("#00FF00"),
    6, // frame stroke width (in dp)
 ),
// customization parameters for the background outside the frame
new BackgroundCustomization(
    100 // background opacity (in %)
),
  )
);

Android Localization: Adding a Custom or Updating an Existing Language Pack

Please note: this feature has been implemented in 8.1.0.

To add or update the language pack for Oz Android SDK, please follow these instructions:

Go to the folder for the locale needed, or create a new folder. Proceed to for the details.
Create the file called strings.xml.

iOS

To start using Oz iOS SDK, follow the steps below.

Embed Oz iOS SDK into your project as described here.
Get a trial license for SDK on our website or a production license by email. We'll need your bundle id. Add the license to your project as described here.
Connect SDK to API as described . This step is optional, as this connection is required only when you need to process data on a server.
Capture videos by creating the controller as described . You'll send them for analysis afterwards.
Upload and analyze media you've taken at the previous step. The process of checking liveness and face biometry is described .
If you want to customize the look-and-feel of Oz iOS SDK, please refer to .

Minimal iOS version: 11.

Minimal Xcode version: 16.

Available languages: EN, ES, HY, KK, KY, TR, PT-BR.

A sample app source code using the Oz Liveness SDK is located in the GitLab repository:

Follow the link below to see a list of SDK methods and properties:

Download the demo app latest build .

Getting a License for iOS SDK

License

You can generate the trial license here or contact us by email to get a productive license. To create the license, your bundle id is required. After you get a license file, there are two ways to add the license to your project.

Rename this file to forensics.license and put it into the project. In this case, you don't need to set the path to the license.
During the runtime: when initializing SDK, use the following method.

OZSDK(licenseSources: [.licenseFileName(“forensics.license”)]) { licenseData, error in
      if let error = error {
        print(error)
      }
    }

or

LicenseSource a source of license, and LicenseData is the information about your license. Please note: this method checks whether you have an active license or not and if yes, this license won't be replaced with a new one. To force the license replacement, use the setLicense method.

In case of any license errors, the system will use your error handling code as shown above. Otherwise, the system will return information about license. To check the license data manually, use OZSDK.licenseData.

Error message

What to Do

Adding SDK to a Client’s Mobile App

CocoaPods

To integrate OZLivenessSDK into an Xcode project via the CocoaPods dependency manager, add the following code to Podfile:

pod 'OZLivenessSDK', :git => 'https://gitlab.com/oz-forensics/oz-liveness-ios', :tag => 'VERSION'

Version is optional as, by default, the newest version is integrated. However, if necessary, you can find the older version number in Changelog.

Since 8.1.0, you can also use a simpler code:

// for the latest version
pod ‘OZLivenessSDK’
// OR, for the specific version
// pod ‘OZLivenessSDK’, ‘8.22.0’

By default, the full version is being installed. It contains both server-based and on-device analysis modes. To install the server-based version only, use the following code:

pod 'OZLivenessSDK/Core', :git => 'https://gitlab.com/oz-forensics/oz-liveness-ios.git',  :tag => 'VERSION'

For 8.1.0 and higher:

pod ‘OZLivenessSDK/Core’
// OR
// pod ‘OZLivenessSDK/Core’, ‘8.22.0’

SPM

Please note: installation via SPM is available for versions 8.7.0 and above.

Add the following package dependencies via SPM: (if you need a guide on adding the package dependencies, please refer to the ). OzLivenessSDK is mandatory. If you don't need the on-device analyses, skip the OzLivenessSDKOnDevice file.

You can also add the necessary frameworks to your project manually.

Download the SDK files from and add them to your project.

OZLivenessSDK.xcframework,
OZLivenessSDKResources.bundle,
OZLivenessSDKOnDeviceResources.bundle (if you don't need the on-device analyses, skip this file).

Download the TensorFlow framework 2.11 from .
Make sure that:

both xcframework are in Target-Build Phases -> Link Binary With Libraries and Target-General -> Frameworks, Libraries, and Embedded Context;
the bundle file(s) are in Target-Build Phases -> Copy Bundle Resources.

Connecting SDK to API

To connect SDK to Oz API, specify the API URL and access token as shown below.

OZSDK.setApiConnection(Connection.fromServiceToken(host: "https://sandbox.ohio.ozforensics.com", token: token)) { (token, error) in
}

Please note: in your host application, it is recommended that you set the API address on the screen that precedes the liveness check. Setting the API URL initiates a service call to the API, which may cause excessive server load when being done at the application initialization or startup.

Alternatively, you can use the login and password provided by your Oz Forensics account manager:

OZSDK.setApiConnection(Connection.fromCredentials(host: “https://sandbox.ohio.ozforensics.com”, login: login, password: p)) { (token, error) in
    // Your code to handle error or token
}

By default, logs are saved along with the analyses' data. If you need to keep the logs distinct from the analysis data, set up the separate connection for telemetry as shown below:

Capturing Videos

OzCapsula (SDK v8.22 and newer)

Please note: all required data (other than the video) must be packaged into the container before starting the Liveness screen.

Create a controller that will capture videos as follows:

getSessionToken() { sessionToken in
            DispatchQueue.main.async {
                do {
                    let action:OZVerificationMovement = .selfie
                    let mediaRequest = MediaRequest.action(action)
                    let profile = AnalysisProfile(mediaList: [mediaRequest],
                                                  type: .quality,
                                                  params: [:] )
                    let request = CaptureRequest(analysisProfileList: [profile], cameraPosition: .front)
                    let ozLivenessVC = try OZSDK.createMediaCaptureScreen(self, request, sessionToken: sessionToken)
                    self.present(ozLivenessVC, animated: true)
                } catch let error {
                    print(error.localizedDescription)
                }
            }
        }

The delegate object must implement the OZLivenessDelegate protocol:

extension ViewController: LivenessDelegate {
    func onResult(container: DataContainer) {
    }
    func onError(status: OZVerificationStatus?) {
    }
}

SDK 8.21 and older

Create a controller that will capture videos as follows:

let actions: [OZVerificationMovement] = [.selfie]
let ozLivenessVC: UIViewController = OZSDK.createVerificationVCWithDelegate(self, actions: actions)
self.present(ozLivenessVC, animated: true)

action – a list of user’s actions while capturing the video.

Once video is captured, the system calls the onOZLivenessResult method:

extension viewController: OZLivenessDelegate {
 func onError(status: OZVerificationStatus?) {
        // show error
   }
 }
 func onOZLivenessResult(results: [OZMedia]) {
   // proceed to the checks step
 }
}

The method returns the results of video capturing: the [] objects. The system uses these objects to perform checks.

If a user closes the capturing screen manually, the failedBecauseUserCancelled error appears.

How to Restore the Previous Design after an Update

If you want to get back to the previous (up to 6.4.2) versions' design, reset the customization settings of the capture screen and apply the parameters that are listed below.

// customization parameters for the toolbar
let toolbarCustomization = ToolbarCustomization(
   closeButtonColor: .white,
   backgroundColor: .black)

// customization parameters for the center hint
let centerHintCustomization = CenterHintCustomization(
   verticalPosition: 70)
   
// customization parameters for the center hint animation
let hintAnimationCustomization = HintAnimationCustomization(
    hideAnimation: true)

// customization parameters for the frame around the user face
let faceFrameCustomization = FaceFrameCustomization(
   strokeWidth: 6,
   strokeFaceAlignedColor: .green,
   strokeFaceNotAlignedColor: .red)

// customization parameters for the background outside the frame
let backgroundCustomization = BackgroundCustomization(
   backgroundColor: .clear)

OZSDK.customization = OZCustomization(toolbarCustomization: toolbarCustomization,
   centerHintCustomization: centerHintCustomization,
   hintAnimationCustomization: hintAnimationCustomization,
   faceFrameCustomization: faceFrameCustomization,
   versionCustomization: vesrionCustomization,
   backgroundCustomization: backgroundCustomization)

iOS Localization: Adding a Custom or Updating an Existing Language Pack

Please note: this feature has been implemented in 8.1.0.

To add or update the language pack for Oz iOS SDK, use the set(languageBundle: Bundle) method. It shows the SDK that you are going to use the non-standard bundle. In OzLocalizationCode, use the custom language (optional).

If you don’t set the custom language and bundle, the SDK uses the pre-installed languages only.

Changelog

iOS SDK changes

10.0.0 – June 03, 2026

Breaking changes: for the OzCapsula flow, this SDK version requires API 6.6.0.1 or newer.

Updated internal dependencies.
Enhanced security.

9.3.0 – May 22, 2026

The files passed via UserMedia in MediaRequest (OzCapsula) are now named using a UUID v4 identifier with the original file extension. The original file name can still be transmitted via the mediaMeta field.
Telemetry observer callbacks (EventObserver.update() and EventObserver.onDetected()) are now dispatched on a background thread.
Updated the SDK to comply with Apple Required Reasons API.
The unbalanced dispatch_group_leave() crash on session timeout in view controller no longer occurs.
Removed the OZ_ prefix from cases of the ContainerType.
We now send the One Shot gesture media as ZIP instead of JPEG.
Enhanced security.

9.2.0 – Apr. 23, 2026

Added the new addAnalysisProfile method. It allows appending an additional AnalysisProfile (e.g., a reference photo) to an existing OzCapsula container generated during capture, forming a multi-container package for biometric or comprehensive analyses. The session token and the existing OzCapsula instance are read from device memory automatically; no additional parameters are needed. Warning: requires API 6.6.1 and above.
The Scan gesture has been made easier to pass: resolved the issue with conflicting hints.
Updated sample to cover the case of biometric verification using OzCapsula.
Resolved the issue with SQLCipher integration conflict.

9.1.0 – Mar. 17, 2026

Added support for optimized data transmission when using container.

9.0.0 – Feb. 17, 2026

You can now customize the logo position (if allowed by license).
The Scan gesture is now voiced properly.

8.23.0 – Feb. 06, 2026

Updated code sample in align with OzCapsula functionality.
Long antiscam messages are now displayed properly.
SDK no longer crashes when Liveness screen is called several times in a row with short intervals.
Resolved the issue with container errors not being returned.
Updated dependencies.

8.22.0 – Dec. 09, 2025

Implemented a new proprietary data format: OzCapsula Data Container.
Resolved the issue with SDK not returning the license-related callbacks.
Enhanced security.

8.21.0 – Nov. 21, 2025

Resolved the issue with SDK sometimes not responding to user actions on some devices.
Updated SDK to support the upcoming security features.

8.20.0 – Oct. 17, 2025

Fixed the bug with crashes that might happen during the Biometry analysis after taking a reference photo using camera.
Enhanced security.

8.19.0 – Sept. 23, 2025

The Scan gesture animation now works properly.
Fixed the bug where SDK didn’t call completion during initialization in debug mode.
Enhanced security.

8.18.2 – Aug. 22, 2025

Addressed an SDK crash that occasionally happened when invoking the license.

8.18.1 – Aug. 06, 2025

We highly recommend updating to this version.

Resolved the issue with integration via Swift UI.
SDK no longer crashes on smartphones that are running low on storage.
Security and telemetry updates.

8.17.0 – June 12, 2025

Security updates.

8.16.2 – Apr. 22, 2025

Xcode updated to version 16 to comply with Apple requirements.

8.16.1 – Apr. 09, 2025

Security updates.

8.16.0 – Mar. 11, 2025

Updated the authorization logic.
Improved voiceover.
SDK now compresses videos if their size exceeds 10 MB.
Head movement gestures are now handled properly.
Security updates.

8.15.0 – Dec. 30, 2024

Changed the wording for the head_down gesture: the new wording is “tilt down”.
Added proper focus order for VoiceOver when the antiscam hint is enabled.
Added the public setting extract_action_shot in the Demo Application.
Bug fixes.
Security updates.

8.14.0 – Dec. 3, 2024

Accessibility updates according to WCAG requirements: the SDK hints and UI controls can be voiced.
Improved user experience with head movement gestures.
Minor bug fixes and telemetry updates.

8.13.0 – Nov. 11, 2024

The screen brightness no longer changes when the rear camera is used.
Fixed the video recording issues on some smartphone models.
Security and telemetry updates.

8.12.2 – Oct. 24, 2024

Internal SDK improvements.

8.12.1 – Sept. 30, 2024

Added Xcode 16 support.
Security and telemetry updates.

8.11.0 – Sept. 10, 2024

Security updates.

8.10.1 – Aug. 23, 2024

Bug fixes.

8.10.0 – Aug. 1, 2024

SDK now requires Xcode 15 and newer.
Security updates.
Bug fixes.

8.9.1 – July 16, 2024

Internal SDK improvements.

8.8.3 – July 11, 2024

Internal SDK improvements.

8.8.2 – June 25, 2024

Bug fixes.

8.8.1 – June 25, 2024

Logging updates.

8.8.0 – June 18, 2024

Security updates.

8.7.0 – May 10, 2024

You can now install iOS SDK via Swift Package Manager.
The sample is now available on SwiftUI. Please find it here.
Added a description for the error that occurs when providing an empty string as an ID in the addFolderID method.
Bug fixes.

8.6.0 – Apr. 10, 2024

The messages displayed by the SDK after uploading media have been synchronized with Android.
The bug causing analysis delays that might have occurred for the One Shot gesture has been fixed.

8.5.0 – Mar. 06, 2024

The length of the Selfie gesture is now configurable (affects the video file size).
You can set your own logo instead of Oz logo if your license allows it.
Removed the pause after the Scan gesture.
The code in is now up-to-date.
Security and logging updates.

8.4.2 – Jan. 24, 2024

Security updates.

8.4.0 – Jan. 09, 2024

Changed the default behavior in case a localization key is missing: now the English string value is displayed instead of a key.
Fixed some bugs.

8.3.3 – Dec. 11, 2023

Internal licensing improvements.

8.3.0 – Nov. 17, 2023

Implemented the possibility of using a master license that works with any bundle_id.
Fixed the bug with background color flashing.

8.2.1 – Nov. 11, 2023

Bug fixes.

8.2.0 – Oct. 30, 2023

The Analysis structure now contains the sizeReductionStrategy field. This field defines what type of media is being sent to the server in case of the hybrid analysis once the on-device analysis is finished successfully.
The messages for the errors that are retrieved from API are now detailed.
The toFrameGradientColor option in hintAnimationCustomization is now deprecated, please use the hintGradientColor option instead.
Got back the iOS 11 support.

8.1.1 – Oct. 09, 2023

If multiple analyses are applied to the folder simultaneously, the system sends them as a group. It means that the “worst” of the results will be taken as resolution, not the latest. Please refer to this article for details.
For the Liveness analysis, the system now treats the highest score as a quantitative result. The Liveness analysis output is described here.

8.1.0 – Sept. 07, 2023

Updated the Liveness on-device model.
Added the Portuguese (Brazilian) locale.
You can now add a custom or update an existing language pack. The instructions can be found here.
If a media hasn't been uploaded correctly, the system now repeats the upload.
Added a new method to retrieve the telemetry (logging) identifier: getEventSessionId.
The setPermanentAccessToken, configure and login methods are now deprecated. Please use the setApiConnection method instead.
The setLicense(from path:String) method is now deprecated. Please use the setLicense(licenseSource: LicenseSource) method instead.
Fixed some bugs and improved the SDK work.

8.0.2 – Aug. 15, 2023

Fixed some bugs and improved the SDK algorithms.

8.0.0 – June 27, 2023

Added the new analysis mode – hybrid (Liveness only). If the score received from an on-device analysis is too high, the system initiates a server-based analysis as an additional check.
Improved the on-device models.
Updated the run method.
Added new structures: RequestStatus (analysis state), ResultMedia (analysis result for a single media) and RequestResult (consolidated analysis result for all media).
The updated AnalysisResult structure should be now used instead of OzAnalysisResult.
For the OZMedia object, you can now specify additional tags that are not included into our tags list.
The Selfie video length is now about 0.7 sec, the file size and upload time are reduced.
The hint text width can now exceed the frame width (when using the main camera).
The methods below are no longer supported:

Removed method

Replacement

analyse

AnalysisRequest.run

addToFolder

uploadMedia

documentAnalyse

AnalysisRequest.run

7.3.0 – June 06, 2023

Added the center hint background customization.
Added new face frame forms (Circle, Square).
Added the antiscam widget and its customization. This feature allows you to alert your customers that the video recording is being conducted, for instance, for loan application purposes. The purpose of this is to safeguard against scammers who may attempt to deceive an individual into approving a fraudulent transaction.
Synchronized the default customization values with Android.
Added the Spanish locale.
iOS 11 is no longer supported, the minimal required version is 12.

7.2.1 – May 24, 2023

Fixed the issue with the server-based One shot analysis.

7.2.0 – May 18, 2023

Improved the SDK algorithms.

7.1.6 – May 04, 2023

Fixed error handling when uploading a file to API. From this version, an error will be raised to a host application in case of an error during file upload.

7.1.5 – Apr. 03, 2023

Improved the on-device Liveness.

7.1.4 – Mar. 24, 2023

Fixed the animation for sunglasses/mask.
Fixed the bug with the .document analysis.
Updated the descriptions of customization methods and structures.

7.1.2 – Feb. 21, 2023

Updated the TensorFlow version to 2.11.
Fixed several bugs, including the Biometry check failures on some phone models.

7.1.1 – Feb. 06, 2023

Added customization for the hint animation.

7.1.0 – Jan. 20, 2023

Integrated a new model.
Added the uploadMedia method to AnalysisRequest. The addMedia method is now deprecated.
Fixed the combo analysis error.
Added a button to reset the SDK theme and language settings.
Fixed some bugs and localization issues.
Extended the network request timeout to 90 sec.
Added a setting for the animation icon size.

7.0.0 – Dec. 08, 2022

Implemented a range of UI customization options and switched to the new design. To restore the previous settings, please refer to this article.

6.7.0

The run method now works similar to the one in Android SDK and returns an array of analysis' results.

6.4.0

Synchronized the version numbers with Android SDK.
Added a new field to the Analysis structure. The params field is for any additional parameters, for instance, if you need to set extracting the best shot on server to true. The best shot algorithm chooses the most high-quality frame from a video.
Fixed some localization issues.
Changed the Combo gesture.
Now you can launch the Liveness check to analyze images taken with another SDK.

3.0.1

The Zoom in and Zoom out gestures are no longer supported.

3.0.0

Added a new simplified analysis structure – AnalysisRequest.

2.3.0

Added methods of on-device analysis: runOnDeviceLivenessAnalysis and runOnDeviceBiometryAnalysis.
You can choose the installation version. Standard installation gives access to full functionality. The core version (OzLivenessSDK/Core) installs SDK without the on-device functionality.
Added a method to upload data to server and start analyzing it immediately: uploadAndAnalyse.
Improved the licensing process, now you can add a license when initializing SDK: OZSDK(licenseSources: [LicenseSource], completion: @escaping ((LicenseData?, LicenseError?) -> Void)), where LicenseSource is a path to physical location of your license, LicenseData contains the license information.
Added the setLicense method to force license adding.

2.2.3

Added the Turkish locale.

2.2.1

Added the Kyrgyz locale.
Added Completion Handler for analysis results.
Added Error User Info to telemetry to show detailed info in case of an analysis error.

2.2.0

Added local on-device analysis.
Added oval and rectangular frames.
Added Xcode 12.5.1+ support.

2.1.4

Added SDK configuration with licenses.

2.1.3

Added the One Shot gesture.
Improved OZVerificationResult: added bestShotURL which contains the best shot image and preferredMediaURL which contains an URL to the best quality video.
When performing a local check, you can now choose a main or back camera.

2.1.2

Authorization sessions extend automatically.
Updated authorization interfaces.

2.1.1

Added the Kazakh locale.
Added license error texts.

2.1.0

You can cancel network requests.
You can specify Bundle for license.
Added analysis parameterization documentAnalyse.
Fixed building errors (Xcode 12.4 / Cocoapods 1.10.1).

2.0.0

Added license support.
Added Xcode 12 support instead of 11.
Fixed the documentAnalyse error where you had to fill analyseStates to launch the analysis.
Fixed logging.

Flutter

In this section, we explain how to use Oz Flutter SDK for iOS and Android.

Before you start, it is recommended that you install:

Flutter 3.0.0 or newer;
Android SDK 21 or newer;
dart 2.18.6 or newer;
iOS platform 13 or newer;
Xcode.

Please find the Flutter repository .

Web Plugin (Web SDK Frontend part)

Web Plugin is a plugin called by your web application. It works in a browser context. The Web Plugin communicates with Web Adapter, which, in turn, communicates with Oz API.

Please find a sample for Oz Liveness Web SDK . To make it work, replace <web-adapter-url> with the Web Adapter URL you've received from us.

For the samples below, replace https://web-sdk.sandbox.ohio.ozforensics.com in index.html.

sample

Adding the Plugin to Your Web Page

A dedicated Web Adapter in our cloud or the adapter deployed on-premise. The adapter's URL is required for adding the plugin.

To embed the plugin in your page, add a reference to the primary script of the plugin (plugin_liveness.php) that you received from Oz Forensics to the HTML code of the page. web-sdk-root-url is the Web Adapter link you've received from us.

Description of the on_complete Callback

This callback is called after the check is completed. It retrieves the analysis result (unavailable for the capture mode). The result content depends on the Web Adapter result_mode .

When result_mode is safe, the on_complete callback contains the state of the analysis only:

For the status value, the callback contains the state of the analysis, and for each of the analysis types, the name of the type, state, and resolution.

Description of the on_result Callback

This callback is called periodically during the analysis’ processing. It retrieves an intermediate result (unavailable for the capture mode). The result content depends on the Web Adapter result_mode configuration parameter.

Keep in mind that it is more secure to get your back end responsible for the decision logic. You can find more details including code samples .

Safe

When result_mode is safe, the on_result callback contains the state of the analysis only:

{
 "state": "finished"
}

Please note: the options listed below are for testing purposes only. If you require more information than what is available in the Safe mode, please follow .

Status

For the status value, the callback contains the state of the analysis, and for each of the analysis types, the name of the type, state, and resolution.

The folder value is almost similar to the status value, with the only difference: the folder_id is added.

In this case, you receive the detailed response possibly containing sensitive data. This mode is deprecated; for security reasons, we recommend using the safe mode.

Description of the on_error Callback

This callback is called when the system encounters any error. It contains the error details and telemetry ID that you can use for further investigation.

Closing or Hiding the Plugin

Closing the plugin

To force the closing of the plugin window, use the close() method. All requests to server and callback functions (except on_close) within the current session will be aborted.

Example:

var session_id = 123;

OzLiveness.open({
  // We transfer the arbitrary meta data, by which we can later identify the session in Oz API
  meta: {
    session_id: session_id 
  },
  // After sending the data, forcibly close the plugin window and independently request the result
  on_submit: function() {
    OzLiveness.close();
    my_result_function(session_id);
  }
});

Hiding the plugin window without cancelling the callbacks

To hide the plugin window without cancelling the requests for analysis results and user callback functions, call the hide() method. Use this method, for instance, if you want to display your own upload indicator after submitting data.

An example of usage:

Localization: Adding a Custom Language Pack

The add_lang(lang_id, lang_obj) method allows adding a new or customized language pack.

Parameters:

lang_id: a string value that can be subsequently used as lang parameter for the open() method;

Customization Options for Older Versions (before 1.0.1)

To set your own look-and-feel options, use the style section in the Ozliveness.open method. Here is what you can change:

faceFrame – the color of the frame around a face:

Security Recommendations

Even though the analysis result is available to the host application via Web Plugin callbacks, it is recommended that the application back end receives it directly from Oz API. All decisions of the further process flow should be made on the back end as well. This eliminates any possibility of malicious manipulation with analysis results within the browser context.

To find your folder from the back end, you can follow these steps:

On the front end, add your unique identifier to the folder metadata.

You can add your own key-value pairs to attach user document numbers, phone numbers, or any other textual information. However, ensure that tracking personally identifiable information (PII) complies with relevant regulatory requirements.

Browser Compatibility

Please note: for the plugin to work, your browser version should support JavaScript ES6 and be the one as follows or newer.

Browser

Version

Google Chrome (and other browsers based on the Chromium engine)

Mozilla Firefox

*Web SDK doesn't work in Internet Explorer compatibility mode due to lack of important functions.

No-Server Licensing

This article covers a rare case when you use Web Plugin only. If you have a standard installation with Web Adapter, do not use these licensing parameters in OzLiveness.open() – your server license will be managed automatically. Passing a license via the frontend will override the server license and may cause unexpected expiration issues.

To generate the license, we need the domain name of the website where you are going to use Oz Forensics Web SDK, for instance, your-website.com. You can also define subdomains.

To find the origin, in the developer mode, run window.origin on the page you are going to embed Oz Web SDK in. At localhost / 127.0.0.1, license can work without this information.

Set the license as shown below:

With license data:

OzLiveness.open({
    license: {
        'payload_b64': 'some_payload',
        'signature': 'some_data',
        'enc_public_key': 'some_key'
    },
    ...,
})

With license path:

Check whether the license is updated properly.

Example

Proceed to your website origin and launch Liveness -> Simple selfie.

Once the license is added, the system will check its validity on launch.

Changelog

iOS SDK changes

10.0.0 – June 03, 2026

Breaking changes: for the OzCapsula flow, this SDK version requires API 6.6.0.1 or newer.

Updated internal dependencies.
Enhanced security.

9.3.0 – May 22, 2026

The files passed via UserMedia in MediaRequest (OzCapsula) are now named using a UUID v4 identifier with the original file extension. The original file name can still be transmitted via the mediaMeta field.
Telemetry observer callbacks (EventObserver.update() and EventObserver.onDetected()) are now dispatched on a background thread.
Updated the SDK to comply with Apple Required Reasons API.
The unbalanced dispatch_group_leave() crash on session timeout in view controller no longer occurs.
Removed the OZ_ prefix from cases of the ContainerType.
We now send the One Shot gesture media as ZIP instead of JPEG.
Enhanced security.

9.2.0 – Apr. 23, 2026

Added the new addAnalysisProfile method. It allows appending an additional AnalysisProfile (e.g., a reference photo) to an existing OzCapsula container generated during capture, forming a multi-container package for biometric or comprehensive analyses. The session token and the existing OzCapsula instance are read from device memory automatically; no additional parameters are needed. Warning: requires API 6.6.1 and above.
The Scan gesture has been made easier to pass: resolved the issue with conflicting hints.
Updated sample to cover the case of biometric verification using OzCapsula.
Resolved the issue with SQLCipher integration conflict.

9.1.0 – Mar. 17, 2026

Added support for optimized data transmission when using container.

9.0.0 – Feb. 17, 2026

You can now customize the logo position (if allowed by license).
The Scan gesture is now voiced properly.

8.23.0 – Feb. 06, 2026

Updated code sample in align with OzCapsula functionality.
Long antiscam messages are now displayed properly.
SDK no longer crashes when Liveness screen is called several times in a row with short intervals.
Resolved the issue with container errors not being returned.
Updated dependencies.

8.22.0 – Dec. 09, 2025

Implemented a new proprietary data format: OzCapsula Data Container.
Resolved the issue with SDK not returning the license-related callbacks.
Enhanced security.

8.21.0 – Nov. 21, 2025

Resolved the issue with SDK sometimes not responding to user actions on some devices.
Updated SDK to support the upcoming security features.

8.20.0 – Oct. 17, 2025

Fixed the bug with crashes that might happen during the Biometry analysis after taking a reference photo using camera.
Enhanced security.

8.19.0 – Sept. 23, 2025

The Scan gesture animation now works properly.
Fixed the bug where SDK didn’t call completion during initialization in debug mode.
Enhanced security.

8.18.2 – Aug. 22, 2025

Addressed an SDK crash that occasionally happened when invoking the license.

8.18.1 – Aug. 06, 2025

We highly recommend updating to this version.

Resolved the issue with integration via Swift UI.
SDK no longer crashes on smartphones that are running low on storage.
Security and telemetry updates.

8.17.0 – June 12, 2025

Security updates.

8.16.2 – Apr. 22, 2025

Xcode updated to version 16 to comply with Apple requirements.

8.16.1 – Apr. 09, 2025

Security updates.

8.16.0 – Mar. 11, 2025

Updated the authorization logic.
Improved voiceover.
SDK now compresses videos if their size exceeds 10 MB.
Head movement gestures are now handled properly.
Security updates.

8.15.0 – Dec. 30, 2024

Changed the wording for the head_down gesture: the new wording is “tilt down”.
Added proper focus order for VoiceOver when the antiscam hint is enabled.
Added the public setting extract_action_shot in the Demo Application.
Bug fixes.
Security updates.

8.14.0 – Dec. 3, 2024

Accessibility updates according to WCAG requirements: the SDK hints and UI controls can be voiced.
Improved user experience with head movement gestures.
Minor bug fixes and telemetry updates.

8.13.0 – Nov. 11, 2024

The screen brightness no longer changes when the rear camera is used.
Fixed the video recording issues on some smartphone models.
Security and telemetry updates.

8.12.2 – Oct. 24, 2024

Internal SDK improvements.

8.12.1 – Sept. 30, 2024

Added Xcode 16 support.
Security and telemetry updates.

8.11.0 – Sept. 10, 2024

Security updates.

8.10.1 – Aug. 23, 2024

Bug fixes.

8.10.0 – Aug. 1, 2024

SDK now requires Xcode 15 and newer.
Security updates.
Bug fixes.

8.9.1 – July 16, 2024

Internal SDK improvements.

8.8.3 – July 11, 2024

Internal SDK improvements.

8.8.2 – June 25, 2024

Bug fixes.

8.8.1 – June 25, 2024

Logging updates.

8.8.0 – June 18, 2024

Security updates.

8.7.0 – May 10, 2024

You can now install iOS SDK via Swift Package Manager.
The sample is now available on SwiftUI. Please find it here.
Added a description for the error that occurs when providing an empty string as an ID in the addFolderID method.
Bug fixes.

8.6.0 – Apr. 10, 2024

The messages displayed by the SDK after uploading media have been synchronized with Android.
The bug causing analysis delays that might have occurred for the One Shot gesture has been fixed.

8.5.0 – Mar. 06, 2024

The length of the Selfie gesture is now configurable (affects the video file size).
You can set your own logo instead of Oz logo if your license allows it.
Removed the pause after the Scan gesture.
The code in is now up-to-date.
Security and logging updates.

8.4.2 – Jan. 24, 2024

Security updates.

8.4.0 – Jan. 09, 2024

Changed the default behavior in case a localization key is missing: now the English string value is displayed instead of a key.
Fixed some bugs.

8.3.3 – Dec. 11, 2023

Internal licensing improvements.

8.3.0 – Nov. 17, 2023

Implemented the possibility of using a master license that works with any bundle_id.
Fixed the bug with background color flashing.

8.2.1 – Nov. 11, 2023

Bug fixes.

8.2.0 – Oct. 30, 2023

The Analysis structure now contains the sizeReductionStrategy field. This field defines what type of media is being sent to the server in case of the hybrid analysis once the on-device analysis is finished successfully.
The messages for the errors that are retrieved from API are now detailed.
The toFrameGradientColor option in hintAnimationCustomization is now deprecated, please use the hintGradientColor option instead.
Got back the iOS 11 support.

8.1.1 – Oct. 09, 2023

If multiple analyses are applied to the folder simultaneously, the system sends them as a group. It means that the “worst” of the results will be taken as resolution, not the latest. Please refer to this article for details.
For the Liveness analysis, the system now treats the highest score as a quantitative result. The Liveness analysis output is described here.

8.1.0 – Sept. 07, 2023

Updated the Liveness on-device model.
Added the Portuguese (Brazilian) locale.
You can now add a custom or update an existing language pack. The instructions can be found here.
If a media hasn't been uploaded correctly, the system now repeats the upload.
Added a new method to retrieve the telemetry (logging) identifier: getEventSessionId.
The setPermanentAccessToken, configure and login methods are now deprecated. Please use the setApiConnection method instead.
The setLicense(from path:String) method is now deprecated. Please use the setLicense(licenseSource: LicenseSource) method instead.
Fixed some bugs and improved the SDK work.

8.0.2 – Aug. 15, 2023

Fixed some bugs and improved the SDK algorithms.

8.0.0 – June 27, 2023

Added the new analysis mode – hybrid (Liveness only). If the score received from an on-device analysis is too high, the system initiates a server-based analysis as an additional check.
Improved the on-device models.
Updated the run method.
Added new structures: RequestStatus (analysis state), ResultMedia (analysis result for a single media) and RequestResult (consolidated analysis result for all media).
The updated AnalysisResult structure should be now used instead of OzAnalysisResult.
For the OZMedia object, you can now specify additional tags that are not included into our tags list.
The Selfie video length is now about 0.7 sec, the file size and upload time are reduced.
The hint text width can now exceed the frame width (when using the main camera).
The methods below are no longer supported:

Removed method

Replacement

analyse

AnalysisRequest.run

addToFolder

uploadMedia

documentAnalyse

AnalysisRequest.run

7.3.0 – June 06, 2023

Added the center hint background customization.
Added new face frame forms (Circle, Square).
Added the antiscam widget and its customization. This feature allows you to alert your customers that the video recording is being conducted, for instance, for loan application purposes. The purpose of this is to safeguard against scammers who may attempt to deceive an individual into approving a fraudulent transaction.
Synchronized the default customization values with Android.
Added the Spanish locale.
iOS 11 is no longer supported, the minimal required version is 12.

7.2.1 – May 24, 2023

Fixed the issue with the server-based One shot analysis.

7.2.0 – May 18, 2023

Improved the SDK algorithms.

7.1.6 – May 04, 2023

Fixed error handling when uploading a file to API. From this version, an error will be raised to a host application in case of an error during file upload.

7.1.5 – Apr. 03, 2023

Improved the on-device Liveness.

7.1.4 – Mar. 24, 2023

Fixed the animation for sunglasses/mask.
Fixed the bug with the .document analysis.
Updated the descriptions of customization methods and structures.

7.1.2 – Feb. 21, 2023

Updated the TensorFlow version to 2.11.
Fixed several bugs, including the Biometry check failures on some phone models.

7.1.1 – Feb. 06, 2023

Added customization for the hint animation.

7.1.0 – Jan. 20, 2023

Integrated a new model.
Added the uploadMedia method to AnalysisRequest. The addMedia method is now deprecated.
Fixed the combo analysis error.
Added a button to reset the SDK theme and language settings.
Fixed some bugs and localization issues.
Extended the network request timeout to 90 sec.
Added a setting for the animation icon size.

7.0.0 – Dec. 08, 2022

Implemented a range of UI customization options and switched to the new design. To restore the previous settings, please refer to this article.

6.7.0

The run method now works similar to the one in Android SDK and returns an array of analysis' results.

6.4.0

Synchronized the version numbers with Android SDK.
Added a new field to the Analysis structure. The params field is for any additional parameters, for instance, if you need to set extracting the best shot on server to true. The best shot algorithm chooses the most high-quality frame from a video.
Fixed some localization issues.
Changed the Combo gesture.
Now you can launch the Liveness check to analyze images taken with another SDK.

3.0.1

The Zoom in and Zoom out gestures are no longer supported.

3.0.0

Added a new simplified analysis structure – AnalysisRequest.

2.3.0

Added methods of on-device analysis: runOnDeviceLivenessAnalysis and runOnDeviceBiometryAnalysis.
You can choose the installation version. Standard installation gives access to full functionality. The core version (OzLivenessSDK/Core) installs SDK without the on-device functionality.
Added a method to upload data to server and start analyzing it immediately: uploadAndAnalyse.
Improved the licensing process, now you can add a license when initializing SDK: OZSDK(licenseSources: [LicenseSource], completion: @escaping ((LicenseData?, LicenseError?) -> Void)), where LicenseSource is a path to physical location of your license, LicenseData contains the license information.
Added the setLicense method to force license adding.

2.2.3

Added the Turkish locale.

2.2.1

Added the Kyrgyz locale.
Added Completion Handler for analysis results.
Added Error User Info to telemetry to show detailed info in case of an analysis error.

2.2.0

Added local on-device analysis.
Added oval and rectangular frames.
Added Xcode 12.5.1+ support.

2.1.4

Added SDK configuration with licenses.

2.1.3

Added the One Shot gesture.
Improved OZVerificationResult: added bestShotURL which contains the best shot image and preferredMediaURL which contains an URL to the best quality video.
When performing a local check, you can now choose a main or back camera.

2.1.2

Authorization sessions extend automatically.
Updated authorization interfaces.

2.1.1

Added the Kazakh locale.
Added license error texts.

2.1.0

You can cancel network requests.
You can specify Bundle for license.
Added analysis parameterization documentAnalyse.
Fixed building errors (Xcode 12.4 / Cocoapods 1.10.1).

2.0.0

Added license support.
Added Xcode 12 support instead of 11.
Fixed the documentAnalyse error where you had to fill analyseStates to launch the analysis.
Fixed logging.

Changelog

API changes

6.6.1 – June 09, 2026

API now can process an OzCapsula container that has other OzCapsula containers inside. This applies to the Mobile SDK integration flow only.
We now support OpenTelemetry.
You can now obtain the full-size action shot from API for the Liveness analysis. In the payload, set extract_action_shot to 1 or true. In an API response, check analyses[].results_media[].output_images[]. Action shot has original_name = ResultImageActionShot.jpeg. The default report template has been changed accordingly and is included into API image.
Optimized shotset processing.
To prevent TFSS overload, you can now manage the number of concurrent requests API sends to TFSS. Please refer to for details.
We no longer hide the best shot in base64 from response by default. The best shot can be found in analyses[].results_media[].output_images[].image_b64.
OzCapsula requests now include the analyses[] section in the response even when the request is declined with a non-null decline_reason, so integrations relying on analyses[] (e.g., using the on_complete callback in Web SDK) work properly.
expire_date in the /api/authorize/auth response is no longer affected by the timezone that is set in API.
By default, all OzCapsula-related errors now return the "Invalid request data" error message. Error codes stay unchanged.
To S3, we now save multiple engine_response.json files for a single media file: one for each analysis applied (naming: {analysis_id}_{source_media_id}_engine_response.json).
GET /api/collections/{collection_id}/persons/ no longer returns a 500 Internal Server Error for legacy image path formats; an invalid path now produces a meaningful error without a stack trace.
Resolved an AttributeError that might have occurred in case of failed JSON serialization.
Enhanced security.

Updated internal dependencies.

Updated models.
API no longer returns a 500 error when viewing analysis details or printing reports under the CLIENT role in Web UI.

Breaking changes: this version doesn’t support Celery.
Breaking changes: Renamed the oz_instant_save_artifacts_s3 config parameter to OZ_INSTANT_SAVING_ARTIFACTS_ENABLED. If you use this parameter, please rename it manually.

Breaking changes: if you use S3, set OZ_STATIC_S3_BUCKET_URL="None" to avoid breaking of the S3 connection. This is fixed in 6.5.0.
You can now add container to the existing folder using the POST api/folders/{folder_id}/media method.
Improved performance of the

Implemented a new proprietary data format: OzCapsula Data Container.
Instant API now can save static and JSON payload to S3. To enable this functionality, set oz_instant_save_artifacts_s3 to true.
Resolved the issue with occasional false rejections using videos received from Web SDK.

Updated API to support upcoming features.

Fixed bugs that could cause the GET /api/folders/ request to return incorrect results.

Updated API to support upcoming features.
Fixed bugs.

Resolved an issue with POST /api/instant/folders/ and POST /api/folders/ returning “500 Internal Server Error” when the video sent is corrupted. Now system returns “400 Bad Request”.
Updated API to support upcoming features.

Updated API 6 to support Kazakhstan regulatory requirements: added the functionality of extracting action shots from videos of a person performing gestures.
You can remove admin rights from a CLIENT ADMIN user and change their role to CLIENT via PATCH /api/users/{{user_id}}.
You can generate a service token for a user with the OPERATOR role.

Optimization and performance updates.

Analyses can now be done in parallel with each other. To enable this feature, add the OZ_ANALYSE_PARALLELED_CHECK_MEDIA_ENABLED parameter to config.py and set it to true (the default value is false).
For the instant mode, authorization can be disabled. Add the OZ_AUTHORIZE_DISABLED_STATELESS parameter to config.py

Please note: this version doesn't support the Kazakhstan regulatory requirements.

Optimized storage and database.
Implemented the which involves creating a folder and executing analyses in a single request by attaching a part of the analysis in the payload.
Implemented the without storing any data locally or in database. This mode can be used either with or without other API components.

Deprecated Endpoint or Parameter

Replacement

Improved the resource efficiency of server-based biometry analysis.

API can now extract action shots from videos of a person performing gestures. This is done to comply with the new Kazakhstan regulatory requirements for biometric identification.
Created a new report template that also complies with the requirements mentioned above.
If action shots are enabled, the thumbnails for the report are generated from them.

Updated the Postman collection. Please see the new collection and at .
Added the new method to check the timezone settings: GET {{host}}/api/config
Added parameters to the GET {{host}}/api/event_sessions method:

Security updates.

Face Identification 1:N is now live, significantly increasing the data processing capacity of the Oz API to find matches. Even huge face databases (containing millions of photos and more) are no longer an issue.
The Liveness (QUALITY) analysis now ignores photos tagged with photo_id, photo_id_front, or photo_id_back, preventing these photos from causing the tag-related analysis error.

Security updates.

You can now apply the Liveness (QUALITY) analysis to a single image.
Fixed the bug where the Liveness analysis could finish with the SUCCESS result with no media uploaded.
The default value for the extract_best_shot parameter is now True.

Security updates.

Set the autorotation of logs.
Added the CLI command for user deletion.
You can now switch off the video preview generation.

For the sliced video, the system now deletes the unnecessary frames.
Added new methods: GET and POST at media/<media_id>/snapshot/.
Replaced the default report template.

The Photo Expert and KYC modules are now removed.
The endpoint for the user password change is now POST users/user_id/change-password instead of PATCH.

Provided log for the Celery app.

Added filters to the Folder [LIST] request parameters: analyse.time_created, analyse.results_data for the Documents analysis, results_data for the Biometry analysis, results_media_results_data for the QUALITY analysis. To enable filters, set the with_results_media_filter query parameter to True.

Added a new attribute for users – is_active (default True). If is_active == False, any user operation is blocked.
Added a new exception code (1401 with status code 401) for the actions of the blocked users.

Added shots sets preview.
You can now save a shots set archive to a disk (with the original_local_path, original_url attributes).
A new original_info attribute is added to store md5, size, and mime-type of a shots set

Added health check at GET api/healthcheck.

Fixed the shots set thumbnail URL.

Now, the first frame of shots set becomes this shots set's thumbnail URL.

Modified the retry policy – the default max count of analysis attempts is increased to 3 and jitter configuration introduced.
Changed the callback algorithm.
Refactored and documented the command line tools.

Changed the delete personal information endpoint and method from delete_pi to /pi and from POST to DELETE, respectively.

Improved the delete personal information algorithm.
It is now forbidden to add media to cleaned folders.

Changed the authorize/restore endpoint name from auth to auth_restore.
Added a new tag – video_selfie_oneshot.

Fixed a bug with no error while trying to synchronize empty collections.
If persons are uploaded, the analyse collection TFSS request is sent.

Added the fields_to_check parameter to document analysis (by default, all fields are checked).
Added the double_page_spread parameter to document analysis (True by default).

Fixed collection synchronization.

Authorization token can be now refreshed by expire_token.

Added support for application/x-gzip.

Renamed shots_set.images to shots_set.frames.

Added user sessions API.
Users can now change a folder owner (limited by permissions).
Changed dependencies rules.

Move oz_collection_binding (collection synchronization functional) to oz_core.

Simplified the shots sets functionality. One archive keeps one shot set.

Improved the document sides recognition for the docker version.

Moved the orientation tag check to liveness at quality analysis.

Added a default report template for Admin and Operator.

Updated the biometric model.

A new ShotsSet object is not created if there are no photos for it.
Updated the data exchange format for the documents' recognition module.

You can’t delete a Collection if there are associated analyses with Collection Persons.

Added time marks to analysis: time_task_send_to_broker, time_task_received, time_task_finished.

Added a new authorization engine. You can now connect with Active Directory by LDAP (settings configuration required).

A new type of media in Folders – "shots_set".
You can’t delete a CollectionPerson if there are analyses associated with it.

Renamed the folder field resolution_suggest to operator_status.
Added a folder text field operator_comment.

Fixed a deletion error: when report author is deleted, their reports get deleted as well.

Client can now view only their own profile.

Client Operator can now edit only their profile.
Client can't delete own folders, media, reports, or analyses anymore.
Client Service can now create Collection Person and read reports within their company.

Client, Client Admin, Client Operator have read access to users profiles only in their company.
A/B testing is now available.
Added support for expiration date header.

Added a new role of Client Operator (like Client Admin without permissions for company and account management).
Client Admin and Client Operator can change the analysis status.
Only Admin and Client Admin (for their company) can create, update and delete operations for Collection and CollectionPerson models from now on.

Changelog

Android SDK changes

10.0.0 – June 05, 2026

Breaking changes: for the OzCapsula flow, this SDK version requires API 6.6.0.1 or newer.

Updated internal dependencies.
Enhanced security.

9.3.0 – May 14, 2026

The files passed via UserMedia in MediaRequest (OzCapsula) are now named using a UUID v4 identifier with the original file extension. The original file name can still be transmitted via the mediaMeta field.
Telemetry observer callbacks (EventObserver.update() and EventObserver.onDetected()) are now dispatched on a background thread.
Removed the OzForensics namespace reference from the Android manifest.
Rebuilt TensorFlow Lite with 16 KB page alignment to comply with Google's updated requirements; the RELRO alignment warning at build/publish no longer occurs.
A rare codec-related crash during liveness recording no longer appears.
The sample app now covers the scenario of biometric authentication using OzCapsula.
Videos captured in the Hybrid analysis flow are now compressed correctly.

Added the new addAnalysisProfile method. It allows appending an additional AnalysisProfile (e.g., a reference photo) to an existing OzCapsula container generated during capture, forming a multi-container package for biometric or comprehensive analyses. The session token and the existing OzCapsula instance are read from device memory automatically; no additional parameters are needed. Warning: requires API 6.6.1 and above.
The Scan gesture has been made easier to pass: resolved the issue with conflicting hints.
The Action rules unavailable error

Selfie gesture recording now stops strictly at the configured timeout to normalize video duration across devices.
If user can’t take a video, the new timeout counter for video capture now starts after the error timeout dialog is shown.

Updated internal dependencies.

Fixed the bug with “Unknown Error” being returned even in case of successful video capture.
Resolved the issue with occasional crashes caused by improper preview scaling on some devices.

You can now (if allowed by license).
In case of lost internet connection during license checking, SDK now returns the proper error.
Updated code sample to align with OzCapsula functionality.

Fixed the bug with green videos appearing on some devices.
Resolved the issue with occasional SDK crashes caused by restrictions of device camera.
Fixed minor bugs.

Fixed the bug with SDK crashes caused by the “Invalid to call at Released state” and “Pending dequeue output buffer request cancelled” errors.
Fixed the bug with "java.util.concurrent.TimeoutException" causing crashes.
Android SDK now passes orientation and media type tags along with the action one.

Fixed a minor bug.

Implemented a new proprietary data format: OzCapsula Data Container.
Fixed occasional SDK crashes in specific cases and / or on specific devices.
Enhanced security.

Improved SDK performance for some devices.
Updated SDK to support the upcoming security features.

Fixed the bug with green videos on some smartphone models.
Resolved the issue with mediaId appearing null.
Enhanced security.

Resolved an issue with warning that could appear when running Fragment.
SDK no longer crashes when calling copyPlane.
When you choose to send compressed videos for a hybrid analysis, SDK no longer saves original media as well as compressed.

To support memory page size of 16 KB, switched TensorFlow to LiteRT.

Fixed the bug that caused video duration and file size to increase.

Added support for Google Dynamic Feature Delivery.
Resolved an issue that might have caused crashes when taping the close button on the Liveness screen.
Fixed a bug where the SDK would crash with "CameraDevice was already closed" exception.

Resolved the issue with OkHttp compatibility.
Fixed the bug with Fragment missing context.

Resolved a camera access issue affecting some mobile device models.

Security updates.

Security updates.

Security updates.

Resolved the issue with possible SDK crashes when closing the Liveness screen.

Security updates.

Updated the authorization logic.
Improved voiceover.
Fixed the issue with SDK lags and the non-responding error that users might have encountered on some devices after completing the video recording.
Resolved the issue with SDK crashes on some devices that might have occurred because of trying to access non-initialized or closed resources.

Security updates.

You can now disable video validation that has been implemented to avoid recording of extremely short videos (3 frames and less): switch the option off using .
Fixed the bug with green videos on some smartphone models.
Security updates.

Fixed bugs that could have caused crashes on some phone models.

Changed the wording for the head_down gesture: the new wording is “tilt down”.
Added proper focus order for TalkBack when the antiscam hint is enabled.
Added the public setting extract_action_shot in the Demo Application.

Fixed the bug when the recorded videos might appear green.
Resolved codec issues on some smartphone models.

Accessibility updates according to WCAG requirements: the SDK hints and UI controls can be voiced.
Improved user experience with head movement gestures.
Moved the large video compression step to the Liveness screen closure.

Security and telemetry updates.

Security updates.

Security updates.

Security and telemetry updates.

Fixed the RuntimeException error with the server-based Liveness that appeared on some devices.
Security updates.

Security updates.
Bug fixes.

Updated the Android Gradle plugin version to 8.0.0.
Internal SDK improvements.

Internal SDK improvements.

Security updates.

Security updates.

Security updates.

Security updates.

Added a description for the error that occurs when providing an empty string as an ID in the setFolderID method.
Fixed a bug causing an endless spinner to appear if the user switches to another application during the Liveness check.
Fixed some smartphone model specific-bugs.

Upgraded the on-device Liveness model.
Security updates.

The length of the Selfie gesture is now (affects the video file size).
You can instead of Oz logo if your license allows it.
Removed the pause after the Scan gesture.

Changed the master license validation algorithm.

Downgraded the required compileSdkVersion from 34 to 33.

Security updates.

Updated the on-device Liveness model.
Fixed some bugs.

Internal licensing improvements.

Internal SDK improvements.

Bug fixes.

Implemented the possibility of using a master license that works with any bundle_id.
Video compression failure on some phone models is now fixed.

Bug fixes.

The Analysis structure now contains the sizeReductionStrategy field. This field defines what type of media is being sent to the server in case of the hybrid analysis once the on-device analysis is finished successfully.
The messages for the errors that are retrieved from API are now detailed.

If multiple analyses are applied to the folder simultaneously, the system sends them as a group. It means that the “worst” of the results will be taken as resolution, not the latest. Please refer to this article for details.
For the Liveness analysis, the system now treats the highest score as a quantitative result. The Liveness analysis output is described .

Updated the Liveness on-device model.
Added the Portuguese (Brazilian) locale.
You can now add a custom or update an existing language pack. The instructions can be found .

Fixed errors.

The SDK now works properly with baseURL set to null.

The dependencies' versions have been brought into line with Kotlin version.

Added the new analysis mode – hybrid (Liveness only). If the score received from an on-device analysis is too high, the system initiates a server-based analysis as an additional check.
Kotlin version requirements lowered to 1.7.21.
Improved the on-device models.

Restructured the settings screen.
Added the center hint background customization.
Added new face frame forms (Circle, Square).

Improved the SDK algorithms.

Updated the model for the on-device analyses.
Fixed the animation for sunglasses/mask.
The oval size for Liveness is now smaller.

Fixed the error with the server-based analyses while using permanentAccessToken for authorization.

Added customization for the .
You can now hide the status bar and system buttons (works with 7.0.0 and newer).
OzLivenessSDK.init now requires context as the first parameter.

Fixed crashes for Android v.6 and below.
Fixed oval positioning for some phone models.
Internal fixes and improvements.

Updated security.
Implemented some internal improvements.
The addMedia method is now deprecated, please use uploadMedia for uploading.

Changed the way of sharing dependencies. Due to security issues, now we share two types of libraries as shown below: sdk is a server analysis only, full provides both server and on-device analyses:

UICustomization has been implemented instead of OzCustomization.
Implemented a range of options and switched to the new design. To restore the previous settings, please refer to .

Fixed the bug with freezes that had appeared on some phone models.
SDK now captures videos in 720p.

Synchronized the names of the analysis modes with iOS: SERVER_BASED and ON_DEVICE.
Fixed the bug with displaying of localization settings.

Now you can use Fragment as Liveness screen.
Added a new field to the Analysis structure. The params field is for any additional parameters, for instance, if you need to set extracting the best shot on server to true. The best shot algorithm chooses the most high-quality frame from a video.

The Zoom in and Zoom out gestures are no longer supported.

Updated the biometry model.

Added a new simplified API – AnalysisRequest. With it, it’s easier to create a request for the media and analysis you need.

Published the on-device module for on-device liveness and biometry analyses. To add this module to your project, use:

To launch these analyses, use runOnDeviceBiometryAnalysis and runOnDeviceLivenessAnalysis methods from the OzLivenessSDK class:

Liveness now goes smoother.
Fixed freezes on Xiaomi devices.
Optimized image converting.

New metadata parameter for OzLivenessSDK.uploadMedia and new OzLivenessSDK.uploadMediaAndAnalyze method to pass this parameter to folders.

Added functions for SDK initialization with LicenseSources: LicenseSource.LicenseAssetId and LicenseSource.LicenseFilePath. Use the OzLivenessSDK.init method to start initialization.
Now you can get the license info upon initialization val licensePayload = OzLivenessSDK.getLicensePayload().

Added the Kyrgyz locale.

Added local analysis functions.
You can now configure the face frame.
Fixed version number at the Liveness screen.

Added the main camera support.

Added configuration from license support.

Added the OneShot gesture.
Added new states for OzAnalysisResult.Resolution.
Added the uploadMediaAndAnalyze method to load a bunch of media to the server at once and send them to analysis immediately.

Access token updates automatically.
Renamed accessToken to permanentAccessToken.
Added R8 rules.

Fixed the oval frame.
Removed the unusable parameters from AnalyseRequest.
Removed default attempt limits.

To customize the configuration options, the config property is added instead of baseURL, accessToken, etc. Use OzConfig.Builder for initialization.
Added license support. Licences should be installed as raw resources. To pass them to OzConfig, use setLicenseResourceId.