Liveness detection & face biometrics

Confirm there is a real person, live — in seconds.

Liveness detection and face biometrics that run straight in the browser or in your app — no hardware, no friction. They stop photos, video, masks and deepfakes, and confirm the face really belongs to the ID on file.

No extra hardware Integrates in hours Privacy by design
4
Platforms — Web, iOS, Android and .NET MAUI
2
Anti-spoofing layers (device + server)
< 3s
Average time per validation
256-bit
End-to-end AES encryption
Live demo

Don't take our word for it. Try it yourself.

Point the camera and run a liveness check right now, here in the browser — the same challenges and the same anti-spoofing your customers will meet. Nothing is installed; nothing leaves your device unencrypted.

  • React to the randomized challenges and watch liveness pass in real time.
  • Try to fool it with a photo or a video on screen — and watch it get blocked.
  • This is exactly the Web SDK you integrate in production.
playground.biotrust.io
Face detection with a landmark mesh during a BioTrust liveness test

Face detection example. Run the real test →

The problem

Identity fraud got cheap. Proving you are a real person did not.

Mule accounts, deepfakes and leaked selfies turned digital onboarding into an easy target. Asking for "a photo" is no longer enough — you have to prove there is a live person, right there, right now.

Photos and video fool the check

A leaked selfie or a recorded video sails through anything that only checks "whether there is a face". Here, no live reaction means no pass.

Deepfakes scale fast

Face swapping and synthetic faces have become commodities for fraudsters. Stopping them takes far more than face recognition.

Identity ≠ a live person

Knowing a face exists says nothing about whether it is present, or whether it belongs to the ID on file. BioTrust settles both.

How it works

Liveness detection in 3 simple steps

For the end user it is fast and intuitive. For you, it is a clear answer: pass or fail.

The user looks at the camera

In the browser or in the app, with nothing to download and no special hardware. A guide oval positions the face in seconds.

They react to the challenges

Randomized movements and lights prove there is a live person, right there, right now — not a photo, a video or a deepfake.

You get the answer

Live person? Matches the ID? It comes back ready for your system to decide, with a score and an image, in seconds.

Features

Everything a serious verification needs

Liveness detection, face recognition and fraud prevention in one stack — on the client and enforced again on the server.

Liveness with randomized challenges

The user reacts to challenges drawn on the spot — turn, move closer, blink. A photo, a recorded video or another device's screen simply cannot answer.

Face recognition + official database

It goes beyond 'there is a live face': it confirms that face belongs to the ID holder, matching against the official biometric database. Real identity, not just presence.

Two-layer anti-spoofing

The same fraud-prevention model runs on the device and is checked again on the server — which never blindly trusts the client. Masks, deepfakes and screen replays fail both.

Active illumination against deepfakes

In the browser, the screen fires a random sequence of colored lights and measures the 3D reflection on the face. Injected video and synthetic faces do not reproduce that physics.

End-to-end encryption

The image leaves the device encrypted with AES-256 and only the server decrypts it, using an ephemeral key per session. No biometric data travels or sits exposed in the clear.

SDKs for Web, iOS, Android, .NET MAUI, Flutter and React Native

One biometric database for every platform you ship. Native SDKs and a REST API with documentation that actually helps — the first validation runs the same day.

1:N recognition

FaceMatch: enroll once, recognize from then on

Beyond proving liveness, BioTrust identifies who the person is — matching the face against your own enrolled database, on the spot and with liveness detection included.

1:N search — "who is this person?"Matches the face against the whole database and returns the corresponding record, with a similarity score.
1:1 match — verify against one IDChecks whether the face matches one specific enrolled document.
  • Liveness detection included — nobody gets in, or enrolled, with a photo.
  • Enrollment and people management from the SDK itself (add, edit, list).

Enrolled database

Mary S. · ID ***.456.789-** 98,6%

Where to use FaceMatch

Access control

Open turnstiles, gates and restricted areas by face — no badge, no password.

Front desk & buildings

Recognize residents and authorized visitors right at the entrance, with a record of every passage.

Event check-in

