VU Cloud Services

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

The problem

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"
Our solution

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.

Key features

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 /

Layer 01 · TLS

TLS fingerprint (JA3)

version, ciphers, extensions and curves

tlsFingerprintHash
Layer 02 · HTTP

Header fingerprint

order and presence, as well as content

headerSignature
Layer 03 · Network

Approximate location

country and region, with their accuracy radius

geoData

A 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.

The integration

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.

ElementHow it works
GET /The fingerprint of the current connection, with the signature. Called from the browser
GET /publicKeyThe RSA public key to verify signature. You request it once and cache it
GET /versionThe service version
AuthenticationNone on /, /publicKey or /version: the browser has to be able to call them. What protects the integration is the signature verification
SetupVU adds each environment's origins (scheme, host and port) to its CORS list before the first call
Base URLhttps://fingerprint.api.vusecurity.com
OutputuserData (TLS fingerprint, headers, headerSignature, cookie, etag, geoData, ip) and signature
RequestFrom the browser
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.
The decision ruleYour backend
// 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.

Before going to production

What needs to be ready before the first real user

AspectWhat to check
OriginsThe development, testing and production domains, registered with VU
The callMade from the client, always with credentials: "include"
The signatureThe response body reaches the verifier unmodified, and the verifier uses the algorithm agreed with VU*
LocationEvery geoData field is treated as optional and interpreted together with its accuracyRadius
If it doesn't respondYour 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.

VU times out · degrades, stays upBrowserVUYour backendRisk enginesignature verifiedcredentials: includesignaturesignals
This service generates personal dataIP address, approximate location and persistent device identifiers. Under the GDPR, the LGPD or equivalent regulations, using them requires a legal basis, informing the data subject and defining a retention period. Involve your legal team before going to production and store only what your risk engine actually uses.
How you start

Start by talking to VU

Connection Fingerprint doesn't use an API key: VU enables it for the domains you'll call it from.

  1. 02

    You send your originsone per environment: scheme, host and port

  2. 03

    VU registers themin its CORS list, before the first call

  3. 04

    You call GET / from your sitewith credentials: "include"

  4. 05

    You verify the signature in your backendwith the key from GET /publicKey

  5. 06

    You use the signals in your risk enginetogether with your own context

Frequently asked questions

No. It's one more signal for the risk engine you already have. It coexists with your current provider and with any other VU Cloud Services service.
Because the fingerprint describes the user's connection. If the call came from your server, you'd get your own server's fingerprint, not that of the device you want to assess. So that nobody can alter the response along the way, VU signs it and your backend verifies it before using it.
Not in the browser: the call is authorized based on the origins VU registers, so you don't expose any key on the client. To verify the signature in your backend, you only need the public key VU gives you.
No. The TLS fingerprint describes how a browser or a tool connects, and many users with the same browser share the same fingerprint. Its value lies in comparing it with what the client declares and combining it with the persistent identifiers and your own context.
It's approximate: it's derived from the IP address and is usually useful at the country or city level, not the street address. Each response includes an accuracyRadius that indicates the margin of error. A VPN or a proxy can show a location different from the real one.
The IP address, the approximate location and two persistent device identifiers (cookie and ETag). Under the GDPR, the LGPD or equivalent regulations, using them requires a legal basis, informing the data subject and defining a retention period. We recommend storing only what your risk engine actually uses.

You already know what the device says. Now see how it connects.

Talk to VU and add the connection fingerprint to your risk engine.