Back to Knowledge Hub
Fingerprint

Cloudflare Turnstile: Signals and Privacy

What Cloudflare Turnstile measures, what a source archive reveals about browser signals, and where privacy controls stop short of a service decision.

BotBrowser Team

Documentation

Want the structured docs for Fingerprint?

This article lives in the editorial library. For step-by-step setup, reference material, and ongoing updates, jump into the docs section.

Cloudflare Turnstile privacy depends on more than whether a checkbox appears. Cloudflare describes small JavaScript challenges that inspect browser capabilities, alongside network signals named in its privacy notice. A historical research archive also records canvas, WebGL and audio operations inside a challenge frame, with important attribution limits. BotBrowser documents controls in the browser engine for these browser surfaces; it does not determine Cloudflare's classification or remove network context already available to a service. The useful distinction is between information a browser exposes, information a recorder actually observed, and a decision that remains on the server.

  • Turnstile's public documentation names computational challenges, API probing and browser behavior; its privacy notice also names IP address, TLS fingerprint, User-Agent header, sitekey and origin.
  • A February 2026 archive contains rendering-related events in a Cloudflare challenge frame. It is a historical sample, not a complete inventory of today's Turnstile deployments.
  • The research recorder generates some of its own API reads. Removing entries marked snapshot does not remove the getter events those snapshots trigger.
  • Three saved HTTP 200 responses establish transport observations. They do not establish token issuance, Siteverify acceptance or application permission.
  • Privacy protection requires both browser-surface controls and limits on collection, retention and reuse. Neither a clean fingerprint nor an absent checkbox establishes anonymity.

Contents

The signal path behind the widget

Cloudflare's Turnstile overview describes a sequence of small, non-interactive JavaScript challenges. The documented categories include proof-of-work, proof-of-space, probing web APIs, browser quirks and human behavior. These categories describe the service's approach; they do not publish a stable list of every property read on every request. Challenge selection can vary. An invisible presentation therefore says something about the interface, not that the browser supplied no environmental information.

Turnstile is also a distinct integration choice. Cloudflare says it can be embedded without placing the website's traffic behind its CDN. The underlying Challenge Platform is shared with other Cloudflare challenge products, but a Turnstile widget is not interchangeable with an interstitial Challenge Page or the Enterprise Bot Management product. A browser-side operation found in one archived challenge cannot be assigned to every Cloudflare service merely because the same vendor operates them.

The response-signal discussion covers a different question: what a client can conclude from the response it received. Signal collection comes earlier in the causal chain. A canvas read can be an input candidate; a challenge document is an output observation. Connecting the two requires evidence from the relevant request and execution context. A changed response alone cannot identify which browser measurement, network attribute or application policy contributed to it. The DataDome collection and privacy analysis separates current Tag declarations from historical collector and challenge evidence. The Akamai architecture analysis separates declared page-script behavior analysis from independent edge visibility and the subsequent customer response choice.

The local source material is pinned to research checkout 2b6e8f14b912737ae9d0c637a7336c31e0b9c743. Its 20260227/stock_145 directory contains a recorder, frame-separated hook output, captured flow requests and a summary dated February 27, 2026. The directory label identifies a Stock Chrome 145 sample. Reading these existing artifacts is static historical research: no current Cloudflare challenge execution, new acceptance test or BotBrowser comparison is claimed.

Historical recorder separates the parent frame, with 73 API events, from the Cloudflare challenge frame, with 148 API events and six canvas operations. Three POST records and a null recorded token remain separate evidence streams.

The frame split matters. In that saved sample, the parent-frame group has 73 API-call records and no canvas operations. The Cloudflare challenge-frame group has 148 API-call records and 6 canvas-operation records. Those are recorder counts, not counts of unique fingerprint attributes, independent security checks or bits of identifying information. Several records describe repeated calls, and the recorder itself supplies some of them. Their value is preserving where observations were collected before interpreting what they mean.