Entry without queues: the face is the ticket, with liveness detection against fraud.

Returning customers

Identify existing customers and tailor the service on the spot.

Deduplication & fraud prevention

Stop the same person from opening several accounts under different identities.

Time & attendance

Attendance you can trust, immune to clocking in for a colleague.

facematch.js
// 1. Enroll a person in the database (capture + liveness)
const manager = sdk.createManager(config, callback);
await manager.addPerson({
  document: "12345678901",
  documentType: "CPF"
});

// 2. From then on, identify with a 1:N search
const busca = {
  uuid: "usuario-123",
  apiUrl: "https://api.biotrust.io",
  validationMode: "FaceMatch",
  faceMatchConfig: { RequireChallenges: true }
};

const launcher = sdk.createLauncher(busca, {
  onValidationComplete: (r) => {
    const m = r.faceMatchResult;
    if (m?.match) liberarAcesso(m.fullName, m.similarity);
  }
});
await launcher.launch();
Active liveness

Challenges only a present person can complete

Instead of waiting for the user to "hold still and look at the camera", BioTrust asks for reactions drawn at random in every session. The order changes every time — so recording a video beforehand gets you nowhere: it will never answer in the right sequence.

  • Random sequence per session — the answer cannot be pre-recorded.
  • Fast and guided — the user finishes in seconds, with no friction.
  • Runs on the device — no heavy video sent to the server.

Randomized challenges

Move closer Move back Turn right Look up Blink
A different order on every validationA recorded video never gets the sequence right.
Active illumination

The barrier that stops injected deepfakes

During validation, the screen fires a random sequence of colored lights and measures how the face reflects each color in 3D. A real person reflects the right physics; an injected video or a synthetic face does not.

  • Color correlation — the reflection has to match the light that was drawn.
  • 3D structure — a flat surface (screen or photo) does not fool it.
  • Built into the Web SDK — no extra hardware cost.

A randomized color sequence, measured in real time in the reflection on the face.

Defense in depth

Whatever runs on the device, the server checks again

Anti-spoofing runs on the device — fast, and without uploading video. But the server never trusts the client's result: it re-runs the same model over the frame it received before approving. Fraud has to break through both.

  • The client score is telemetry only — the decision is made on the server.
  • Payload encrypted and bound to the session — no replay.
On the deviceFace detection + liveness + anti-spoofing in real time.
In transitFrame encrypted with AES-256 using an ephemeral session key.
On the serverRe-runs anti-spoofing and decides: pass or fail.
Attacks blocked

What BioTrust does not let through

The most common identity fraud attempts — blocked by independent layers of defense, on the device and on the server.

Printed photoNo reaction to the live challenges.
Blocked
Face on a screenFlat surface exposed by the 3D light analysis.
Blocked
Recorded video (replay)Never matches the randomized sequence.
Blocked
Masks and silicone facesRejected by texture anti-spoofing.
Blocked
Deepfake / face swapThe 3D reflection and structure do not add up.
Blocked
Video injection (virtual camera)Active illumination cannot be reproduced.
Blocked
Security & Compliance

Built for teams that cannot get security wrong

Independent layers of defense, strong encryption and privacy by design — from the device to the server.

Privacy by design

The heavy processing happens on the device and biometrics only travel encrypted. Less data exposed, and you stay in control.

End-to-end encryption

AES-256 with an ephemeral key per session: if a packet leaks, by the next day it is worth nothing.

Anti-deepfake and anti-injection

Active illumination and 3D structure analysis defeat injected video and synthetic faces that fool ordinary systems.

Double-checked on the server

The client score is telemetry only: the server decides, re-running fraud prevention over the frame it received.

Official biometric database

The match is against the official database. The answer is not 'there is a live face' — it is 'this is that person'.

Device binding and anti-replay

Every session is unique and bound to the device, with a single-use nonce. A captured request cannot be sent again.

Standards & Compliance

Built on the standards the market demands

BioTrust security and privacy follow the biometrics and data protection standards. Formal third-party certifications are on our roadmap — and the product was designed to pass them.

