All articles Fraud & ATO

Sealed Results Fraud API: Trust Device Data on Your Server

Engineer in a dark server room holding an encrypted device module under blue light

Most signup and checkout flows collect device and bot signals in the browser, then post the result to the backend as a JSON field the client can edit. A sealed results fraud API removes that dependency: the signal is computed and sealed on Prynt’s side, delivered as an opaque payload, and verified with your secret key before your code reads a single value. The browser still carries the envelope. It just cannot read it, and it cannot change it without breaking verification.

This post covers why client-supplied device data deserves distrust, what sealing actually changes, and how to wire verification into a route without turning every missing token into a blocked customer.

Where client-side device results break down

A typical implementation collects signals in the browser, decides “human” or “automation”, and sends that verdict along with the form: a hidden input, a header, a cookie, a field in the request body. All of those live on the attacker’s machine. DevTools and request tooling edit any of them in seconds, and the forged request reaches the same handler that creates the account.

The uncomfortable part is not the edit itself. It is that a forged request and a genuine one look identical in your logs, because both arrive as a well-formed field your code already trusts. Worse, a readable response tells an attacker exactly which signal fired, so they can retune their automation until the flags disappear.

Teams usually accept this tradeoff for latency and simplicity: compute in the browser, act in the same request. Sealing keeps the flow but moves the trust boundary to the place that can enforce it.

What a sealed result contains, and what it hides

With Prynt Identify, the outcome of the signals — automation and AI-agent checks, VPN, proxy and datacenter detection, tampering — is sealed into a payload bound to that visitor and returned to the browser as an opaque string. Your backend verifies it with the secret key, then reads the decision fields.

Translucent encrypted panel with an opaque unreadable side on a black background

Two properties matter here. Integrity means the payload cannot be altered without failing verification. Confidentiality means the client cannot read which signal fired, so probing for thresholds becomes guesswork. Together they turn device data from a client claim into a server-verifiable fact. For how the underlying identifiers are built, see device fingerprinting.

A verification flow you can ship

Keep the order strict: extract, verify, then apply policy. Never branch on unverified fields.

// Illustrative pseudo-code. Exact field names live in https://pryntid.com/docs
on POST /signup:
  envelope = body.sealed_result          # opaque, produced by Prynt
  result   = verify(envelope, secret = PRYNT_SECRET_KEY)

  if result.invalid or result.expired:
      return step_up("captcha")          # your policy, not Prynt's
  if result.decision == "bot":
      return block("automation_detected")
  create_account(body)

Three operational rules keep this boring in a good way. The secret key stays on the server and rotates on a schedule you control; it never ships in a browser bundle or a mobile app. Verification failure returns a distinct code so your dashboards can separate forged payloads from expired ones. And the server-side copy of the decision — visitorId, decision, reasons, requestId — is what you log and later reason about, not the raw envelope. The API reference for verification and error codes is in our docs.

Choose your failure mode per route

A missing, expired or invalid envelope is not an error state. It is a policy decision, and one policy will not fit every route.

Developer at a dark desk explaining a node diagram with a glowing lock

On account creation and free-trial starts, step-up is usually enough: a captcha or email verification keeps honest users moving while making automation expensive. On login, a risky or unverifiable device belongs in step-up territory, not in a silent allow. On low-risk reads, allowing the request and recording the gap is cheaper than blocking it.

Failing closed everywhere feels safer and is usually worse. A checkout that breaks whenever a script is blocked costs more than the accounts it prevents. The failure worth avoiding is the quiet one: allowing the request with no marker, so nobody can tell later how many unverified sessions reached production. Whatever branch you take, let the server decide.

Test the seal before you rely on it

Run three tests in CI against a staging secret. Tamper: flip one character of the envelope and confirm the route refuses it. Replay: resend a valid envelope after its lifetime and confirm expiry is caught. Absence: strip the field entirely and confirm your step-up path works end to end.

Then check quality, not just mechanics. A verifier that rejects forgeries but misreads genuine traffic creates friction you will blame on users. Accuracy explains how we measure detection quality, which is a better basis for tuning thresholds than intuition.

FAQ

Engineers in a dark room watching particles bounce off a translucent barrier

Is a sealed result the same as a device fingerprint?

No. The fingerprint is the identifier for the visitor or device. Sealing is about delivery and proof: who computed the result and whether it arrived intact. You need both, and they fail for different reasons.

What happens if the browser blocks the script or the envelope never arrives?

Your policy decides, and it should be explicit. Allow with a risk marker, step up, or block on high-value routes. Treat absence as a signal you measure, not as a technical error to ignore.

Can someone still replay a sealed result?

Only within the lifetime you accept. Check age during verification, keep lifetimes short, and rate-limit verification attempts per visitor and IP. Sealing prevents forgery; replay defense is your job at the edge.

Start with a real envelope

Prynt Identify’s free plan covers 5,000 identifications a month with no card, so you can verify a live envelope from your own backend and write policy around real responses instead of guesses. Compare what each plan includes, then create a free account at pryntid.com and unseal your first result server-side.

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.

Keep reading