If your fraud rules read a value the browser produced and sent you, you are trusting the browser. A tamper proof device fingerprint is not a value nobody can influence; it is one where influence leaves evidence your server can check before any decision runs. That distinction matters more than the signal itself, because the cheapest attack on device-based controls is not a clever spoof. It is editing the payload.
Most teams find this after a rule stops firing. The dashboard looks fine, the agent still loads, and the numbers move for reasons nobody can explain. Nothing is broken in the collection layer; the gap is that the payload arrives as an unverified claim.
This post walks the mechanism end to end: what the client can change, what signing and server verification actually buy you, and how to fail closed on a bad payload without locking out the customers who pay you.
A signal you did not verify is a claim, not a fact
Fingerprint values are computed in the browser, and the browser belongs to whoever is using it. An override on navigator, a patched canvas return, a replayed request body from a captured session, an automation framework that never touches the real DOM — these are client-side facts about a client-side environment.
That is architecture, not a flaw in any particular product. The useful question is not “can this value be changed?” It is “if it changes, will I know before the rule fires?”
Separate tampering from unusual but honest setups
Some of what looks like tampering is a privacy extension, a corporate proxy, an old browser, or a QA emulator. Treat integrity as evidence, not as a verdict on the person. A payload that fails verification tells you about the transport; linkedId and accountsOnDevice tell you about the account.
Signing turns an editable payload into a checkable one
Signing does not make a payload unforgeable. It makes forgery specific: the signature matches the bytes you received, or it does not. Combined with a server-issued nonce, the check also rules out replay, and the cost of producing a convincing payload rises from “edit a JSON field” to “reproduce the collection path inside a short window.”

Prynt returns sealed results alongside every requestId, so your server can verify what it received before a handler reads a single attribute. The important design choice is yours: verification lives in one place, and the rest of the application never sees an unverified payload.
Verify raw bytes, not a re-parsed object
The most common implementation bug is parsing the body and re-serializing it before verification. Key order changes, whitespace disappears, and a valid signature fails. Read the raw body, verify, then parse.
// Pseudocode: verify before any rule reads the payload
const nonce = issueNonce(req.session.id); // single use, short TTL
const raw = await readRawBody(req); // exact bytes, as sent
const check = verifySeal({
body: raw,
signature: req.headers["x-prynt-signature"],
keyId: req.headers["x-prynt-key-id"],
nonce,
publicKey: publicKeys[req.headers["x-prynt-key-id"]],
});
if (!check.ok) return decide("challenge", check.reasonCode);
const signals = check.payload; // trusted only after this line
Plan for key rotation and agent versions
Send a key identifier in the header so you can hold two public keys during a rotation window and retire the old one on a date you choose. Do the same for agent versions: publish a minimum supported version, log the version on every payload, and give yourself an overlap period before you reject older ones.
Fail closed on purpose, not by accident
Failing closed means an unverified payload takes the restrictive path instead of the permissive one. It does not mean blocking everyone. Map each failure to an action:
- Missing or invalid signature — challenge on low-risk surfaces, block on account recovery, payout changes, and trial extension.
- Expired or reused nonce — re-run the agent once, then challenge if it fails again.
- Unknown key id — retry with the previous public key, then challenge.
- A payload that cannot have been produced in one session — raise the risk score and keep the
requestIdon the account for support.
Log the reasonCode with every outcome and alert on rate changes, not on single events. Support needs the requestId to answer “why was I asked to verify?” without guessing.
Turn integrity into decisions your policy can use
Once payloads are verified, visitorId and accountsOnDevice become inputs instead of hints. A failed verification is itself a signal, and it should flow through the same allow / challenge / block surface as every other one — same reason codes, same dashboards, same review queue. A separate integrity pipeline that nobody watches is how tampering goes unnoticed for a quarter.

Start narrow: verify on signup, login, and password reset, where account abuse begins. Add surfaces once the reason codes are boring.
FAQ
Can a valid signed payload be replayed?
Yes, if you verify the signature alone. Bind every payload to a single-use nonce with a short lifetime and reject duplicates on the server.
Does signing replace fingerprint signals?
No. It is evidence about the payload, not about the person. You still decide from visitorId, accountsOnDevice, Smart Signals, and your own account history.
What if verification fails for real customers?
Read the reasonCode distribution before you tighten anything. Start with challenge on low-risk actions, watch the pattern for a week, then move specific failure modes to block.
Try it free
Create a Prynt account, drop the agent into a staging page, and verify a sealed result against your own key before you wire it into policy. That single step turns your fingerprint from an editable claim into something your server can stand behind.

Try it free
Prynt is device intelligence with a free plan: 5,000 identifications a month, visitor IDs with confidence and bot detection — no credit card. Upgrade to Pro for VPN, proxy, tampering and behavioral signals.