Privacy by design

On-device processing, data minimization and biometrics always encrypted — you remain the data controller.

Strong encryption

End-to-end AES-256, with an ephemeral key per session. No biometric data travels in the clear.

Tested against presentation attacks

Anti-spoofing evaluated with the ISO/IEC 30107-3 methodology: photo, video, mask and injection.

Use cases

Where BioTrust fits

Whenever you need to be certain who is on the other side of the screen.

Banks & Fintechs

Open fully digital accounts without opening the door to fraud. KYC and onboarding that stand up to compliance review.

Government & Services

Release benefits and public services only to the people they belong to, verified against the official database.

Healthcare & Telemedicine

Make sure the right patient is in the appointment and in the medical record — with no red tape for the user.

HR & Signatures

Hire and sign remotely with biometrics that hold legal weight. Remote onboarding, with no paper and no fraud.

Marketplaces & Gig

Verify drivers, couriers and sellers before granting access — and keep the platform clean.

Fraud Prevention & Payments

Re-authenticate risky operations in seconds and cut chargebacks, mule accounts and account takeover.

Comparison

Why this is not "just another face recognition"

The difference between checking that a face exists and proving there is a real, present, legitimate person.

Feature BioTrust Common approach
Liveness detection with randomized challenges passive or absent
Anti-spoofing on the device e on the server one side only
Active illumination against deepfakes
Match against the official biometric database rarely
Runs in the browser, with no app to install usually requires an app
Processes on the client (low cost and latency) everything on the server
SDKs for Web, iOS, Android, .NET MAUI, Flutter and React Native partial coverage
For developers

Integrate in hours, not weeks

One configuration, one call, one ready-made result. Every SDK follows the same logic — what you learn on the web applies on iOS, Android, .NET MAUI, Flutter and React Native.

Web<script> via CDN
iOSSwift Package Manager
AndroidGradle · Maven
.NET MAUINuGet · Android and iOS
Flutterpub.dev · Android and iOS
React Nativenpm · Android and iOS
liveness.js
// 1. Initialize the SDK
const sdk = new BioTrustSDK();
await sdk.initialize();

// 2. Set up the validation
const config = {
  uuid: "user-id",
  apiUrl: "https://api.biotrust.io",
  validationMode: "Liveness"
};

// 3. Launch it and handle the result
const launcher = sdk.createLauncher(config, {
  onValidationComplete: (r) => {
    if (r.success) approve(r.livenessConfidence);
  }
});
await launcher.launch();
<script src="https://s3.us-east-1.amazonaws.com/cdn.biotrust.io/1.2.2/biotrust-sdk.min.js"></script>
LivenessView.swift
import BioTrust

// Configure (builder pattern) and launch
let config = try FaceBiometricConfig.Builder()
    .setUuid("user-id")
    .setApiUrl("https://api.biotrust.io")
    .setValidationMode(.livenessOnly)
    .setLocale("pt-BR")
    .build()

let launcher = BiometricValidationLauncher(
    viewController: self,
    callback: MyCallback(),
    config: config
)

launcher.launch(from: self)
Swift Package Manager · github.com/biotrust-io/BioTrust-SDK-IOS-Release
LivenessActivity.java
import io.biotrust.sdk.*;

// Configure (builder pattern) and launch
FaceBiometricConfig config = new FaceBiometricConfig.Builder()
    .setUuid("user-id")
    .setApiUrl("https://api.biotrust.io")
    .setValidationMode(ValidationMode.LIVENESS_ONLY)
    .setLocale("pt-BR")
    .build();

BiometricValidationLauncher launcher =
    new BiometricValidationLauncher(this, new MyCallback(), config);

launcher.launch(this);
implementation 'io.biotrust:biotrust:1.2.2'
liveness-cpf.js
const sdk = new BioTrustSDK();
await sdk.initialize();

// Liveness + validation against the ID
const config = {
  uuid: "user-id",
  apiUrl: "https://api.biotrust.io",
  validationMode: "LivenessWithDocument",
  documentInfo: {
    document: "12345678901",               // ID number
    birthDate: "1990-01-01T00:00:00.000Z"  // date of birth
  }
};

