Device and operating system
OS version, architecture, device class, screen behavior, and platform-specific browser traits must agree.
Product / Fingerprints
A browser identity is a coherent device, not a string.
Undetect resolves device identities before launch so OS, browser, graphics, locale, route, storage, and session state agree from the first measurement. The goal is not plausible-looking values; it is a profile that behaves like it belongs to the population it claims to represent, backed by millions of fingerprints per month across Windows, macOS, and Android.
identity resolver
Input constraints
os: Windows country: us timezone derived languages derived
4.2M
Windows
10, 11, Server 2022
2.8M
macOS
13.x, 14.x, Apple Silicon
3.5M
Android
12, 13, 14
Resolved before launch
Pre-launch / Coherence resolution
Persistent / Identity continuity
Session sync / State continuity
Unlimited / No per-fingerprint fee
847
OS versions
2,341
Browser builds
156
Device classes
94
Regions
412
GPU variants
Launch contract
Identity is resolved before the first page can measure it.
The docs expose the important distinction: customers provide inputs, not a brittle final fingerprint. The launch system validates those inputs, fills the missing dimensions, and returns the effective profile for inspection.
fingerprint launch state
UD_FINGERPRINT_JSON
Constrained generation
Provide partial inputs such as OS, country, timezone, languages, or public IP; the fingerprint API validates them into a complete coherent profile.
UD_FINGERPRINT_FILE
Sticky device identity
Read and write a fingerprint file so a specific device profile can be reused across separate browser sessions.
UD_FINGERPRINT_UPDATE
Automatic refresh
Let cached profiles refresh as browser versions and high-entropy surfaces age, or disable writes when a static fixture is required.
Undetect.getFingerprint
Effective profile inspection
Retrieve the full profile that actually launched, including fields derived from defaults, route resolution, and backend validation.
Coherence model
Plausibility is measured across surfaces.
Most failures come from treating a fingerprint as a list of editable values. Real systems evaluate behavior, distribution, continuity, and change over time.
Browser and engine behavior
Version distribution, API behavior, feature exposure, and execution semantics are part of the identity.
Rendering and graphics
Canvas, WebGL, GPU, media, and font outputs need to match the device profile instead of standing apart.
Locale and network context
Language, timezone, region, route, and repeated account history are evaluated together by modern systems.
Storage and permissions
Cookies, local storage, permissions, and browser state are continuity signals, not incidental implementation details.
Change over time
A profile that never evolves can become just as suspicious as a profile with an obvious mismatch.
Resolver flow
Minimal hints become a full launch profile.
Customers should not have to specify hundreds of parameters. The resolver expands minimal constraints into a coherent profile before the browser starts, which avoids early measurements seeing the wrong state.
pre-launch resolution
01
Provide constraints
Start from minimal hints such as operating system, region, screen class, and optional device class.
02
Resolve the full profile
The resolver expands those hints into a cohesive browser, device, graphics, locale, and runtime profile before launch.
03
Launch coherently
Identity is present from the first browser measurement, avoiding late patch contradictions.
04
Persist and evolve
Returning identities keep continuity while surfaces update over time so profiles do not freeze into outliers.
No inputs
Stealthium requests a new randomized persona for the launch.
Partial inputs
Inputs such as Windows + country are expanded into a full profile before the browser opens.
Sticky file
A fingerprint file acts like a device identity record and is refreshed when surfaces age.
Synced profile
Cookies and browser state move with the identity so returning sessions behave like returning devices.
Continuity
State is part of identity.
Persistent workflows need more than reusable JSON. Cookies, storage, permissions, session artifacts, and controlled surface evolution all affect whether a returning identity looks real.
Persistent identities
Tie a fingerprint to a specific identity when returning-user semantics or authenticated workflows require continuity.
Session Sync
Back up cookies, relevant storage, session data, and the associated fingerprint JSON for deterministic resumption.
Automatic evolution
Refresh fingerprints as browser, platform, and device distributions move so long-lived profiles stay plausible.
Optional SDK
Capture profiles from your own user population when exact alignment matters more than generic realism.
Unlimited fingerprints
Fingerprints are included at no extra cost because identity coherence is a prerequisite for reliable operation.
UD_SYNC_REMOTE
Remote profile storage
Use an rclone-backed remote such as object storage to download the user data directory before launch and upload it after close.
UD_SYNC_FILENAME
Business-keyed sessions
Name synced profiles with a reference id or metadata value so browser state maps cleanly to your own identity model.
UD_SYNC_AUTO_VACUUM
Keep the useful state
Retain cookies, local storage, IndexedDB, and relevant profile data while stripping files that only add size and sync latency.
Undetect.setConfig
Conditional upload
Toggle profile upload at runtime after deciding whether a session produced valid state worth preserving.
Evaluate identity coherence under your real constraints.
Test pre-launch resolution, persistent identities, Session Sync, and automatic profile evolution against the flows where mismatch currently causes blocks or challenge escalation.