Know the device. Understand the risk.
Stop abuse in real time.
Sentriq combines device, account, network, automation, and risk intelligence into explainable real-time decisions. Every signal is named and weighted — not a black-box score.
See it in action
A decision, not a black box
Illustrative example — see it with your own browser on the Demo page.
- NEW_DEVICE
- HIGH_IP_VELOCITY
- AUTOMATION_SUSPECTED
What Sentriq does
Six capabilities, one explainable decision
Device Intelligence
Coarse, non-invasive signals — screen, hardware, platform, UA, timezone, locale — resolved into a device with a deterministic, explainable confidence score.
Network Intelligence
Deterministic IP classification plus IP-based velocity and credential-abuse detection, derived server-side from the request itself.
Account Security
Device-to-account relationships, multi-account-per-device detection, and credential-abuse pattern detection across your login surface.
Bot & Automation
Three transparent heuristics — webdriver flag, headless pattern, viewport consistency — combined into a 0-100 automation confidence score.
Fraud Signals
Every signal that touches a decision is named, timestamped, and attributable — new device, brute force, credential stuffing, and more.
Risk Engine
A deterministic, weighted-sum score with a policy engine that turns it into an allow, monitor, challenge, or block decision.
How it works
From signal to decision, every step is visible
Device Intelligence
Confidence-based device resolution, explained in plain terms
Sentriq resolves device identity from coarse, non-invasive browser signals using a deterministic, weighted-similarity algorithm — not machine learning, and not a probabilistic guess. Every resolution produces a 0-100 confidence score and a reason you can read, so a “known device” decision is something your team can explain to a customer or an auditor, not just trust blindly.
We deliberately don’t collect canvas, WebGL, or audio fingerprints. It’s a privacy boundary, not an oversight — and it means Sentriq has no accuracy claim to make beyond what a deterministic algorithm on coarse signals can honestly deliver.
- Screen, hardware, platform, UA, timezone, and locale signals only — no canvas, WebGL, or audio fingerprinting, ever.
- A 0-100 confidence score from weighted signal similarity, with every contributing signal named — not a black-box match.
- Tolerant of normal device evolution: a browser update is tracked in signal history but never itself treated as a new device.
- A cleared-storage or incognito session with no other matching signals resolves as a new device — there is no probabilistic fallback that reaches across a full reset.
Device ↔ account linkage
Every account seen on a device is tracked, both directions.
Multi-account-per-device detection
Flags a device once it has been used to access several distinct accounts.
Brute-force detection
One account, repeated failed logins from few sources.
Credential-stuffing detection
One source, failed logins spread across many accounts.
Account-attack detection
One account under attack from many distinct sources.
Account Security
Catch credential abuse before it becomes a breach
Sentriq tracks the relationship between devices and the accounts they touch, so patterns that are invisible one login at a time become obvious in aggregate — a device cycling through accounts, an account under sustained attack from many sources, or one source hammering many accounts.
Credential-abuse detection is tuned to stay quiet on shared connections like corporate NAT or campus Wi-Fi, so a busy office doesn’t read as a credential-stuffing attack.
Bot & Automation
Three honest heuristics, one transparent score
Sentriq combines three coarse, well-understood automation heuristics into a 0-100 automation confidence score, independent of the fraud risk score. This is a heuristic-based signal, not a comprehensive bot-detection suite — it is not intended to compete with dedicated, DataDome-class bot-mitigation products, and Sentriq returns a decision, not a challenge UI; rendering any CAPTCHA or challenge is your application’s own implementation.
WEBDRIVER_DETECTED`navigator.webdriver === true` — a direct signal exposed by automated browsers.
headless_hintZero plugins and zero MIME types enumerated — a common headless-browser pattern, treated as a heuristic, never as certainty.
runtime_inconsistencyReported viewport dimensions are internally inconsistent with a real browser window.
Network Intelligence
IP signal you can rely on today
Available today
- IP address capture, derived server-side from the request itself — never trusted from the client.
- Deterministic IP classification — public, private, reserved, and similar categories.
- IP-based velocity detection and credential-abuse pattern detection (brute force, credential stuffing, account-attack patterns).
On the roadmap
- IP enrichment — geolocation, ASN/hosting-provider lookup, VPN/proxy/Tor detection — is architected end-to-end but not yet bound to a data provider.
Risk Engine
A score you can explain, signal by signal
Every risk assessment is a deterministic weighted sum. Nothing about the score is hidden: each contributing signal is returned with its own code, its own weight, and a plain-language description of why it fired — so “challenge” is a decision your team can audit, not a number to take on faith.
The policy engine then maps the score to a decision — allow, monitor, challenge, or block — against thresholds your team controls.
{
"score": 65,
"level": "high",
"decision": "challenge",
"signals": [
{
"code": "BRUTE_FORCE_SUSPECTED",
"weight": 30,
"description": "8 failed logins against this account from 1 source(s) in the last velocity window."
},
{
"code": "NEW_DEVICE",
"weight": 15,
"description": "This device has not been seen for this account before."
}
]
}Example response shape — try it live on the Demo page.
import { Sentriq } from '@sentriq/browser';
const sentriq = await Sentriq.init({ publicKey: 'pub_test_xxx' });
const result = await sentriq.track('login', {
account: { id: 'usr_123' },
});
console.log(result.risk.level); // 'low' | 'medium' | 'high' | 'critical'
console.log(result.risk.decision); // 'allow' | 'monitor' | 'challenge' | 'block'Developer Experience
A few lines to integrate
Initialize the SDK with a public key, then call track() with a named security event — login, signup, payment, and more. You get back a risk level and a decision, and you decide what to do with it — Sentriq never hangs indefinitely on a critical path, and it never silently swallows a failure.
The SDK only ever collects coarse, non-invasive signals and reports them — the server, not the browser, is authoritative for device identity and every risk decision.
Integrations
Wherever your stack lives
JavaScript / TypeScript
The core @sentriq/browser SDK — drop it into any web app.
React
Works in any React app, since the SDK is plain JavaScript.
Next.js
Works via the same @sentriq/browser package.
REST API
Call the same event and risk endpoints from any backend language.
Laravel / PHP
Call the REST API directly from Laravel or any PHP backend.
Deterministic, explainable risk decisions — the transparent alternative.
Integrate the SDK, call track(), and get back a risk level and a decision you can explain, signal by signal.