The diagram follows inject.js request handlers and per-frame collection, then the archived JSON structure. It deliberately keeps network captures beside the frame data rather than drawing every API call into an asserted transmitted request body. The archive does not establish that every recorded value was serialized, sent unmodified, retained or used by a model. A browser operation, an outgoing request and server processing are separate evidence boundaries even when they occur close together in time.

The privacy consequence is still concrete. A third-party challenge frame creates an execution context in which browser-exposed properties can become inputs to security checks. Network requests to its operator also create an observation relationship outside the site's own application code. Assessing that relationship requires the vendor's declared purposes as well as source observations. Neither the absence of a visual puzzle nor a large recorder count answers the purpose, retention or onward-use questions by itself.

Browser surfaces recorded in the archive

The saved challenge-frame apiCalls include canvas serialization, canvas pixel readback, WebGL parameter queries and offline audio rendering. The recorder source supplies the meaning of those event labels: inject.js:247-326 wraps the relevant native methods and records selected arguments or results. This is stronger evidence than a general list of APIs the instrumentation could hook. It remains weaker than a caller-attributed trace that identifies the exact vendor function responsible for every invocation.

Canvas: a rendered result rather than a camera image

Two canvas.toDataURL events and one ctx2d.getImageData event appear in the challenge-frame records. Canvas serialization produces a representation of an existing canvas; pixel readback returns pixels from the specified canvas region. These method names do not imply access to the user's display, camera or unrelated browser tabs. The recorder also keeps 6 drawing-operation entries, whose count should not be mistaken for the complete drawing program.

Rendering output can nevertheless expose characteristics of the implementation that produced it. Text, graphics and rasterization depend on browser and rendering components. Repeated outputs can support comparisons between environments, but an observed readback is not a measured identification probability. Establishing uniqueness would require a defined population and sampling method. Establishing stable tracking would additionally require evidence across sessions or sites. Neither result follows from two calls within one archived frame.

One generated canvas helper in the surrounding archive has an hCaptcha label despite residing under the Cloudflare research directory. That provenance conflict prevents using the helper as an authenticated Cloudflare drawing recipe. The original event records and recorder implementation support the observed API categories; the helper's artwork has unresolved vendor attribution. A convenient filename cannot resolve contradictory source attribution.

WebGL: parameters are not all the same kind of exposure

The recorded webgl.getParameter names include numeric parameters 7936, 7937, 37445 and 37446. In WebGL terminology, the first pair corresponds to vendor and renderer queries; the latter pair is associated with unmasked renderer information through the debug-renderer extension. The archive also records webgl.getExtension. An extension request is not equivalent to a successful extension result, and the presence of an event does not guarantee an unmasked string was available.

The WebGL fingerprinting analysis explains why graphics implementation descriptions and rendered pixels are related but different surfaces. A textual renderer label can disclose an implementation family. A rendering result can reflect a broader pipeline. Combining those categories may provide a service with compatibility or consistency information, yet this archive does not reveal a weighting rule, decision cutoff or complete GPU inventory. Hardware identity must not be inferred from one API label alone.

Audio: local computation does not establish microphone access

Three OfflineAudioContext.startRendering events are recorded in the challenge frame. Offline audio rendering processes an audio graph without needing live microphone capture. These events therefore concern a computational audio surface, not evidence that Turnstile recorded a visitor's voice or requested microphone permission. Keeping that distinction explicit avoids turning a legitimate fingerprinting concern into an unsupported surveillance claim.

The offline audio call itself does not show which samples were subsequently examined or transmitted. It can produce output influenced by audio processing behavior, but the saved method invocation is only one stage. A privacy assessment should distinguish creation of an audio buffer, reading a derived value and communicating that value. The hook output supports a rendering invocation; it does not independently decode the service's representation of the result.

Source-derived surface matrix lists canvas.toDataURL twice, ctx2d.getImageData once, four WebGL parameter identifiers, and OfflineAudioContext.startRendering three times. Limits distinguish canvas pixels from screen capture and offline audio from microphone capture.

