A JavaScript Math engine fingerprint test runs carefully chosen mathematical functions and looks for tiny, repeatable differences in floating-point results. Those differences can reflect the browser engine, operating system, math library or browser version. The result is a possible browser signal—not a name, a guaranteed unique identifier or proof that one specific engine produced it.
This guide shows how the signal works, how to run a small local test, how to interpret results responsibly, and what is still unknown about the popular “Math Engine Fingerprint Test” page.
What the “Math Engine Fingerprint Test” does
Scrapfly describes its page as a test of JavaScript Math precision intended to reveal differences between browser engines. It focuses on floating-point edge cases and names V8, SpiderMonkey and JavaScriptCore as examples of engines that may behave differently.
In practical terms, a page can call functions such as Math.acos(), Math.asin() or Math.tan() with fixed inputs, record the returned numbers and compare the resulting sequence with other browsers. A difference may be only in the last few significant digits, but a stable sequence of differences can help distinguish one implementation environment from another.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitches#1 Best Overall
The exact current Scrapfly implementation, its input set, its comparison database and its handling of results are not documented in the material available for this article. Its results area was shown as “computing…”, so no output from that page is independently verified here.
Why JavaScript Math results can vary
Approximation is allowed for many functions
The ECMAScript 2015 Math specification requires exact behavior for certain boundary cases but allows implementations latitude in how many familiar mathematical functions are approximated. Browsers can therefore use different algorithms or underlying libraries while still conforming to the language specification.
Variation can come from several layers:
- JavaScript engine: V8, SpiderMonkey and JavaScriptCore may choose different numerical routines or compiler paths.
- Operating system and math library: the same browser family can rely on different system libraries on different platforms.
- Browser version: an engine update can change an approximation or a rounding path.
- Hardware and execution path: implementation choices and processor behavior can affect intermediate calculations, although a script cannot safely infer a particular CPU from one value.
Functions commonly used to demonstrate this kind of latitude include Math.acos, Math.asin, Math.cosh, Math.expm1, Math.sinh and Math.tan. That list explains the general mechanism; it does not establish that every one appears in Scrapfly’s current page.
What the result means—and what it does not
It is one possible signal
Browser fingerprinting normally combines many observable attributes. EFF’s Cover Your Tracks explanation lists examples such as the user-agent string, screen characteristics, fonts, platform, language and canvas or WebGL hashes. A Math sequence can be added to that collection, but it is only one component.
Outdated Drivers Are Slowing You Down
One free scan finds every outdated or missing driver and matches the right update for your exact hardware.Free scan · exact hardware matchPC Slower Than It Used to Be?
A free scan shows the junk files, broken settings and background clutter dragging Windows down - then fixes them in one click.Free scan · Windows 10 & 11It is not personal identification
A matching sequence does not reveal your name, email address or account. It indicates that your browser environment produced the same measured values as another environment. Many people can share those values, and one person can produce different values after changing browsers, operating systems or versions.
It is not proof of a uniquely identified engine
Different engines can converge on the same rounded output, while one engine can produce different output across platforms or releases. A single observation therefore cannot establish “this is definitely V8” or any other exclusive conclusion.
Entropy claims need a defined sample
Scrapfly states that its approach provides “4-6 bits of entropy” and is difficult to prevent. Those are publisher statements, not independently established measurements in the available material: no method, population, dataset or validation procedure is supplied for that figure.
For historical context, Peter Eckersley’s PETS 2010 paper states: “We observe that the distribution of our fingerprint contains at least 18.1 bits of entropy.” That number describes the combined fingerprints observed in Eckersley’s study, not JavaScript Math results and not Scrapfly’s tool. The same paper reported 18.8 bits and 94.2% uniqueness for browsers with Flash or Java in that study subset; those are historical sample results, not current worldwide rates.
A separate 2011 experiment by Keaton Mowery, Dillon Bogenreif, Scott Yilek and Hovav Shacham involved 1,015 participants and examined JavaScript execution characteristics, including information related to browser version, operating system and microarchitecture. Its performance-based technique should not be conflated with a Math-precision test.
Run a transparent local Math probe
The following self-contained page lets you see exactly which functions and inputs you test. It does not claim to identify an engine; it produces a reproducible value sequence that you can compare between environments.
- Create a file named
math-probe.html. - Paste the code below and open the file in two or more browsers or browser versions.
- Save each displayed sequence with the browser name, version, operating system and date.
- Compare the full sequences, not one rounded value.
<!doctype html>n<meta charset="utf-8">n<title>JavaScript Math probe</title>n<pre id="out">Running...</pre>n<script>nconst cases = [n ["acos", 0.123456789],n ["asin", 0.123456789],n ["cosh", 1.23456789],n ["expm1", 0.123456789],n ["sinh", 1.23456789],n ["tan", 0.123456789]n];nconst results = cases.map(([name, input]) => {n const value = Math[name](input);n return { name, input, value, digits: value.toPrecision(17) };n});ndocument.querySelector('#out').textContent = JSON.stringify({n userAgent: navigator.userAgent,n resultsn}, null, 2);n</script>toPrecision(17) exposes enough decimal digits to make small differences visible for an IEEE-754 double. It is a display format, not extra accuracy. If two browsers print the same digits, that does not prove that every internal step was identical; it only means the displayed result matched.
Make comparisons meaningful
- Use identical input literals and the same script file.
- Run each browser in a fresh profile when extensions could alter page execution.
- Record browser version, operating system, architecture when known, and date.
- Repeat a run to check stability before comparing different environments.
- Keep the probe separate from user-agent, canvas or WebGL tests if you are studying Math behavior alone.
How to evaluate a published Math test
Before treating a result as evidence, ask five questions:
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
- Which signals are measured? Is the page Math-only, or does it also collect canvas, WebGL, audio or configuration data?
- What is the collection method? Are the functions, inputs, rounding and comparison rules published?
- What validation set exists? A claimed entropy value should identify its sample size, geography, dates and measurement procedure.
- Is the output single-signal or combined? A combined fingerprint cannot be credited entirely to Math precision.
- What happens to the data? Look for a clear statement about local processing, network transmission, retention and deletion.
The available material does not establish Scrapfly’s exact collection, transmission or retention practices. Do not infer them from the visual result page.
Common errors and misleading interpretations
| Symptom | Likely cause | What to do |
|---|---|---|
| Every browser prints identical values | The chosen inputs do not expose an implementation difference, or the values are rounded before display. | Use the full-precision display in the sample and test additional documented inputs. Identical output is a valid result. |
| Values change between repeated runs | The page is using nondeterministic inputs, changing state, or another script is modifying the test. | Use fixed literals, a fresh profile and the local code above. A deterministic Math call should normally be repeatable. |
| Only one final “score” is shown | The site may hash or classify a sequence instead of exposing raw values. | Ask whether the method and mapping table are published; do not treat an opaque label as an engine proof. |
| A result differs after a browser update | The engine, system library or approximation routine changed. | Record the exact version. Version changes are a reason to re-baseline, not evidence of user identity. |
| The page remains on “computing…” | A script error, blocked resource, unsupported browser feature or stalled network request may be involved. | Open developer tools, check the Console and Network panels, disable blocking extensions for a controlled run, and compare with the local probe. |
| A vendor advertises a precise entropy number | The number may be an estimate or marketing claim without a published sample. | Look for the population, collection date, method and validation results before citing it as a measurement. |
Privacy and defensive options
Fingerprinting defenses generally aim to make many users look alike or to reduce the number of exposed signals. EFF discusses Tor Browser, tracker-blocking tools and NoScript as examples, while noting that defenses are imperfect and can have usability or compatibility costs.
- Use a privacy-focused browser configuration when reducing fingerprintability is more important than site compatibility.
- Limit scripts on untrusted sites with a content-blocking or script-control tool, understanding that this can break application features.
- Keep browsers updated; privacy controls and implementation behavior change over time.
- Do not assume that changing one Math result defeats tracking if a site can still observe screen, font, canvas, WebGL and language attributes.
Or skip the browser setup
If your goal is to save a visual record of a test page or compare rendered results across URLs, ScreenshotNeo provides a website screenshot API and MCP server. It is not an engine-fingerprint measurement itself; it captures the page you request.
One GET request returns a PNG, JPEG, WebP or PDF. For a rendered test page, the cURL form is:
The Tool Desk
Outbyte Driver Updater FREEFix the driver behind crashes, sound loss and screen glitchesFind Drivers →Outbyte PC Repair FREERepair Windows errors before they cause bigger problemsFix Now →curl -G "https://api.screenshotneo.com/v1/shot" -d access_key=YOUR_API_KEY --data-urlencode url=https://stripe.com -o shot.webpSee the ScreenshotNeo documentation for parameters and response headers. The same request in Python is:
import requestsnr = requests.get("https://api.screenshotneo.com/v1/shot", params={"access_key": "YOUR_API_KEY", "url": "https://stripe.com"}, timeout=90)nopen("shot.webp", "wb").write(r.content)Node.js:
const q = new URLSearchParams({ access_key: 'YOUR_API_KEY', url: 'https://stripe.com' });nconst res = await fetch(`https://api.screenshotneo.com/v1/shot?${q}`);Before capture, ScreenshotNeo can accept cookie or consent banners and remove more than 60 known consent platforms, newsletter popups and chat widgets; each step can be disabled. Bot checks, CAPTCHAs, blank pages, timeouts, failed loads and cache hits are not billed, and response headers identify the page verdict and whether the request was billed. Its MCP server exposes take_screenshot, get_page_info and capture_pdf for Claude, Cursor and other MCP clients.
The Free plan includes 1,000 screenshots per month with no card. Paid plans start at $5 for 3,000 shots; every feature is included on every plan, and yearly billing provides two months free. Create a free ScreenshotNeo account to capture a test page without setting up a browser automation stack.
FAQ
How should I report a surprising Math difference?
Include the exact script, input literals, printed precision, browser and version, operating system, architecture when known, and a second run showing whether the value is stable. That record lets another person reproduce the observation without relying on an unexplained score.
Can a site combine this test with other fingerprinting?
Yes. A page can call Math functions alongside configuration, canvas, WebGL or other browser APIs. Treat the privacy policy and the code or documentation as separate questions from what the Math values alone demonstrate.
Frequently Asked Questions
How should I report a surprising Math difference?
Include the exact script, input literals, printed precision, browser and version, operating system, architecture when known, and a second run showing whether the value is stable. That record lets another person reproduce the observation without relying on an unexplained score.
Can a site combine this test with other fingerprinting?
Yes. A page can call Math functions alongside configuration, canvas, WebGL or other browser APIs. Treat the privacy policy and the code or documentation as separate questions from what the Math values alone demonstrate.
The Bottom Line
A JavaScript Math engine test can expose small implementation differences, but it is a narrow, probabilistic signal. Use published methods and reproducible raw values—not an unexplained entropy label—to decide what a result actually shows.
Recommended Free Tools
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
