Teams that want to self-host fraud detection usually give some mix of five reasons: their users’ data shouldn’t go to a vendor, ad blockers strip the vendor’s script, per-call pricing punishes growth, decisions have to be explainable, and they don’t want to depend on someone else’s uptime. All five are legitimate. But they are different problems, and only some of them require running the service yourself.
This post takes each reason, says what it actually needs, and checks whether a managed service can meet it. Prynt is a managed service, so we’ll say plainly where it fits and where it doesn’t.
1. “Our users’ device data shouldn’t go to a vendor”
This one splits in two, and the split decides everything.
A rule forbids it. A regulator, a sector law or a customer contract says device signals may not leave your infrastructure, or may not leave a given country. Then a managed service is out, whatever its features. Self-host, or pick a vendor that processes inside that boundary. Prynt processes in the United States only today, on servers it operates, so it is out for any “must stay in country X” rule other than the US. Self-hosting for data residency goes through how to read these rules.
It’s a preference for less exposure. That’s a data-minimization goal, and it can be met by controlling what you send and who can read it:
- Attach your opaque user id as
linkedId, never an email. - Gate identification on consent with
requireConsent: true; the agent also honors Global Privacy Control by default. - Turn on sealed results so the browser gets an encrypted blob your server opens.
- Rely on plan retention windows enforced daily, plus erasure by
visitorIdorlinkedId. - Put it under a DPA and check the sub-processor list on the trust page.
Self-hosted vs SaaS: what you actually control walks through each of these and their limits, including the main one: in Prynt’s shared cloud, IP addresses are stored in full today.
2. “Ad blockers strip the vendor’s script”
This is a real problem. Blocklists target well-known fingerprinting domains, and the sessions that run aggressive blocking skew toward the ones you most want to see. A detection model that never runs on the attacker’s session is worth nothing.
The fix is first-party serving, not self-hosting: load the agent and send its calls through your own domain. With Prynt’s Cloudflare Worker (download it from /sdks), the agent is served same-origin under /__prynt/:
<script src="/__prynt/agent.js"></script>
<script>
Prynt.load({ apiKey: 'pk_live_…', endpoint: location.origin + '/__prynt' })
.then((prynt) => prynt.identify({ tag: { action: 'pageview' } }))
.then(({ requestId }) => { /* send requestId with your form */ });
</script>
If you don’t use Cloudflare, any reverse proxy can do the same: route /__prynt/agent.js to https://api.pryntid.com/cdn/prynt.umd.js and /__prynt/v1/ to https://api.pryntid.com/v1/, and forward the visitor’s IP with the first-party proxy secret from the console so IP signals still describe the visitor, not your proxy. First-party agent serving has the details, and the nginx gate covers blocking at the proxy.
3. “Per-call pricing punishes us as we grow”
Also real, and also not a hosting problem: it’s a pricing-model problem. Metered pricing bills you for every call, including the ones bots trigger during an attack, which is exactly when you can least afford to stop checking. FingerprintJS pricing explained shows how that adds up.
Prynt uses flat monthly plans with an identification quota (pricing). There is no per-call overage: at the quota, identification returns 429 quota_exceeded until the month resets or you upgrade, and Enterprise removes the quota. So a bot flood can’t run up the bill, but it can use up your quota; leave headroom and stop obvious junk at the edge.
Self-hosting changes the cost shape to servers plus people. It only comes out cheaper when you already have the team, and when you count the work of keeping detection current, which is the cost teams most often leave out. Build vs buy device intelligence models both sides.
4. “We have to explain our decisions”
A fraud decision that blocks a real customer has to be defensible, to the customer and sometimes to a regulator. What that usually needs is per-decision reasoning: which signals fired and why the score came out as it did.
A managed service can provide that. Each Prynt decision carries a suspect score, reason codes and the signals behind them, and you can add your own rules, tune risk weights and feed outcomes back. What it can’t give you is the code: Prynt is not open source. If your requirement is source-level auditability, or changing how a signal is computed, you need code you own, either your own build or an open-source library plus the server side you write around it.
5. “We don’t want to depend on a vendor”
This reason is honest and a managed service can’t make it go away: you depend on its uptime, its latency and its roadmap. What you can control is how much that dependency hurts.
- Fail open. A slow or unreachable fraud check should never block a real signup. Set a short timeout and treat “unknown” as its own outcome:
// Fail open: if Prynt is slow or unreachable, decide later instead of blocking.
async function checkDevice(requestId) {
if (!requestId) return { decision: 'unknown' };
try {
const res = await fetch(`https://api.pryntid.com/v1/events/${encodeURIComponent(requestId)}`, {
headers: { Authorization: `Bearer ${process.env.PRYNT_SECRET_KEY}` },
signal: AbortSignal.timeout(1500),
});
return res.ok ? await res.json() : { decision: 'unknown' };
} catch {
return { decision: 'unknown' }; // e.g. create the account, hold the free credits
}
}
- Latency. Prynt’s API runs in the United States. Identify in the browser before the user submits, so the round trip overlaps with typing, and keep the server check to one
GET. - Lock-in. Keep the policy in your code (thresholds, what “block” means for your product) and store your own decision with the reason, so the provider is an input, not your system of record.
If a vendor outage on your login path is unacceptable even with fail-open, that’s a real argument for owning the service.
When the reasons do add up to self-hosting
Self-hosting is the right call when:
- A law, regulator or contract forbids sending device signals to a processor, or out of a country your vendor doesn’t process in.
- You need processing in a region the vendor doesn’t offer. For Prynt today, that is anywhere outside the US.
- The system must run without outbound calls.
- Detection is your product, and you have the people to run, patch and update it.
Then be ready for what it involves: deploying and upgrading the service, an on-call owner for a check on your login path, scaling under attack traffic, and keeping detection current as evasion tools change every few weeks. That last part never ends.
Where Prynt fits
Prynt is a managed cloud service in the United States, with a free tier. It answers reason 2 (first-party serving) and reason 3 (flat pricing) directly, reasons 1 and 4 in part (data controls and per-decision reasoning, not a different region or the code), and reason 5 only through how you integrate it. If reason 1 is a hard rule for you, or you need reason 4 at the code level, self-host. Otherwise start with the docs.
Frequently asked questions
Is self-hosting fraud detection more work than using a managed service?
Yes. You take on deploying, patching, monitoring and scaling the service, and keeping detection current as bots and anti-detect browsers change. That work is worth it when a rule forbids sending device signals to a vendor, or when detection is a core part of your product. Otherwise most of the reasons teams give can be met without it.
Does self-hosting improve fraud detection accuracy?
Not by itself. What improves coverage is serving the agent from your own domain, so ad and tracker blockers don’t strip it. A managed service can do that too: Prynt’s Cloudflare Worker, or your own reverse proxy, serves the agent and the API same-origin.
When is a managed service the better choice?
When no law or contract forbids sending device signals to a processor, your required processing region is one the vendor offers, and you would rather spend engineering time on your product than on running detection. Check the vendor’s controls (consent, sealed results, retention, erasure, DPA) against your needs first.
Write down which of the five reasons you actually have, and whether each is a rule or a preference. Rules about where data may go decide the question on their own. Preferences can usually be met by a managed service configured well. For the detailed comparison, read self-hosted vs SaaS fraud detection, and see the device fingerprinting overview.
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.