CreepJS is a free, open-source browser fingerprinting page created by Abraham Juliot and launched in 2020, and it is probably the most scrutinised self-test in the antidetect and scraping world. This review treats it as a measuring instrument rather than a hurdle to clear: what its trust score, 'lies' count and headless percentages actually measure, where they can mislead, and how it compares with Pixelscan, Iphey and Browserleaks. Facts about the hosted page reflect its state in November 2026, and figures reported by vendors are labelled as such.
TL;DR
CreepJS — CreepJS is a transparent, free fingerprint diagnostic that is excellent at exposing inconsistencies and poor at predicting real-world detection.
| Pros | Cons |
|---|---|
| Open-source project with a public GitHub repository and a free hosted test page | No single pass/fail answer, so beginners can misread a nonzero percentage as a failure |
| Reports inconsistencies ('lies') and exposes the parameters behind its scores instead of a single opaque verdict | Measures JavaScript-visible signals only; TLS handshake fingerprints (JA3/JA4) and IP reputation are outside its scope |
| Dedicated headless section with '% like headless', '% headless' and '% stealth' readings | A clean score does not predict how a given anti-bot vendor will treat a profile |
| Shows a fingerprint ID and a 64-character fuzzy hash, which makes before-and-after comparisons easy | Look-alike domains such as creepjs.org make it easy to test on the wrong site |
| Useful as a stress test for antidetect browser profiles, hardened privacy browsers and automation setups | Scores shift with browser version and settings, and no independent benchmark of its accuracy is published |
CreepJS is an open-source diagnostic, not a pass/fail verdict
CreepJS is an open-source fingerprint analysis project by Abraham Juliot that launched in 2020. It runs entirely in the visitor's browser, collects signals through JavaScript, and presents them with a bias toward showing evidence rather than a headline grade. That design choice separates it from most checkers a casual user will meet.
As of November 2026 the hosted page reports a 'FP ID' and a 'Fuzzy' fingerprint hash (a 64-character string) and displays the computation time in milliseconds. Below those sit sections for the signal families you would expect: canvas, WebGL, audio, fonts, WebRTC and navigator properties. The WebRTC block, for example, lists host connection, foundation/IP, SDP capabilities, STUN connection and media devices. A separate Headless section reports '% like headless', '% headless' and '% stealth', along with platform hints for Chromium.
The practical consequence is that CreepJS rewards people who read it. A user hoping for a green tick will be frustrated, because the page is built around inconsistency detection, not approval. A QA engineer comparing two browser configurations will find that same behaviour more useful than a verdict, since every number has something behind it that can be inspected.
The official instance lives on GitHub Pages, not creepjs.org
The author's own hosted instance is at https://abrahamjuliot.github.io/creepjs/, and the source code is at https://github.com/abrahamjuliot/creepjs. Anyone searching for a CreepJS test will also see creepjs.org, a separate domain that markets itself as a browser fingerprint checker and IP risk analysis page, scans the browser on load and shows the fingerprint ID a website could compute along with the signals behind it.
Gologin's guide to CreepJS states that the only official project is the GitHub Pages one and calls sites like CreepJS.org knockoffs. That is a vendor's view, and readers should check it themselves: compare the page against the repository's README, look at who publishes each domain, and note that the GitHub Pages address sits under the author's account name. Whichever site you use, results from different instances are not guaranteed to be comparable, so pick one and keep using it when you compare configurations.
CreepJS derives trust from inconsistencies it calls lies
CreepJS reports both fingerprint uniqueness and a trust confidence, and the trust figure is based on inconsistencies, labelled 'lies', found in the fingerprint. This is the tool's central idea. Rather than asking how rare your browser is, it asks whether the things your browser reports agree with each other.
A 'lie' is a detected contradiction or sign of tampering: a function whose prototype has been altered, an API that returns values at odds with another API, or a user agent that claims one platform while other properties imply another. Anti-fingerprinting measures that overwrite properties in JavaScript are the classic way to produce lies, because the override often leaves traces that a native implementation would not. That is why a hardened or randomised browser can score worse than an untouched one, and it is the main reason the tool matters to people building spoofing setups.
The limitation is interpretive. A lie count of zero means CreepJS found no contradiction among the checks it runs; it does not mean no site can find one. A nonzero count means something differs from a stock browser, which is not always the same as 'a site would block you'.
Headless, like-headless and stealth percentages measure different things
The Headless section separates three readings: how much the browser resembles headless Chromium, how much it matches headless outright, and how much it looks like a stealth patch has been applied. Treating them as one 'bot score' is the most common misreading.
Gologin's published CreepJS test of its own profile offers a useful worked example, with the caveat that it is a vendor-run result and not an independent measurement. Gologin reports 0% headless, 0% tampering, 25% like-headless and 0 lies. The reading is straightforward: nothing identified as headless, nothing flagged as tampered, no contradictions, but a quarter of the like-headless heuristics still triggered. Those heuristics look for traits that headless builds tend to share, and a normal headed browser with some unusual settings can trip a few of them.
Gologin's own write-up also reports the same profile passing Pixelscan ('Consistent') and scoring 100/100 on Iphey, while CreepJS still showed the nonzero like-headless figure. The lesson applies beyond any one product. Checkers disagree because they test different things, and a nonzero line in CreepJS is a prompt to investigate, not proof of failure.
CreepJS sits between verdict tools and raw-data tools
Pixelscan and Iphey give a verdict, Browserleaks gives raw data, and CreepJS occupies the space in between. Pixelscan returns a consistency label such as 'Consistent', and Iphey returns a score out of 100. Both are quick to read and easy to share, but they compress many checks into one answer and show comparatively little of the reasoning.
Browserleaks sits at the other end. It offers separate, independent tests for individual leak vectors, such as WebRTC, canvas or fonts, and leaves interpretation to the user. CreepJS adds confidence levels and a lie count on top of visible parameters. You get a judgement, but also the material to argue with it.
The sensible workflow uses several of these together. A verdict tool answers 'does this look obviously wrong?', a raw-data tool answers 'what exactly is leaking?', and CreepJS answers 'does my configuration contradict itself?'. A profile that passes the first and fails the third has a problem that a green label would hide.
Automation checks reportedly cover Selenium, Puppeteer and Playwright
Gologin says CreepJS runs separate checks for the Selenium, Puppeteer and Playwright automation frameworks. The hosted page's Headless section, with its stealth and like-headless readings, fits that description, though the exact list of automation checks should be confirmed by reading the repository source instead of relying on a summary.
For automation users the useful pattern is differential testing. Run the page once in a manually driven browser and once under your framework with identical profile settings, then compare the headless block and the lie count. Differences between the two runs isolate what the framework itself exposes, which is a much cleaner signal than any absolute score.
A caution applies to anyone searching for how to bypass CreepJS. Stealth plugins and patches change what the page sees, but patches applied in JavaScript can themselves be flagged, which is what the 'stealth' percentage is for. Because the page changes over time, a patch that scores well today may not next quarter.
A clean browser can score worse than a configured one
Gologin says a clean browser with no anti-fingerprinting measures can struggle to score well on CreepJS. The mechanism is plausible. A stock browser exposes a fingerprint that may be quite unique, and uniqueness feeds the entropy side of the report, while a configured profile may blend into a larger population of devices.
That claim needs careful reading. Uniqueness and trust are different axes. A stock Chrome install on a common operating system typically produces few contradictions, which is good for trust, while its combination of fonts, hardware and screen values may still be rare. Meanwhile a heavily spoofed profile can have a common-looking fingerprint and still collect lies. When a result looks surprising, check which axis moved before drawing conclusions.
It is also worth remembering that the claim comes from a company that sells a configured browser. That does not make it false, but it is the sort of statement that should be reproduced with your own hardware, your own browser version and your own settings.
A good CreepJS score does not cover TLS fingerprints
CreepJS is JavaScript running inside the page, so it cannot observe the TLS handshake that happened before the page loaded. TLS client fingerprints such as JA3, and its successor JA4 published by FoxIO in 2023, are computed from the handshake itself, and Gologin's technical guide notes that major CDNs use JA4. A browser whose JavaScript environment looks flawless can still send a handshake that does not match the browser it claims to be.
The same goes for IP reputation, behaviour analysis, cookie history and request timing. None of these appear in a CreepJS result. For scraping and multi-account work, that makes CreepJS a necessary check and a poor sufficient one. A profile built on a flagged datacenter IP will not be rescued by 0 lies.
The honest framing is this: CreepJS tells you whether the browser's story is internally consistent. Whether a given site accepts that story depends on factors the page does not test.
Vendor-run CreepJS comparisons are single data points
Every CreepJS result a vendor publishes is one browser build, one machine and one moment, and the tool's output changes with all three. Gologin's reported result of 0% headless, 0% tampering, 25% like-headless and 0 lies is a fair illustration: it is a useful snapshot, but not a benchmark, and it comes from a company with a commercial interest in how the number looks.
No independent, third-party benchmark of CreepJS accuracy is published, and the tool's authors do not present it as a detection-accuracy standard. Browser versions matter too. A result taken on one Chrome major version can differ from one on the next, so any two screenshots from different dates or builds are not a controlled comparison.
If you want to evaluate antidetect products with CreepJS, run your own test on the same machine with the same proxy and the same browser version for each product. Free tiers make this cheap. According to Gologin's pricing page, the free plan includes 3 profiles with no time limit plus a 7-day trial of paid features, and Dolphin Anty's free plan also includes 3 profiles. Gologin's Professional plan starts at $9/month for 10 profiles. Those allowances are enough to run a repeatable CreepJS comparison before paying for anything.
Running the hosted test takes a minute; reading it takes longer
A CreepJS run starts when the page loads, with no input required. Open https://abrahamjuliot.github.io/creepjs/ in the browser or profile you want to examine, wait for the computation to finish, and note the FP ID, the fuzzy hash, the trust and lie readings, and the Headless block before scrolling into the detail sections.
For a controlled test, change one variable at a time. Run it with extensions disabled, then enabled. Run it on a fresh profile, then after applying your anti-fingerprinting settings. Reload to confirm the FP ID is stable within a session, and compare results across profiles that are supposed to look different. If two profiles meant to be distinct return the same ID, that is more informative than any percentage.
On the repository side, readers who search for creepjs github will find the source at github.com/abrahamjuliot/creepjs. Before relying on it, check recent commit activity, the license file, open issues and whether the hosted page matches the current code. The same applies to anyone searching for 'creepjs npm': look at the npm registry directly for the package name, publisher and last publish date, because a package with a similar name is not necessarily maintained by the repository's author. Treat any claim about npm availability, including in this review, as something to verify.
CreepJS is best used as a stress test, not proof of invisibility
CreepJS is the right tool when you want to find contradictions in a browser configuration, and the wrong tool when you want reassurance. Privacy-minded users can use it to see what a site could compute and whether a hardening extension is leaving telltale traces. QA teams building antidetect or automation setups get a free regression check they can run after every browser update.
Scrapers should use it as a first filter and nothing more, since TLS fingerprints, IP quality and behaviour decide most real blocks. Researchers get the most from it, because the open code and visible parameters make it possible to see why a number is what it is.
A browser fingerprint test of this kind answers a narrow question well. It does not tell you whether a profile will survive contact with a specific anti-bot system, and nobody should read a low lie count as a guarantee.
Verdict
CreepJS earns a strong 8.2/10 as a free, transparent diagnostic for people who will read its output and compare runs under controlled conditions. It suits QA engineers, researchers and anyone tuning an antidetect or automation setup; it does not suit readers who want a pass/fail answer or a guarantee against detection.
Frequently asked questions
What is CreepJS and who created it?
Is CreepJS.org the official CreepJS site?
What does the trust score in CreepJS mean?
What are 'lies' in CreepJS?
What is the difference between CreepJS and Pixelscan?
Can CreepJS detect Selenium, Puppeteer and Playwright?
Is CreepJS available on GitHub and npm?
Does passing CreepJS mean a browser profile is undetectable?
Why does a clean browser sometimes score poorly on CreepJS?
Sources
Comparisons
-

PlainProxies Alternatives 2026: Top Residential Proxy Providers
-
Gologin vs BitBrowser
-
Gologin vs Octo Browser
-
Gologin vs Dolphin Anty
-
Gologin vs GeeLark
-
Gologin vs NSTBrowser
-
Gologin vs 1Browser
-
Gologin vs SessionBox
-
Gologin vs Incogniton
-
Gologin vs Undetectable
-
Dolphin Anty vs Octo Browser
-
Gologin vs AdsPower
-
Dolphin Anty vs Multilogin
-
Gologin vs Multilogin
-
Gologin vs MoreLogin