What the SDK returns
- Structured decision:
allow,deny,require_strong_method,inconclusive - Age, liveness and quality score breakdown
- Integrator-configurable minimum age
- Local pipeline with face detection, age estimation and liveness
Privacy by design for age verification in sensitive digital flows
Age verification with privacy by design and local processing
Kagefy is designed to enforce age restrictions with local processing, liveness and risk-based decisions. Integrate on web and mobile, tune the validation bar to your risk profile and keep a strong fallback when evidence is not enough.
Local processing in the default flowReturns
allow, deny, require_strong_method or inconclusiveConfigurable minimum age and web SDK with a clear path to mobile
Starting at R$ 0.05 per completed validation. Built for teams that need to enforce 18+ access with lower image exposure in the default flow.
Designed to combine effective age verification mechanisms with data minimization and privacy protection.
- Brazilian Federal Constitution, article 5, X
- Decree No. 12.880/2026, article 15, I, and article 24
Quickstart to evaluate without booking a call first
If I were a developer evaluating this SDK, I would need three answers quickly: how to integrate it, what it returns and which platforms are ready now.
Minimal React example
Minimum age, risk profile and final decision in a few lines.
import { useEffect } from "react";
import { useAgeVerifier } from "@kagefy/sdk-react";
export function AgeGate() {
const { videoRef, result, start } = useAgeVerifier({
minimumAgeYears: 18,
riskProfile: "high",
});
useEffect(() => {
void start();
}, [start]);
return (
<>
<video ref={videoRef} autoPlay playsInline muted />
<pre>{result?.decision.decision ?? "starting"}</pre>
</>
);
}Platform status
- Web SDK: ready for evaluation now
- React SDK: ready for evaluation now
- React Native and Ionic: product path already prepared
- Native Android and iOS: planned evolution for stronger mobile signals
What the team sees in practice before talking to sales
The flow needs to become clear quickly: local capture, signal consolidation and a decision the product can operate on.
How this shows up in the product
- The user enters a flow with local capture and minimum quality validation
- The SDK combines estimated age, liveness and risk context in the same session
- The product receives a ready-to-operate decision instead of an isolated score
The central idea is to reduce operational ambiguity: the SDK does not just return detection, it returns an actionable decision.
Structured response example
The response below shows how the SDK returns an output that is ready for policy enforcement, not just isolated signals.
{
"minimumAgeYears": 18,
"decision": "require_strong_method",
"riskProfile": "high",
"signals": {
"age": {
"estimate": 19.4,
"confidence": 0.91
},
"liveness": {
"status": "passed",
"challengeCount": 2
},
"quality": "good"
}
}A better decision because validation does not depend on a single signal
Instead of relying on one weak method, the platform combines local signals, capture quality and liveness to produce an output the product can use immediately.
Local face detection
The SDK verifies face presence, framing and minimum quality before advancing.
Local age estimation
Age estimation runs locally without sending facial frames to the backend in the default flow.
Challenge-based liveness
The system runs liveness challenges to make simple fraud harder and improve operational confidence.
Risk-based decision
Signals are consolidated into a ready-to-use output: allow, deny, require_strong_method or inconclusive.
Strong fallback
When evidence does not support release, the platform escalates to a stronger method or returns inconclusive.
Designed for conservative decisions in sensitive flows
- Focused on age verification, not on full KYC
- Complements access policy without replacing civil identity proof
- Weak evidence does not support release in sensitive contexts
- Lack of signal preserves a conservative decision posture
- Inconclusive is part of the decision policy
- Strong fallback is built in for higher-risk contexts
Structured output for the product layer
| allow | Release when the signal combination supports the flow for the configured risk level. |
| deny | Block when evidence clearly conflicts with the configured policy. |
| require_strong_method | Escalate to a stronger method when the context requires more proof than the local flow can provide. |
| inconclusive | Valid state when the platform should not release access on the observed evidence. |
Practical example: age-borderline cases or insufficient evidence should be directed to require_strong_method or inconclusive, preserving a more defensible policy.
Privacy is part of the system design.
The product is designed around data minimization. The default path prioritizes local processing, lower image exposure and an architecture that is easier to defend across product, security and compliance.
Privacy by design
- Local processing in the default flow
- Selfie retention is outside the structural requirement
- Raw biometrics stay outside the product foundation
- Minimal logs for operational audit
- Offline/on-device operation whenever applicable
What stays on device
- Face detection
- Age estimation
- Liveness
- Capture quality
- Local decision whenever the flow allows it
What may leave the device
- Consolidated score
- Final decision
- Timestamp
- Method used
- Model version and minimal audit metadata
Where this model delivers value faster
The product was designed for contexts where age restriction, privacy and strong fallback need to coexist without improvisation.
Adult content
Access control with lower exposure of sensitive data and strong fallback when evidence is not enough.
Age-restricted platforms
Apps, communities, publishers and services that need to enforce minimum age with more operational consistency.
Reputationally sensitive digital products
When user protection, privacy and risk reduction must move together.
Web and mobile
One product foundation with a clear path to multiple platforms.
Built for technical teams that need to integrate fast and defend the choice internally
SDK integration, risk-based configuration and structured output for direct use in the product.
SDK-first
SDK integration for web and React, with a prepared path for React Native, Ionic and future Android and iOS expansion.
Risk configuration
The integrator sets minimum age, risk profile and validation policies for the specific use case.
Adjustable strictness
Lower friction where that makes sense, stronger policy where the operation requires more resistance to bypass attempts.
Structured decision
The output already organizes risk, evidence and fallback needs for direct product use.
Start with the React SDK
Minimal example to start the technical evaluation with React.
npm install @kagefy/sdk-react
Privacy by default and a more defensible technical choice for product, engineering, legal and compliance.
Risk starts when access is sensitive and verification is weak
In practice, the hard part is not separating obvious extremes. It is reducing fraud around the relevant age boundary without forcing users into an invasive flow or creating an operation that is hard to defend internally.
Weak solutions
Isolated and superficial methods are easy to bypass and leave the platform exposed in higher-risk flows.
Invasive solutions
Flows that require selfie upload, image retention or excessive data capture increase friction, regulatory pressure and reputational risk.
What the platform needs
Infrastructure that combines privacy, fraud resistance and fallback capacity when evidence is not enough to unlock access.
Volume-based pricing to start small and gain efficiency
Commercial positioning starts at R$ 0.05 per completed validation. The calculator shows how the effective tier changes with the credit package and expected consumption.
Plan calculator
Simulate your credit tier and see the applicable pricing
The calculator uses the current commercial ladder, from 1,000 up to 1,000,000 equivalent credits, to show the applicable tier and unit price.
Credit tier
1,000,000 credits
Price per validation
R$ 0.05
Commercial reference tiers for initial evaluation. Consumption above 1 million can be handled under a dedicated commercial arrangement.
Starting at
R$ 0.05
per completed validation
Credit-based model, starting at 1,000 credits with progressive discounts as the consumption tier grows.
- Entry point starts at 1,000 credits
- Progressive discount as the consumption tier grows
- Tiers designed to reduce marginal cost in larger operations
- During evaluation we detail how retries, inconclusive results and fallback paths affect consumption policy
Frequently asked questions for initial evaluation
Short answers so product, engineering, legal and leadership can quickly understand the positioning.
Does the product send facial images to the server?
In the default flow, the proposal is local processing and an initial decision path that stays outside the backend.
Does the product store biometrics?
The architecture is designed to minimize data and avoid raw biometric persistence in the default flow.
Does this replace KYC?
The solution is decision infrastructure for age verification. KYC and proof of civil identity belong to a different product layer.
Does it work offline?
The design prioritizes local execution and offline/on-device operation whenever applicable.
What leaves the device in the default flow?
The goal is to transmit only score, decision and minimal audit metadata. Facial images are outside the default dependency of the flow.
Which platforms are ready now?
Evaluation starts with the web SDK and the React SDK today. React Native, Ionic and native mobile are part of the planned product evolution.
Can I configure the minimum age?
Yes. The platform is designed to let the integrator configure minimum age for the specific use case.
How does pricing work?
Commercial communication starts at R$ 0.05 per completed validation. The effective tier depends on the credit package and expected consumption, as shown in the calculator.
If your team needs to restrict access by age with lower image exposure, it is worth a conversation.
We show how to integrate, where the flow fits in the product and how to calibrate validation for the real risk of your use case.
Request a demo
Fill out the form and the team will return with the next step for architecture, integration and commercial model. No attachments, no image upload and no unnecessarily long form.
What happens next
- We understand your flow and required minimum age
- We suggest the risk profile and validation bar
- We point to the most viable integration path for web or mobile
Good context to send
- Expected consumption tier
- Whether the flow is web, mobile or hybrid
- Whether you need 18+, another minimum age or mandatory strong fallback