A browser can lie about what it is. Its connection can't.
A script can pass itself off as Chrome with one line of code. What it can't change so easily is how it builds the connection. Connection Fingerprint is called from the user's browser and returns the TLS fingerprint, the header fingerprint, the approximate location and two persistent identifiers (cookie and ETag). Everything comes signed by VU so your backend can verify it.
Real browserThey match
Security backed by certifications and independent testing
ISO/IEC 27001:2022
Information security management
ISO/IEC 27017:2015
Security for cloud services
Headers are controlled by whoever connects
A script posing as a modern browser sends the same user-agent as a real person. On top of that, identifiers stored in the browser disappear as soon as someone clears their cookies or uses private browsing. If your risk control relies on what the device says about itself, a well-disguised bot gets through with no trouble and a returning customer shows up as new.
- The connection responded✓ 200
- The user-agent claims to be a browser✓ Chrome
- The headers arrived complete✓ present
- Does it connect like a browser?GREASE "0"
Signed connection signals, ready for your risk engine
Connection Fingerprint gets its signals from the connection itself: the TLS fingerprint, the header fingerprint, the approximate geographic location and two persistent identifiers (cookie and ETag). It doesn't require an SDK or run code on the client. It doesn't decide for you either: it delivers signals and your risk logic defines what to do with them.
Case 01
You already have a risk engine
You don't have to change anything that already works. You just add one more signal, with a call from the browser and a verification in your backend.
Case 02
You want to recognize returning devices
The cookie lasts a year and the ETag usually persists even if the user clears their cookies. If one is renewed and the other isn't, that tells you something too.
Case 03
You suspect bots posing as browsers
You compare what the client declares with the way it connects. If the user-agent says Chrome but the handshake isn't Chrome's, someone is lying about what they are.
Three connection layers in a single response
The call leaves the browser and goes through three layers. What comes back is a signed response, with the identifiers to recognize the device next time.
The call leaves the user's browser GET /
TLS fingerprint (JA3)
version, ciphers, extensions and curves
tlsFingerprintHashHeader fingerprint
order and presence, as well as content
headerSignatureApproximate location
country and region, with their accuracy radius
geoDataA signed response comes back
With the identifiers to recognize the device next time.
- cookie · 1 year
- ETag · survives clearing
- signature · RSA 4096
What each response brings
Consistency across signals
The most revealing thing is whether all the fields tell the same story. No signal is enough on its own: the value lies in combining them with your own context.
Two identifiers, two lifespans
The cookie disappears when the user clears it; the ETag lives in the HTTP cache and usually persists. It's best to store both, linked to the account.
A signature you verify
The response goes through the browser before reaching your backend. The 4096-bit RSA signature lets you confirm nobody altered it along the way.
No SDK or tracking JavaScript
It doesn't run code on the client or depend on browser APIs that privacy modes tend to block. It's just an HTTP call.
One call from the browser and one verification in your backend
Unlike the other VU Cloud Services APIs, which are called from your server, this call is made from the user's device, because the fingerprint describes precisely that connection. The browser sends the response to your backend, which verifies the signature before using the data.
| Element | How it works |
|---|---|
| GET / | The fingerprint of the current connection, with the signature. Called from the browser |
| GET /publicKey | The RSA public key to verify signature. You request it once and cache it |
| GET /version | The service version |
| Authentication | None on /, /publicKey or /version: the browser has to be able to call them. What protects the integration is the signature verification |
| Setup | VU adds each environment's origins (scheme, host and port) to its CORS list before the first call |
| Base URL | https://fingerprint.api.vusecurity.com |
| Output | userData (TLS fingerprint, headers, headerSignature, cookie, etag, geoData, ip) and signature |
const res = await fetch("https://fingerprint.api.vusecurity.com/", {
credentials: "include" // without this, the fp cookie doesn't travel
});
// The response goes to your backend as is, without reordering anything.browser user-agent + GREASE "0"An automated client in disguise. You cross-check it with the header order.known hash + cookie and etag newA recognizable device that lost its state.same cookie + hash differentA browser update, or a stolen cookie. You look at the time window and the origin.
// 1. First of all, the signature, over the raw body.
if (!verifySignature(rawBody, publicKey)) return notVerified();
// 2. Only then, the signals. None of them decides alone.
const d = JSON.parse(rawBody).userData;
const inconsistent =
userAgentClaimsBrowser(d.headers) &&
d.tlsFingerprintSslGreased === "0";
// 3. The hash groups clients; it never authenticates a person.Without credentials: "include", persistence is lost silently
If the call doesn't include credentials, the cookie is neither sent nor stored and the service issues a new identifier on every visit. The response still arrives with 200 and every field present, so nothing warns you that you lost half the value.
And never call it from your server on the user's behalf: it would return your backend's fingerprint, identical for all your users.
What needs to be ready before the first real user
| Aspect | What to check |
|---|---|
| Origins | The development, testing and production domains, registered with VU |
| The call | Made from the client, always with credentials: "include" |
| The signature | The response body reaches the verifier unmodified, and the verifier uses the algorithm agreed with VU* |
| Location | Every geoData field is treated as optional and interpreted together with its accuracyRadius |
| If it doesn't respond | Your risk assessment has a fallback plan and keeps working with fewer signals, without going down |
*Before implementing the verification, confirm with VU the hash algorithm and how userData is serialized. If the object is re-serialized in a different format, the signature fails even though the data is authentic.
Start by talking to VU
Connection Fingerprint doesn't use an API key: VU enables it for the domains you'll call it from.
- 01You talk to a VU expertto contract the service
- 02
You send your originsone per environment: scheme, host and port
- 03
VU registers themin its CORS list, before the first call
- 04
You call GET / from your sitewith credentials: "include"
- 05
You verify the signature in your backendwith the key from GET /publicKey
- 06
You use the signals in your risk enginetogether with your own context
Frequently asked questions
You already know what the device says. Now see how it connects.
Talk to VU and add the connection fingerprint to your risk engine.