Figure 2 groups observed operations rather than ranking their importance. An API appearing more often is not necessarily more identifying or more influential in classification. One read can expose a high-level environment description; many repeated reads may simply implement the same task. Counting calls is useful for finding the relevant recorder branch, but it cannot substitute for understanding what was returned, how it was transformed and what the receiving service actually used.

Other challenge-frame events cover language-related properties, plugins or MIME-type objects, media queries, permissions and timing. Some of those names also occur in the recorder's own snapshot routine. They belong in a qualified observation inventory, not an unconditional claim that Turnstile independently interrogated every listed field. In particular, a permissions.query event records a query operation; it does not establish that the browser displayed a permission prompt or granted access to a protected device.

When the observer creates the observation

The recorder installs getter wrappers and then performs its own environment snapshot after a 100 millisecond timer. In inject.js:433-487, that snapshot directly reads navigator properties, screen dimensions, window geometry, timezone, connection information, memory, User-Agent data and plugin names. Because getters have already been wrapped, the snapshot causes ordinary-looking getter events as well as its explicitly labeled snapshot entries. One research action can therefore produce two different categories of log record.

For example, evaluating navigator.language for the snapshot first invokes the wrapped getter. That wrapper records a navigator event and returns the value. The snapshot code then records the returned value again under its own category. Filtering out only records whose category equals snapshot leaves the earlier getter event behind. Calling every surviving record a third-party read would overstate attribution even though the filter appears sensible.

Initialization introduces another source of recorder-generated activity. The memory section around inject.js:341-354 reads memory properties while setting up its observation behavior. The earliest three memory records occur in both saved frame groups. The existence of those entries cannot establish that challenge code requested heap values. Instrumentation coverage, installation activity and workload activity must remain separate categories until a caller-specific trace or a controlled comparison resolves them.

Recorder causality diagram: the 100 millisecond snapshot reads navigator.language, which triggers a navigator-category hook before the snapshot-category record. Removing the snapshot entry leaves an observer-generated getter event.

Figure 3 is derived from the snapshot and wrapper paths, not an imagined vendor sequence. Its narrow lesson is about interpreting this archive. It does not say that all recorded API calls are synthetic, nor that the challenge performed no measurements. Rendering calls absent from the snapshot deserve separate examination. The absence of per-call stack information still limits exact caller attribution, even for an operation that the obvious snapshot routine does not itself invoke.

The same distinction affects timing. A wrapper adds work to an API invocation, and this recorder samples rather than preserving every possible timing event. A saved performance.now count cannot become a clean measurement of challenge execution cost. Browser launch arguments in the recorder also change the test context, including site-isolation-related options. The sample is an instrumented environment rather than an untouched visitor session, so timing or environment-sensitive results need that qualification.

For an owned-site privacy assessment, the correct response is to annotate the evidence, not to delete inconvenient rows. Preserve the raw record privately, label known installation and snapshot reads, and separate unresolved events from stronger observations. Do not publish visitors' actual language combinations, renderer strings or canvas output merely to demonstrate that the categories exist. The privacy question usually needs a surface name and a justified interpretation, not another transferable fingerprint.

This separation also prevents a false reassurance. Discovering that a memory value was sampled by the researcher does not negate Cloudflare's separately documented network collection or its stated API-probing approach. An overinclusive log and an actual third-party observation relationship can coexist. Removing an unsupported claim improves the account of exposure; it does not prove that the system processes no information beyond what is visible in the remaining records.

Why a flat fingerprint loses context

The recorder's final fingerprint.json is convenient for inspection because it collects fields into one object. Its construction in inject.js:763-804 loses information that the frame-separated source still contains. Challenge-frame URLs are sorted first, but the output keys have no frame prefix. Later snapshot entries assign their values unconditionally. A parent-frame snapshot can therefore replace an earlier value under the same key despite the apparent challenge-frame priority.

