You needed a face match engine. They sold you a suite.
Kavuka Face Match is the facial comparison engine as an API: verify 1:1 (are these two faces the same person?) and search 1:N (does this face exist in the base?) in milliseconds — public docs, sandbox on day one, price per call and data on national soil. The component your team integrates today, not the suite you never asked for.
- Milliseconds
- per 1:1 verify
- 1:N
- search against millions of templates
- Day one
- instant sandbox
- National soil
- domestic data and latency
The same engine that powers the Kavuka platform, exposed as a component: verify and search in production, millions of indexed templates and published accuracy metrics — not promised ones.
Your team only wanted the engine. The market insists on selling the closed suite.
The closed suite and lock-in
The vendor that only sells the packaged solution charges enterprise pricing for a component use case — and holds your roadmap hostage to a proprietary SDK.
The months-long integration
A proprietary SDK, documentation that requires a sales call to read and quarterly implementation cycles stall the product that needed facial comparison yesterday.
The biometric base out of control
Template stored with no namespace, expiry or deletion, on the foreign alternative that also puts your data outside the country, with intercontinental latency in the middle of the flow.
Cost The team that needs an engine and buys a suite pays three times over — in price, in lock-in and in a hostage roadmap. The one that tries to build from scratch discovers the real cost of accuracy, scale and model maintenance. The right component, with the right DX, is the third way.
From the POST to the decision — and the page speaks to developers.
- 01
Create the account and grab the key
Instant sandbox, no sales call: you are running the first verify in minutes, not months.
- 02
POST /verify (1:1)
Two images → similarity score + recommended threshold per use case, in milliseconds.
- 03
POST /search (1:N)
One face against your indexed base → ranked matches with confidence, even across millions of templates.
- 04
Manage the templates
Enroll, namespaces, expiry and deletion — the base under the client’s control, LGPD by design.
The bare engine, with everything a component demands
The same engine that powers the platform, sold as a part: the global benchmark in a local API, with the documentation, latency and pricing model an engineering team expects.
Verify (1:1)
Selfie × document, selfie × record
Search (1:N)
Ranked search against millions of templates
Enroll and base management
Namespaces, expiry and deletion
Image quality
Pre-match score rejects the unusable photo
Published accuracy
FMR/FNMR per threshold, NIST FRVT standard
Developer-first DX
Clear docs, SDKs and instant sandbox
National infrastructure
Data and latency on Brazilian soil
Template, not image
Mathematical representation of sensitive data
Who builds with Kavuka Face Match
Platforms & SaaS
Embed facial verification in their own product, with the latency and price of a component — not a suite.
Apps with biometric action
Login or face confirmation in the native flow: verify at app speed, without proprietary-SDK friction.
Deduplication & investigation
The 1:N to find multi-accounts, duplicates and ties in your own base — with proper governance and documented legal basis.
Integrators & software houses
The white-label engine for projects: facial comparison delivered to the end client without building a model from scratch.
Biometric data is sensitive — and the engine was designed for it
Face Match treats biometric data as sensitive personal data from the very first record: it stores the template (a mathematical representation), not the image, where the case allows, and keeps the base under the client’s control. The safeguard is not a report at the end — it is the design of the component.
- Template, not image: a mathematical representation of the sensitive biometric data, where the use case allows.
- Base under the client’s control: namespaces, expiry and deletion by call.
- Data on national soil — the sovereignty argument, with domestic latency.
- Published accuracy metrics (FMR/FNMR per threshold): the benchmark out in the open, in line with international standards.
- Legal basis documented by the client for 1:N uses (deduplication, investigation), with encryption in transit and at rest.
We were braced for a three-month integration. We ran the first verify by the afternoon of day one.
We swapped the closed suite for the bare engine and the cost per verification dropped absurdly — we pay for what we use.
For the DPO, what changed the game was the base under our control: template, expiry, deletion and data in the country.
Ready to run the first verify in 10 minutes?
Grab the sandbox key, read the public docs and test verify and search on your scenario — no sales call.
- For businesses only. No purchase commitment.
- Data used solely for commercial contact.
- Enterprise leads answered within 1 business day.
What a Face Match engine is and how to integrate it
Face Match is the facial comparison engine exposed as an API: the developer-first component that answers two questions in milliseconds. The first is 1:1 — are these two faces the same person? It is the comparison of selfie against document or selfie against record, the verify that confirms an identity inside a product flow. The second is 1:N — does this face exist in this base? It is the search of one face against millions of indexed templates, returning matches ranked by confidence. Together, verify and search are the heart of any product that needs to recognize, confirm or deduplicate people by image.
The distinction within the portfolio matters. Biometrics is the complete solution — guided capture, liveness, governance and packaged use cases, ready for those who want the whole bundle. Face Match is the bare engine: the API for the engineering team that wants to embed facial comparison in their own product, with the latency, documentation and pricing model a component demands. It is the developer-tools shelf product — the same engine that powers the platform, sold as a part. Whoever only needed the engine should not pay the price, the lock-in and the hostage roadmap of a closed suite.
Developer experience is the product. Public docs you can read without a sales call, SDKs, an instant sandbox and transparent per-call pricing deliver integration in hours, not months. The engine also handles what tends to become a false negative: an image-quality score rejects the unusable photo before the match, and every response comes with the recommended threshold per use case, calibrated on numbers — not on promises. Accuracy is published as FMR/FNMR per threshold, in line with international benchmark standards (NIST FRVT), so calibration is an informed decision by your team.
Sovereignty closes the argument. Global APIs defined the developer-first format, but they put templates outside the country, with intercontinental latency in the middle of the flow; local players mostly sell the packaged suite, leaving the bare component poorly served. Kavuka Face Match is the local API with the global benchmark: data on national soil, domestic latency and biometric data handled as sensitive — template, not image, with namespace, expiry and deletion under the client’s control. And it is the developer gateway to the entire portfolio: the dev who integrates the engine today becomes the champion of tomorrow’s enterprise deal, because the upgrade to Liveness, full Biometrics and the onboarding pipeline is a parameter in the call, not a new project.
What is the difference between Face Match and the Biometrics solution?
Face Match is the engine as an API — verify and search for your team to embed in your product. Biometrics (the complete solution) adds guided capture, Liveness, governance and packaged use cases. The engine is the gateway; the upgrade to the full solution is natural and requires no re-integration.
Does Face Match include liveness?
The bare engine compares faces; Liveness is an additional module (a parameter in the call). There are legitimate comparison cases without liveness — base deduplication, for instance — and the component should charge only for what you use.
How does 1:N search work?
You enroll templates into namespaces; the indexed search returns matches ranked by confidence in milliseconds, even across bases of millions. Deduplication, multi-accounts and investigation are the typical uses — with the legal basis documented by the client.
Where is the data stored?
On national soil, as templates (mathematical representations, not images, where the case allows), with expiry and deletion under the client’s control — the LGPD design for sensitive data.
What is the engine’s accuracy?
We publish the metrics (FMR/FNMR per threshold) and the recommended threshold per use case — the benchmark out in the open, in line with international standards (NIST FRVT), so you calibrate based on numbers, not promises.
How do I start integrating — do I need a sales call?
No. You create the account, grab the sandbox key and run the first verify in minutes. The documentation is public and reads without a form; there is a free tier (1,000 calls/month) and transparent per-call pricing to scale whenever you want.
How do I evolve from the engine to the full pipeline?
The upgrade is a parameter, not a new project. From Face Match you turn on Liveness, full Biometrics, OCR (the document+face pair) and the Onboarding pipeline — with no re-integration, because it is the same engine underneath.
Let's talk
Your next high-impact decision starts with the right data.
Talk to a GUÉP specialist and find where applied intelligence creates the most value in your operation.