SDK & integration preview

Behavioral biometrics is the seventh corroboration axis and the only one still in candidate scope: a human-interaction and device-consistency check that can help separate human application behavior from scripted or ring-linked activity. Until it is approved, every surface that mentions it — including this one — carries the candidate label, and no SDK packages are published.

This is candidate scope and must remain status-labeled until approved.

The integration has two halves that never share raw data. At capture time, a platform SDK records a behavioral session during the application flow and returns an opaque token. At consumption time, a REST API returns evidence the engine has already sealed.

1. Install the platform SDK and initialize it with your public key.
2. Start a session when the application form opens, keyed to your application id.
3. Finalize the session on submit and attach the returned session token to your application payload.
4. After the engine evaluates and seals the record, pull results from the consumption-time API.

The panel below computes a browser-local illustration of the signal classes the candidate axis would draw on: pointer-trajectory naturalness, keystroke cadence, automation flags, and device-consistency checks. It observes nothing until you start it, watches only inside its own box, stores nothing, and transmits nothing — open your browser’s network inspector and verify.

Two boundaries worth noticing. First, the read abstains until the sample is large enough — the same abstention-first posture the engine applies when evidence is thin. Second, this is an illustration, not the production signal: the real capture SDK reduces richer signals to an opaque session token on-device, and ships only if this axis graduates from candidate scope.

Behavioral biometrics catches scripted automation — pointer-trajectory naturalness, keystroke cadence, and target-landing precision separate a curve-fitted bot from a real hand. It does not, on its own, catch the apex tier: a real operator driving a remote desk, a GAN producing human-quality trajectories, or a replay of recorded legitimate input. Those defeat behavioral signals entirely, and the demo names this plainly.

The composition we ship pairs the behavioral atom with a non-behavioral coherence atom (stated residence vs. session-origin region) so the apex tier still flags. The interactive demo, including the apex-mode toggle and the composed verdict, lives inside the gated app — that’s the right surface for a risk-team audience and the one canonical implementation.

See the live capability demo →

A drop-in JavaScript SDK that captures the behavioral session in the page and emits a session token on submit. Package coordinates below are illustrative — nothing is published yet.

<!-- Illustrative — no published artifact yet -->
<script src="https://cdn.kenshiki.example/sdk/kenshiki-web.min.js"></script>

const kenshiki = Kenshiki.init({
publicKey: "pk_demo_xxx",
platform: "browser",
});

// Begin a behavioral session when the application form opens
const session = kenshiki.startSession({ appId: "mortgage-01" });

// On submit, finalize and attach the session token
form.addEventListener("submit", async () => {
const { vendorSessionId } = await session.finalize();
// include vendorSessionId with your application payload
});

• Runs entirely client-side; nothing beyond the session token leaves the page.
• Requires a visible consent notice and respects browser tracking protections.
• Degrades gracefully when the browser blocks fingerprinting APIs — absence of the signal is handled by abstention, not failure.

A native Swift package capturing interaction and device-consistency signals during onboarding. Coordinates are illustrative.

// Swift Package Manager — illustrative, not yet published
.package(url: "https://github.com/kenshiki-labs/kenshiki-ios.git", from: "1.0.0")

import KenshikiSDK

let kenshiki = Kenshiki(publicKey: "pk_demo_xxx", platform: .ios)

let session = kenshiki.startSession(appId: "mortgage-01")

// When the applicant submits
session.finalize { result in
  switch result {
  case .success(let token):
      // attach token.vendorSessionId to your application payload
  case .failure(let error):
      print(error)
  }
}

• Requires the platform tracking-usage disclosure and consent prompt where applicable.
• Uses on-device signals only; no raw biometrics are transmitted.
• Targets current and previous major iOS versions; integrates with both UIKit and SwiftUI.

A native Kotlin library capturing device and behavioral signals during the application flow. Coordinates are illustrative.

// build.gradle (app) — illustrative, not yet published
implementation("com.kenshiki:kenshiki-android:1.0.0")

val kenshiki = Kenshiki.init(
  publicKey = "pk_demo_xxx",
  platform = Platform.ANDROID,
)

val session = kenshiki.startSession(appId = "mortgage-01")

// On submit
session.finalize { result ->
  result.onSuccess { token ->
      // attach token.vendorSessionId to your application payload
  }.onFailure { e -> Log.e("Kenshiki", e.message ?: "") }
}

• No special permissions required for the default signal set.
• Signals are computed on-device; only the session token is sent.
• Compatible with Jetpack Compose and Views.

The capture half is designed so there is nothing sensitive to intercept. Signals are computed on-device and reduced to an opaque session token before anything is transmitted. The consumption half only returns evidence the engine has already sealed — the API cannot be used to re-derive raw signals or re-decide an application.

The SDK emits a session token; raw biometric data never leaves the device.

The consumption-time API is implemented, generated from the same Zod contracts the server validates against, and runnable against the synthetic demo dataset. The OpenAPI specification documents only implemented endpoints, so capture-time endpoints will appear there — and downloads will appear here — only if the behavioral-biometrics signal graduates from candidate scope.