const launcher = sdk.createLauncher(config, {
  onValidationComplete: (r) => {
    if (r.success) approve(r.documentResult);
  }
});
await launcher.launch();
<script src="https://s3.us-east-1.amazonaws.com/cdn.biotrust.io/1.2.2/biotrust-sdk.min.js"></script>
LivenessCPF.swift
import BioTrust

// Liveness + validation against the ID
let doc = DocumentInfo(cpf: "12345678901", birthDate: birthDate)

let config = try FaceBiometricConfig.Builder()
    .setUuid("user-id")
    .setApiUrl("https://api.biotrust.io")
    .setValidationMode(.livenessWithDocument)
    .setDocumentInfo(doc)
    .build()

let launcher = BiometricValidationLauncher(
    viewController: self,
    callback: MyCallback(),
    config: config
)

launcher.launch(from: self)
Swift Package Manager · github.com/biotrust-io/BioTrust-SDK-IOS-Release
LivenessCpfActivity.java
import io.biotrust.sdk.*;

// Liveness + validation against the ID
DocumentInfo doc = new DocumentInfo("12345678901", birthDate);

FaceBiometricConfig config = new FaceBiometricConfig.Builder()
    .setUuid("user-id")
    .setApiUrl("https://api.biotrust.io")
    .setValidationMode(ValidationMode.LIVENESS_WITH_DOCUMENT)
    .setDocumentInfo(doc)
    .build();

BiometricValidationLauncher launcher =
    new BiometricValidationLauncher(this, new MyCallback(), config);

launcher.launch(this);
implementation 'io.biotrust:biotrust:1.2.2'
facematch.js
// 1. Enroll a person in the database (capture + liveness)
const manager = sdk.createManager(config, callback);
await manager.addPerson({ document: "12345678901", documentType: "CPF" });

// 2. From then on, identify with a 1:N search
const busca = {
  uuid: "usuario-123",
  apiUrl: "https://api.biotrust.io",
  validationMode: "FaceMatch",
  faceMatchConfig: { RequireChallenges: true }
};

const launcher = sdk.createLauncher(busca, {
  onValidationComplete: (r) => {
    const m = r.faceMatchResult;
    if (m?.match) liberarAcesso(m.fullName, m.similarity);
  }
});
await launcher.launch();
<script src="https://s3.us-east-1.amazonaws.com/cdn.biotrust.io/1.2.2/biotrust-sdk.min.js"></script>
FaceMatchView.swift
import BioTrust

// 1. Enrolling people: through the FaceMatch management API (see the docs)

// 2. Identify with a 1:N search in the database
let config = try FaceBiometricConfig.Builder()
    .setUuid("user-id")
    .setApiUrl("https://api.biotrust.io")
    .setValidationMode(.faceMatch(requireChallenges: false))
    .build()

let launcher = BiometricValidationLauncher(
    viewController: self,
    callback: MyCallback(),
    config: config
)

launcher.launch(from: self)
Swift Package Manager · github.com/biotrust-io/BioTrust-SDK-IOS-Release
FaceMatchActivity.java
import io.biotrust.sdk.*;
import io.biotrust.sdk.model.*;

// 1. Enroll a person in the database (capture + liveness)
FaceMatchManagerConfig mgr = new FaceMatchManagerConfig.Builder()
    .setUuid("user-id")
    .setApiUrl("https://api.biotrust.io")
    .build();
new FaceMatchManagerLauncher(this, managerCallback, mgr)
    .addPerson(this, "12345678901", "Maria S.", DocumentType.CPF);

// 2. From then on, identify with a 1:N search
FaceBiometricConfig config = new FaceBiometricConfig.Builder()
    .setUuid("user-id")
    .setApiUrl("https://api.biotrust.io")
    .setValidationMode(ValidationMode.FACE_MATCH)
    .build();