The algorithm treats ordinary events differently: a seen set prevents a later non-snapshot value from replacing a previously seen key. Snapshot assignments do not consult that protection. The comment about processing the Cloudflare frame first describes iteration order, not an assurance that Cloudflare-frame values always win. The result is a mixture of first-seen dynamic values and later snapshot assignments. Reading the flat file without its construction code would hide this asymmetry.

Flattening diagram follows inject.js: the Cloudflare frame is processed first, both frames use the same field key, and a later parent snapshot can overwrite that key. Frame and caller attribution are not preserved by the final flat object.

This matters particularly for frame-dependent fields. A challenge iframe and the top-level application do not occupy identical document contexts. An available window dimension can describe the frame's viewport rather than the physical display. A media-query result can depend on its evaluated context. Replacing one frame's observation with another's does not make either original observation false; it makes the unlabeled aggregate unsuitable for a claim about exactly what the challenge frame saw.

There is a second format trap. In the historical output, the dedicated webglOps array is empty while the apiCalls array contains events labeled webgl. Looking only at the separate array would produce an incorrect claim of no WebGL activity. The recorder implementation shows where each event type is actually written. An empty container establishes absence from that container, not absence from the page or even from another part of the same recording.

The appropriate comparison unit is therefore a frame-local event with its category, API name and position in the recording. A flat fingerprint value can be supporting context after its provenance has been resolved. It should not be promoted to a vendor's transmitted field list. The snapshot also does not preserve the transformations that may occur between a native result, an internal representation and an outbound request body.

These limits constrain population claims as well. The second February archive contains a similar challenge-frame record, with 144 API events. Two instrumented archives produced by the same setup are not an independent sample of devices, users or configurations. Their similarity cannot quantify collision resistance, cross-site linkability or coverage across current Turnstile deployments. Such claims would need a different research design and evidence beyond this source collection.

Network receipts, tokens and clearance

The archived request handler records selected Cloudflare-related POST requests and later attaches response information. In the first Stock Chrome sample, three saved flow captures have HTTP status 200, with recorded request-body lengths of 2338, 4087 and 45058 characters. These are lengths reported by the collector, not decoded attribute counts. They do not identify the underlying request fields or prove that any particular canvas or audio result appears in the request.

The summary's turnstileToken value is null. That means this collector did not retain a token through its implemented detection paths. It does not prove that Cloudflare refused the browser, nor that no token could have existed elsewhere. The detector looks for particular parsed response or page-input forms. A historical tool can miss a state it was not designed to observe. The defensible outcome is unverified token issuance rather than an invented success or failure.

Outcome ladder separates three archived POST responses with HTTP 200 from token issuance, Siteverify acceptance and application authorization. The recorder stores turnstileToken as null, leaving those later outcomes unverified.

Cloudflare's server-side validation documentation supplies the next boundary. The client obtains a token, the application sends it to its server, and the server validates it through Siteverify before deciding how to handle the application request. A client-side widget display cannot replace that server-side check. Neither a visible completion state nor a network status from the challenge flow establishes that the application performed validation correctly.

The currently retrieved documentation describes tokens as valid for 300 seconds and intended for single use. It also documents eventual convergence of redemption state across the network. Consequently, single use should be understood as the service's intended token semantics, not a claim of an instantaneous, globally serialized application transaction. A site still needs its own business-operation controls. No token-reuse experiment or replay procedure is necessary to explain that separation.

Clearance cookies add another distinction. Cloudflare's clearance documentation says a Turnstile widget normally issues a token, while cf_clearance is an optional addition when pre-clearance is enabled. The configured security level and zone relationship matter. Describing every successful widget interaction as setting cf_clearance would conflate a default token path with an optional integration feature. Cookie presence also does not reveal the full history of the security decision. The PerimeterX Sensor, Detector and Enforcer analysis follows another documented cookie-to-server decision path, with a separate Risk API route when the client cookie is missing or invalid.

