Identity verification, rebuilt for live capture

Prove it's a person.
Not a photo of one.

FaceVerify replaces gallery uploads with a guided live camera check - automatic capture, active liveness, and duplicate detection across your entire user base, before an account ever goes live.

Request API access See how it works ↓

Built for platforms that can't afford a fake account

Dating & socialMarketplacesFintech onboardingCreator platforms

The old way has a hole in it

A gallery photo proves someone had a photo. Not that they were there.

Edited or AI-generated faces pass a static upload check every time
Screenshots and replayed video look identical to a real photo
Old, filtered, or heavily compressed images enroll a face that no longer matches
None of it proves a live person was in front of the camera

One face, seven checks, one decision

Every verification runs the same disciplined pipeline

No shortcuts, no single-frame guesses - each stage has to pass before the next one runs.

Quality assessment

Sharpness, brightness, and framing are checked live, before a single frame is captured - a bad frame never gets the chance to reach the server.

Liveness engine

Two prompts, chosen at random from a wider set, in a random order - never the same sequence twice, so it can't be memorized or replayed.

Frame selection

The front-facing frame, plus one for each completed prompt. Everything else captured during the session is discarded, not stored.

Embedding generation

A fresh set of face embeddings for this attempt - not one photo, reused indefinitely, from the day an account was created.

Duplicate search

Checked against every other enrolled face on your platform, not just a lookup against the account being verified.

Decision engine

Confidence and match margin decide the outcome. An ambiguous result is never forced into a guess.

Response & webhook

A signed result, delivered server-to-server, the moment it's ready - not when your frontend happens to poll for it.

Confidence, not a coin flip

Three honest outcomes. No forced yes.

The decision engine never collapses an unclear result into a false positive.

Verified

Confidently the right person

High confidence, no ambiguous second match. Cleared automatically.

Manual review

Close enough to check

Either the match margin is too tight to trust, or this face closely resembles another enrolled account. Held for a human, not guessed at.

Failed

Never resolved

The session was abandoned or repeatedly unclear across every retry attempt.

A returning user is never mistaken for their own duplicate. Duplicate search excludes the account being verified from its own match search - so re-verifying isn't penalized as suspicious.

Server-to-server, signed, no polling required

One webhook. Every field you need.

Start a session, redirect the user, and wait for a signed result - that's the entire integration surface.

POST a session request. No image, no gallery photo - just who's being verified.

Redirect to the link you get back. The guided camera flow runs entirely on our side.

Receive a signed webhook. Verify the signature, read the outcome, done.

webhook payload

{
  "event": "verification.completed",
  "status": "verified",
  "external_user_id": "user_8841",
  "confidence": 97.4,
  "livenessPassed": true,
  "duplicate": false,
  "risk": "LOW",
  "reason": null,
  "frontImageUrl": "https://...signed, expires in 15m"
}

Built like infrastructure, not a demo

Nothing about this is a prototype

Access-controlled, not just encrypted

Face embeddings live behind row-level security scoped to your account. Captured images resolve to short-lived signed links - never a public URL.

Indexed for scale

Duplicate search runs against an HNSW-indexed vector store, not a full-table scan that slows down as your enrolled base grows.

A retention policy, not a promise

Abandoned sessions and their images are purged automatically on a schedule. Nothing lingers past the reason it existed.

Decision internals stay internal

Matching thresholds and model internals never leave the server - your integration gets a decision, not a way to reverse-engineer one.

Ready to stop trusting a photo?

Get API access and a sandbox client key - most integrations ship in an afternoon.

Request API access