new BiometricValidationLauncher(this, new MyCallback(), config).launch(this);
implementation 'io.biotrust:biotrust:1.2.2'
ProvaDeVida.cs
// 1. Set up the validation
var config = new ValidationConfig
{
    Uuid = "user-id",
    ApiUrl = "https://api.biotrust.io",
    Mode = ValidationMode.LivenessOnly
};

// 2. Present the screen and handle the result
var r = await new BioTrustValidator().ValidateAsync(config);
if (r.IsSuccess) Approve(r.VivacityConfidence);
dotnet add package BioTrust.Maui --version 1.2.2
AberturaDeConta.cs
var config = new ValidationConfig
{
    Uuid = "user-id",
    ApiUrl = "https://api.biotrust.io",
    Mode = ValidationMode.LivenessWithDocument,
    DocumentCpf = "12345678901",
    DocumentBirthDate = new DateTime(1990, 5, 20)
};

var r = await new BioTrustValidator().ValidateAsync(config);

// Identity confirmed in the official database
if (r.IsSuccess) AbrirConta(r.DocumentSimilarity);
dotnet add package BioTrust.Maui --version 1.2.2
FaceMatch.cs
// 1. Enroll a person in the database (capture + liveness)
var cadastro = new ValidationConfig { Uuid = "user-id", ApiUrl = "https://api.biotrust.io" };
await new BioTrustFaceMatchManager(cadastro)
    .AddPersonAsync("Maria S.", "12345678901", DocumentType.Cpf);

// 2. From then on, identify with a 1:N search
var busca = new ValidationConfig
{
    Uuid = "user-id",
    ApiUrl = "https://api.biotrust.io",
    Mode = ValidationMode.FaceMatch
};
var r = await new BioTrustValidator().ValidateAsync(busca);
if (r.Match == true) Liberar(r.PersonName, r.MatchConfidence);
dotnet add package BioTrust.Maui --version 1.2.2
prova_de_vida.dart
// 1. Set up the validation
final config = ValidationConfig(
  uuid: 'user-id',
  apiUrl: 'https://api.biotrust.io',
  mode: ValidationMode.livenessOnly,
);

// 2. Present the screen and handle the result
final r = await const BioTrustValidator().validate(config);
if (r.isSuccess) approve(r.vivacityConfidence);
flutter pub add biotrust_flutter
abertura_de_conta.dart
final config = ValidationConfig(
  uuid: 'user-id',
  apiUrl: 'https://api.biotrust.io',
  mode: ValidationMode.livenessWithDocument,
  documentCpf: '12345678901',
  documentBirthDate: DateTime(1990, 5, 20),
);

final r = await const BioTrustValidator().validate(config);

// Identity confirmed in the official database
if (r.isSuccess) abrirConta(r.documentSimilarity);
flutter pub add biotrust_flutter
face_match.dart
// 1. Enroll a person in the database (capture + liveness)
final cadastro = ValidationConfig(uuid: 'user-id', apiUrl: 'https://api.biotrust.io');
await BioTrustFaceMatchManager(cadastro)
    .addPerson('Maria S.', '12345678901', DocumentType.cpf);

// 2. From then on, identify with a 1:N search
final r = await const BioTrustValidator().validate(ValidationConfig(
  uuid: 'user-id',
  apiUrl: 'https://api.biotrust.io',
  mode: ValidationMode.faceMatch,
));
if (r.match == true) liberar(r.personName, r.matchConfidence);
flutter pub add biotrust_flutter
ProvaDeVida.tsx
import { BioTrustValidator, ValidationMode } from '@biotrust-io/react-native';

// 1. Set up the validation
const config = {
  uuid: 'user-id',
  apiUrl: 'https://api.biotrust.io',
  mode: ValidationMode.LivenessOnly,
};

// 2. Present the screen and handle the result
const r = await new BioTrustValidator().validate(config);
if (r.isSuccess) approve(r.vivacityConfidence);
npm install @biotrust-io/react-native
AberturaDeConta.tsx
const r = await new BioTrustValidator().validate({
  uuid: 'user-id',
  apiUrl: 'https://api.biotrust.io',
  mode: ValidationMode.LivenessWithDocument,
  documentCpf: '12345678901',
  documentBirthDate: new Date(1990, 4, 20),
});