For privacy, the token and cookie are state-bearing artifacts, while IP address, headers and browser observations provide other context. A browser owner may clear local storage without erasing records already held by a service. Conversely, an operation that reads a rendering surface does not necessarily create a persistent browser identifier. Retention and correlation depend on processing outside the visible API event. Keep those questions attached to the operator's declared data handling rather than guessing from storage alone.

The Bot Management score discussion deals with operator-side fields under a different product boundary. A Turnstile token must not be presented as a public numeric bot-score report. The archive contains no authenticated mapping from a canvas value to a score, challenge action or account decision. A privacy exposure assessment can identify available information without pretending to reconstruct the vendor's private classifier.

Engine protection and patch scope

BotBrowser's browser-fingerprinting overview documents profile-backed controls through native browser API paths for rendering and other exposed surfaces. That architectural scope differs from wrapping selected JavaScript getters or methods after creating a document. The relevant privacy objective is controlling what a participating browser surface exposes consistently, including related values, rather than editing a single visible string while leaving connected observations unexplained.

A rendering surface illustrates the difference. Changing a displayed renderer label is not the same operation as controlling the rendering pipeline's exposed output. Canvas, graphics descriptions and audio results are separate observations in the historical trace. A privacy tool's claim should name which of them it governs and under which conditions. Documentation that describes a browser control is not itself a measurement that the control changes Turnstile's behavior.

JavaScript patches also vary in scope. Some replace values in a particular document, some wrap native method access, and others arrange initialization across supported contexts. Their exact behavior depends on implementation, timing and coverage. It would be inaccurate to claim that every patch necessarily misses all frames or that an engine change automatically covers every observable pathway. Compare documented surfaces and actual owned-fixture behavior rather than treating architectural labels as exhaustive test results.

The recorder's own limitations make this especially visible. Its snapshot-generated getters and frame flattening would complicate any attempt to compare browser protections using only the final JSON. A difference could come from instrumentation, frame selection or the protected surface. A meaningful privacy comparison would preserve those distinctions. The present archive is not such a causal efficacy study, so it does not support a percentage improvement, detector-success rate or product superiority score.

Protection-boundary matrix separates the archive's canvas, WebGL, audio and navigator surfaces from network IP and TLS context declared in Cloudflare's privacy notice, then from the service and application decision. Browser controls do not establish permission or anonymity.

Figure 6 combines the source-observed browser categories with the network categories named in the privacy notice. It does not say that TLS is unrelated to browser implementation, or that no browser product can influence transport behavior. It says that controlling the listed JavaScript and rendering surfaces alone does not settle the entire information relationship. An exit address, existing service records and application context remain distinct questions requiring their own evidence.

Consistency itself has a privacy trade-off. Stable related values can avoid accidental contradictions within a declared browser environment, but stability is not synonymous with lower linkability. A stable exposed value may remain comparable over time. A privacy evaluation must ask what information changes, for whom, across which boundary and over what duration. Merely making several signals agree does not demonstrate that a third party can learn less about a visitor.

Neither an engine layer nor a page patch changes the protected site's authority to decide access. BotBrowser does not supply Turnstile tokens on Cloudflare's behalf, approve an account action or erase a server's prior records. For site owners, browser compatibility testing and personal-data governance are complementary tasks. For visitors, a privacy control should be evaluated by its documented exposure boundary and usable fallback, not by an assumption that passing a challenge proves protection.

A privacy decision for an owned site

The Turnstile Privacy Notice names signals such as client IP address, TLS fingerprint, User-Agent header, sitekey and associated origin. Cloudflare states that collection serves bot detection and blocking rather than identifying, profiling or targeting individuals. It also describes using signals to improve detection capabilities. Reporting a potential correlation surface should preserve these stated purposes rather than asserting undisclosed advertising use or cross-site tracking without evidence.

The notice distinguishes processing roles. Cloudflare describes itself as a processor when securing customers' websites under their instructions, and as a controller when improving Turnstile's detection capabilities. That distinction matters to a site operator's privacy inventory because a single integration can involve more than one declared processing purpose. It does not by itself resolve every jurisdiction's legal requirements or establish that one notice satisfies every deployment's obligations.

