To understand what a website learns about its visitors, it is not enough to inspect the HTML source or check whether cookies are enabled. Information is exposed at several layers: through the network connection, HTTP requests, data available to JavaScript, and the user’s own actions. It is important to distinguish what a site could obtain, what it actually received during a particular visit, and what the browser or an audit tool merely suggests. For example, a loaded script may be able to read browser characteristics, but its presence alone does not prove that every value it reads is sent to a server.
For a practical audit, open the browser’s developer tools, select Network, and start recording before loading the page. After reloading it, inspect requests not only to the main domain but also to third-party addresses, such as analytics providers, ad services, CDNs, widgets, and bot-protection systems. For each request, check the URL, query parameters, method, headers, cookies, and request body. Then repeat an action on the page—a search, a button click, or a form submission—and compare the requests that appear. Developer tools let you inspect request and response headers and contents, as well as the Initiator chain, which shows what triggered a request.
Use harmless test values for this audit, not real passwords, personal messages, or documents. If a string entered into a form appears in the body of a request to a particular domain, that is direct evidence that the string was transmitted to that domain. If a request goes to a third-party domain, that service also receives the relevant request data, although the request alone does not show exactly how the company will process or retain it. An exported HAR file may contain cookies, tokens, URL parameters, and form contents, so inspect and sanitize it before sharing.
The next layer is JavaScript and what is known as browser fingerprinting. Page scripts can use browser APIs and CSS to obtain characteristics such as language, time zone, window dimensions, graphics capabilities, available fonts, and supported features. Any one characteristic may be shared by millions of people, but a combination of characteristics can make a browser more distinguishable. To audit this, compare the Sources panel with the network log: identify which scripts access browser properties and check whether they initiate requests. Do not conclude that data was “stolen” merely because a script or API is present. The strongest evidence of transmission is a specific request containing the relevant value or identifier.
Cookies and other storage mechanisms also affect anonymity, but they work differently. A cookie may be attached automatically to requests that match its domain and settings. Data in localStorage, sessionStorage, and IndexedDB is not usually sent with every request automatically, but a page script can read it and transmit it. Check Storage or Application, compare the state before and after a visit, and then look for newly created identifiers in network requests. Deleting cookies does not necessarily prevent recognition: research presented at WWW 2025 found evidence that fingerprinting can be used for tracking across sessions and can affect advertising mechanisms even after cookies have been cleared.
The difference between an ordinary website and an onion service begins with the network route. When a regular browser connects directly to a conventional website, the site sees the IP address from which the connection arrived. When the same site is accessed through Tor, it generally sees the IP address of a Tor exit relay rather than the visitor’s original IP address. Tor does not hide information that the user enters or sends at the application layer: account names, form contents, cookies, URL parameters, and browser characteristics can still be disclosed to the site. Changing the network route therefore protects one layer—the source network address—but does not prevent the website from receiving application-level data.
An onion service uses a different route: the connection remains within Tor and does not pass through a conventional exit relay into the public internet. As a result, the onion service does not receive the visitor’s original IP address through a direct connection, and the visitor does not learn the server’s ordinary network location. At the web-application layer, however, the difference is much smaller: an onion site can still receive HTTP headers, cookies, request parameters, form data, and information sent by JavaScript. In other words, an onion address changes the network architecture and conceals the parties’ network addresses, but it does not make browser requests invisible to the site itself.
Tor Browser also aims to make browsers less distinguishable by standardizing some characteristics and limiting certain ways of obtaining unique combinations of parameters. This matters for anonymity: if rare characteristics set a browser apart from a larger group, websites and third-party trackers may find it easier to link visits. This protection does not mean that all users look exactly alike or that fingerprinting is impossible; the goal is to reduce the number of distinguishable combinations. For that reason, compare a regular browser and Tor Browser as two different profiles. Avoid manually changing Tor Browser settings or adding extensions, which can make its configuration more unusual.
There is another risk that developer tools do not directly measure: analysis of traffic patterns. Even when a connection’s contents are encrypted, an observer in some threat models may see characteristics of the transmission—such as its volume and timing—and try to infer which site was visited. A research paper on the fingerprintability of onion services examined 482 onion sites and emphasized that its results applied to a particular dataset and measurement period, not as a permanent assessment of all onion sites. This is a different kind of analysis from inspecting HTTP requests in a browser: it concerns observable network traffic and does not automatically reveal a visitor’s identity.
When comparing a regular browser, Tor Browser, and an onion site, perform the same actions in clean profiles and record the browser versions, date, and test conditions. For a conventional website, compare a direct connection with a Tor connection; separately test the onion version, if the site actually has one. Record the request domains, headers, cookies, request bodies, initiators, and storage changes. Do not confuse the remote server’s IP address shown in developer tools with the source IP address seen by the site; they are different addresses. And do not equate the finding that “this browser has an unusual combination of characteristics” with the conclusion that “the site identified the user.” That conclusion requires additional evidence, such as logging into an identifying account, reusing an identifier, or submitting information that reveals the user’s identity.
Finally, developer tools primarily answer the question, “What did this tab send to the site and third-party domains during the observation?” They do not reveal server logs, internal processing, or data-retention periods, and they do not provide a complete picture of browser telemetry unrelated to the open page. A sound audit should therefore state precisely which browser attribute was sent, to whom, in which request, after what action, and how it could link visits. For a conventional website accessed through Tor, the main change is the network address visible to the site; for an onion service, it is the absence of a conventional route through the public internet. In both cases, data disclosed to the application and the user’s behavior remain important factors in anonymity.
Escribir Únete para participar en la discusión.
as always another great article