// Identity confirmed in the official database
if (r.isSuccess) abrirConta(r.documentSimilarity);
npm install @biotrust-io/react-native
FaceMatch.tsx
// 1. Enroll a person in the database (capture + liveness)
const cadastro = { uuid: 'user-id', apiUrl: 'https://api.biotrust.io' };
await new BioTrustFaceMatchManager(cadastro)
  .addPerson('Maria S.', '12345678901', DocumentType.Cpf);

// 2. From then on, identify with a 1:N search
const r = await new BioTrustValidator().validate({
  ...cadastro,
  mode: ValidationMode.FaceMatch,
});
if (r.match === true) liberar(r.personName, r.matchConfidence);
npm install @biotrust-io/react-native

Get your key

Create the account, generate the API key and pick a plan — the test drive releases validations right away.

Add the SDK

A script tag on the web, the native package on iOS and Android, or the NuGet package on .NET MAUI. Set colors, language and challenges in minutes.

Handle the result

Receive liveness, the ID match, the score and the image — and let your backend decide the flow.

Pricing

Simple, transparent plans

Start on the free plan and move up when your volume calls for it.

50% off for the first 6 months

Free

To evaluate the SDK in a real scenario, with no commitment.

R$ 0 /month
  • Liveness detection
  • FaceMatch with up to 100 people
  • 10,000 validations per month
  • SDKs for Web, iOS, Android, .NET MAUI, Flutter and React Native
  • End-to-end encryption
Create free account
Basic

For production operations with a mid-sized enrolled database.

R$ 4,990/month

R$ 2,495 /month

for the first 6 months · then R$ 4,990/month

  • Liveness detection
  • FaceMatch with up to 500 people
  • 50,000 validations per month
  • SDKs for Web, iOS, Android, .NET MAUI, Flutter and React Native
  • End-to-end encryption

Biometrics against the official database: + R$ 2.00 per query

Subscribe
Enterprise

For tailored volume, environment and compliance requirements.

Custom
  • Volume and database sized by contract
  • Dedicated SLA and environment
  • Dedicated support
  • Onboarding with a specialist
  • Account and device management

Biometrics against the official database: + R$ 2.00 per query

Get in touch

Queries against the official document database are charged per use, on top of the monthly fee. Need a different volume? Talk to us.

Frequently asked

The questions everyone asks

Do I need any special hardware?
No. It works with the ordinary camera on any phone or laptop — straight in the browser or through the native SDK. No readers, no peripherals.
Can a photo or video of the user fool the system?
No. Liveness detection uses randomized challenges and, in the browser, active illumination. A photo, a recorded video and another device's screen are all rejected.
What about deepfakes?
Anti-spoofing runs on the device and is checked again on the server, on top of the 3D reflection analysis from the illumination — which defeats video injection attacks and synthetic faces.
Is it compliant with data protection law?
Yes. The design minimizes data: processing happens on the device and biometrics always travel encrypted. You remain the data controller.
How long does integration take?
Hours, not weeks. We offer SDKs for Web, iOS, Android, .NET MAUI, Flutter and React Native, plus a REST API, with documentation and a test environment.
How does validation against the ID work?
On top of liveness detection, we match the captured face against the official biometric database to confirm it really belongs to the document provided.
Does it work in low light?
Yes. Capture is guided and tells the user when the lighting is not good enough. The active illumination check, in fact, uses the screen's own light to measure the reflection on the face.
Is biometric data stored?
Liveness processing happens on the device and the image travels encrypted. What is retained, and for how long, follows your own policy — the design favors the data minimization that privacy law requires.
Can the look and feel be customized?
Yes. Colors, language, copy and watermark are all customizable, so the experience carries your product's identity on web and mobile.
How do I start testing?
The live demo is available on this page. To integrate, the free plan covers 10,000 validations per month and a database of up to 100 people, with no commitment.
Let's get started

Ready to block fraud without blocking your customers?

Talk to an expert and see BioTrust running in your own flow — web, iOS and Android.