Cloudflare's product overview also states that Turnstile does not access, store or transmit user communications, form entries or other page inputs. The historical rendering observations do not contradict that statement: synthetic canvas pixels and offline audio computations are different from message content or typed form values. Conversely, not collecting form text does not imply the absence of browser or network signals. Those are separate categories of information with different privacy questions.

An owned-site assessment can apply the following choice rule: retain a claim only at the strongest boundary its evidence actually reaches, then ask the responsible operator about the next boundary. The table is a decision artifact, not a request to reproduce a challenge or collect a complete visitor fingerprint. It helps separate a documentation question from an unresolved observation and from a deployment decision requiring the site's own records.

Available evidenceSupported privacy statementDecision for the site operator
The notice names IP address and TLS fingerprintNetwork context belongs in the processing inventoryDocument the purpose and responsible processing role; confirm applicable retention information
A frame-local record contains canvas serializationRendering output was requested in that instrumented framePreserve provenance; do not publish raw pixels or claim individual identification
A getter also appears in the recorder snapshotThe observation may be generated by instrumentationLabel attribution unresolved until caller evidence separates the paths
Three flow responses return HTTP 200The recorded exchanges received successful HTTP responsesVerify widget, server validation and application states independently
Product docs describe controls in the browser engineNamed browser surfaces have documented controlsEvaluate those surfaces on owned fixtures without inferring a vendor decision

Purpose limitation begins with reducing unnecessary duplication. If a security provider already processes a category for the declared security function, a site should not automatically copy the raw value into analytics or customer-support logs. A support report may only need the observation time, affected route and an authorized correlation reference. Full canvas output, challenge request bodies, cookies and tokens can create additional exposure while adding little to a browser-compatibility diagnosis.

Retention needs an explicit answer at each storage location. A local browser state lifetime, application-log lifetime and provider retention practice are different clocks. This archive does not establish any of them for a current production deployment. Ask the provider and the relevant site owner for the applicable policy, and record what remains unknown. An article about possible fingerprint surfaces cannot substitute for a service-specific retention statement or an assessment of applicable data-protection obligations.

Accessibility and error recovery belong in the same deployment review. A visitor who cannot complete a security step needs an operator-approved support or alternate verification route. Technical explanations should help the owner investigate compatibility without instructing visitors to forge signals or replay state. A refusal can be a policy result or an integration problem; neither interpretation justifies treating the browser as authorized to override the site's decision.

FAQ

Does an invisible widget mean there is no measurement?

No. Cloudflare distinguishes presentation modes from the non-interactive challenges used to evaluate a browser. Visibility is not a disclosure inventory.

Do the recorded audio events mean microphone recording?

The archived label names offline audio rendering. Microphone capture is a different capability; the saved events do not establish it.

Can an API event prove that its value was transmitted?

Only a demonstrated connection to the transmitted representation would establish that. Temporal proximity to a POST is insufficient, especially with opaque request bodies and recorder-generated reads.

Is the local archive a current list of Turnstile checks?

It is a dated, instrumented sample. Challenge selection and implementations can change, and the recorder lacks complete caller attribution.

Sources

Practical conclusion

Turnstile combines browser challenges with a declared network-information relationship. The archived source adds specific rendering observations while also exposing recorder-generated reads and lost frame provenance. Use that evidence to inventory potential privacy exposure, not to infer a hidden score or promise anonymity. For an owned deployment, the next safe action is to reconcile the provider's declared signal categories with the site's purpose, retention and server-validation records, keeping raw fingerprints and reusable security state out of the report.

#Browser Fingerprinting#Privacy#Cloudflare Turnstile

This article is part of the guide: What Is a Browser Fingerprint? Canvas Fingerprinting

Run the same check in BotBrowser

Load a profile, keep the signals you just read about consistent inside the browser, and confirm the result on your own machine before a rollout.