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.

Funny for about three seconds. Type. Move. Hesitate. Correct yourself. Real people are messy; bots try not to be. The joke is that proving you are human feels ridiculous. The problem is that more of the internet now has to ask.

On the surface, it is a small typing test: type the line, get your words-per-minute, and receive a mildly unfair judgment about your speed and accuracy. Underneath, your browser is watching simple local clues: how your pointer moves, how unevenly you type, whether you correct mistakes, whether the browser says it is automated, and whether the device details agree with each other. It observes nothing until you start, samples pointer motion only while the test is running, stores nothing, and sends nothing — open your browser’s network inspector and verify.

Two things to know. First, the panel waits until it has enough movement or typing to say anything. Thin evidence gets no guess. Second, this is only a local illustration. The real SDK works on-device, turns richer capture data into a session token, and never sends raw typing or pointer trails.

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.

Unlike the capture-time SDKs above, the Pulse beta embed is shippable today: a hosted script that locks a browser action until the carried phone proves the same human is present. Request a publishable key, allowlist your origins, and paste one snippet.