Back to Knowledge Hub
Fingerprint

reCAPTCHA Privacy: Signals and Evidence Boundaries

Separate reCAPTCHA token-time observations, backend assessment inputs, conditional features and Customer Data responsibilities from browser privacy controls.

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.

reCAPTCHA privacy involves both the client integration that generates a token and the customer backend that submits an assessment. The current Cloud documentation describes optional customer-supplied fields, output-only observations associated with token generation and qualified Customer Data processing responsibilities. Those are different sources of information, not one browser inventory. BotBrowser documents profile-backed, browser-native controls for browser-exposed fingerprint surfaces, but cannot control customer assessment submissions, provider records, server decisions or processing contracts. Understanding the boundary requires identifying who supplied a value, when it was observed and which terms govern its processing.

TL;DR

  • A website assessment combines client-token processing with a separate backend submission. Browser-only evidence cannot describe everything the customer sends.
  • Optional Event.userIpAddress and Event.userAgent are caller inputs. Output-only clientProperties separately describes corresponding observations at token generation.
  • Universal, Express and other features have specific conditions. An Optional schema label is neither a complete integration contract nor permission to submit unrelated data.
  • The current FAQ dates the Customer Data role change to April 2, 2026. It identifies the customer as controller and Google as processor under the named Cloud terms.
  • The cookie remains. The role change establishes neither a retention period nor independently verified deletion or legal compliance.

Contents

An assessment has two distinct data paths

The website assessment documentation describes a client integration producing a response token when an end user triggers an action. The application then submits that token from its backend for assessment. Google processes the submitted token and reports its validity and risk analysis. This arrangement creates two privacy-relevant paths: interactions involving the client integration, and information the customer independently includes in the backend request. Looking only at visible page behavior misses the second path.

The documentation says assessments should be created only on the backend for application security. That recommendation also identifies an important evidence boundary. A browser network record may show the application receiving a form submission without showing the later server-to-server assessment. Conversely, a backend assessment log may describe submitted fields without establishing which browser interfaces the client integration read. Both records can be accurate while answering different questions. Neither should silently become a complete account of the other processing path.

The token is an intermediate result, not a readable inventory of every signal used to generate it. The documentation describes it as an encrypted response and provides several ways the application can receive it, including the result of grecaptcha.enterprise.execute() or a client callback. Receiving that result establishes token delivery to the application. It does not establish which browser values were read, which values the backend added, or how long any participant retained related information. Those questions require their own evidence.

Token timing also has a specific meaning. The website documentation says a token can be used only once and expires after two minutes. Those limits govern assessment use of the token. They are not a two-minute retention promise for provider records, application logs or account information associated with the assessment. A token rejected after expiry may still have passed through application infrastructure. Likewise, an application deciding not to submit a token does not establish that the preceding client interaction left no records.

Two documented assessment paths separate client token generation from the customer backend submission. The backend can add request or application context before receiving token properties and risk analysis. Neither path alone establishes retention or application authorization.

For an owned appointment application, a useful distinction would be whether the backend submitted only the required assessment context or also added selected request information. This is a hypothetical design question, not a reported test. The browser component might produce a token while the backend independently possesses an incoming request header and connection information. Establishing that those values were available is still different from establishing that the application included them in its assessment. The deployed request construction determines the latter.

The assessment resource reference reinforces the distinction by marking event as the event being assessed and riskAnalysis and tokenProperties as output-only results. A response can contain information about the submitted event alongside newly returned properties. A field appearing in response JSON therefore needs its enclosing object and direction attached. Without them, a copied request value can look like a new provider observation, or an actual output can be mistaken for something the customer supplied.

The explanation of what a site receives from a risk assessment addresses the neighboring application decision boundary. A token, its validation and the site's authorization decision are separate stages. For privacy purposes, the additional question is provenance: which information accompanied each stage? A successful assessment is not proof that the site completed the requested business operation, and neither outcome describes the provider's storage practices. Keeping those stages distinct makes the data path understandable without turning assessment results into an unsupported description of collection.

The same field names can have different origins

In the REST resource schema, Event.userAgent and Event.userIpAddress are optional caller fields. They describe request information related to the event being assessed. The website assessment documentation recommends providing them as additional assessment values. That is a documented customer submission path, not evidence that every application sends them. A privacy assessment needs the effective backend behavior rather than treating a sample request or available schema field as a record of production traffic.

The output side must also remain visible. TokenProperties.clientProperties is output-only information collected by the client-side integration when the token is generated. Its userIpAddress describes the user's address at token generation, while userAgent describes the User-Agent header string observed by reCAPTCHA at that time. Describing only the optional inputs would erase this second provenance. Omitting a caller field does not establish that the provider cannot observe corresponding information through its own interaction with the client.

The reference gives concrete representation limits for these outputs. The address can be IPv4 or canonical IPv6, with IPv4-mapped IPv6 addresses canonicalized to standard IPv4. The returned User-Agent string is truncated to a maximum of 1000 characters. These conditions describe output representation, not an exhaustive browser profile. They also mean that a simple text comparison can reflect formatting or truncation rather than a meaningful change in the person or device. The field's documented semantics must accompany any comparison.

Field provenance separates optional Event userAgent and userIpAddress supplied by the customer from output-only clientProperties observed at token generation. Identical field names do not establish identical origin, observation time or evidence of a JavaScript API read.

An assessment can consequently contain two descriptions of related request context without either being redundant evidence of one measurement. The customer's backend receives a request at one point in the application flow; the client properties concern token generation. Whether the values agree depends on the actual interaction and infrastructure, which must be established rather than assumed. A difference does not by itself prove misconduct, and agreement does not prove the values came from the same observation. Preserve both provenance and timing before assigning meaning.

Documented locationOrigin and conditionExpected privacy decisionSource
event.userAgentOptional caller-supplied request informationCheck whether the backend actually submits it and for what purposeAssessment schema
event.userIpAddressOptional caller-supplied address related to the eventIdentify the backend's trusted source and submitted scopeWebsite assessment
tokenProperties.clientProperties.userAgentOutput-only header observation at token generationAccount for returned data independently of omitted caller inputsAssessment schema
tokenProperties.clientProperties.userIpAddressOutput-only address at token generationPreserve token-time provenance and documented address formattingAssessment schema
event.ja3, event.ja4, event.headersOptional caller contextVerify actual submission; do not label these fields browser API readsAssessment schema

HTTP header provenance is particularly important. The website documentation identifies the user-agent input as information present in the incoming HTTP request. Supplying that header string does not prove JavaScript read navigator.userAgent. Similarly, an address made available to the backend is not proof of a browser API returning it. Infrastructure and header trust still matter when the application chooses its input. The documentation's discussion of forwarded addresses identifies a possible source; it does not establish which intermediary or address is trustworthy in every deployment.

The ja3 and ja4 fields concern TLS-client fingerprints, while headers concerns HTTP request information. These are request-context schema entries, not JavaScript APIs. Their presence establishes a supported input category, not that the client integration computed them or that the customer submitted them. No current vendor-attributed V8 JSONL record is available in the reviewed evidence set. The available historical generic graphics rows identify an embedding page rather than a vendor V8 callsite. They support neither a current reCAPTCHA API inventory nor a claim that a particular browser read was absent.

Feature conditions change what the schema means

The assessment reference uses Optional widely because one resource supports multiple arrangements. That label is not the entire contract for a selected integration. A field may be optional across the resource yet required under a particular feature. Equally, a field's availability is not universal permission to send data unrelated to the chosen purpose. Read the field description together with the deployed key and feature conditions, rather than deciding from a flattened list of names.

expectedAction is a clear example. The schema labels it optional but explicitly says it is required for Universal keys. It describes the expected action for the event and should correspond to the action provided when the token was generated. A privacy description should distinguish this caller-declared expectation from output-only tokenProperties.action, which describes the action name provided at token generation. These values connect an assessment to an application interaction; they do not establish the identity of the person performing it or replace the application's own authorization rules.

Express supplies another condition that changes the data path. The express flag describes an assessment without a token, and enabling it requires siteKey to reference an Express site key. Tokenless therefore means a particular supported arrangement, not that any website assessment can simply omit its token. The website assessment documentation describes submitting tokens for the listed website integrations. Both statements can hold because their conditions differ. A data map should identify the actual arrangement before deciding which token-related observations apply.

Other switches also have prerequisites and consequences. A wafTokenAssessment requires a specified token created by a WAF-enabled key. Enabling firewallPolicyEvaluation asks for evaluation of the project's firewall policy configuration and a suggested action in the response. These are feature choices, not descriptions of every assessment. Their presence in the common schema does not show that a website enabled them, received their outputs or used those outputs in an application decision. Configuration evidence belongs beside any assertion about deployment.

Independent feature conditions distinguish Universal expectedAction requirements, tokenless Express assessments requiring an Express key and optional account context. AssessmentEnvironment describes the caller system, not the visitor's device.
Schema or feature conditionWhat the documentation establishesExpected decision
Universal keyexpectedAction is requiredRetain the action relationship in the integration's data description
express enabledAssessment is tokenless and requires an Express site keyDo not apply token-based assumptions to this path
wafTokenAssessment enabledToken must exist and come from a WAF-enabled keyEstablish the configured feature before describing its data
transactionData and Fraud PreventionTransaction context participates under feature settingsReview transaction purpose and included fields separately
assessmentEnvironmentDescribes the system invoking assessments.createClassify module and version information as caller environment

assessmentEnvironment deserves special attention because its name can invite the wrong interpretation. The reference explicitly says it describes the environment creating the assessment, not the user's environment. Its client and version fields can identify the initiating module and module version. An integration identifier in this object is therefore not a browser version discovered on the visitor's device. Misclassifying it would inflate the supposed device inventory while obscuring operational information the customer or its integration intentionally supplies.

Conditional outputs need the same treatment as inputs. The resource describes account defense results when an account identifier is provided, transaction assessments when transaction data participates, and phone-fraud assessment conditions involving enabled SMS defense and the required inputs. These outputs do not establish universal profiling of every visitor. They document relationships between features, supplied context and returned assessments. For an owned service, the useful decision is which relationships actually apply, not whether every object in the reference can be copied into one privacy inventory.

This also affects negative evidence. An absent field may reflect an unused feature, an unmet condition or a response that simply did not include it. Its absence should not automatically become a statement about all internal processing. Conversely, a documented optional feature should not be attributed to the site without deployment evidence. The reference supplies conditional semantics; the application supplies its effective configuration and submitted request. Combining those sources carefully yields a narrower but defensible account of the service actually used.

The current Cloud FAQ dates its Customer Data role change to April 2, 2026. It says customers are the sole controller of Customer Data and Google processes that data in accordance with the Google Cloud Terms of Service and Cloud Data Processing Addendum. The named data category, service relationship and agreements matter. This is not a statement that every Google product or every processing activity has the same role allocation, nor an independent audit of any particular deployment.

The FAQ explains the earlier relationship as one in which customers already controlled their end-user data while Google maintained an independent-controller position concerning delivery of the service. Its account of the change says Google relinquishes determining the purposes and means of processing Customer Data in the processor role. That explanation concerns responsibility for the defined processing. It does not imply that the underlying browser integration stops operating, that existing information disappears or that the customer's own responsibilities begin only on the change date.

The badge and disclosure changes follow that role explanation. The FAQ says references to Google's Privacy Policy and Terms of Use are removed from the badge starting April 2, 2026 and recommends removing those references from customer websites for accurate representation. It also says customers should review end-user-facing disclosures to cover security, fraud and abuse prevention. Removing an obsolete link is therefore not equivalent to removing the website's explanation of the processing. The customer's notice still needs to describe the relationship that actually applies.

Customer Data responsibilities are separated from technical behavior. The current FAQ identifies the customer as controller and Google as processor from April 2, 2026 under Cloud terms, while the cookie remains and retention or deletion requires separate evidence.

Cookie continuity is explicit. The FAQ says the necessary cookie _GRECAPTCHA is set when the service executes for risk analysis. In its discussion of the processor change, it says the reCAPTCHA cookie remains unaffected. A different role allocation does not eliminate browser storage. The FAQ also discusses using www.recaptcha.net instead of www.google.com when avoiding that domain's other cookies is preferred. That domain distinction must not be rewritten as a claim that the necessary service cookie or all provider processing disappears.

Purpose limitation is more specific than a broad assertion that data is used only for one momentary verdict. The FAQ commits to processing Customer Data only as necessary to provide and maintain the service and keep its security, threat detection, protection and response capabilities effective against evolving threats. It ties that statement to the service-specific terms and processing addendum. A privacy explanation should preserve those stated purposes rather than narrowing them to token validation alone or expanding them into unspecified uses not established by the source.

No retention period follows from these passages. A processor role, a necessary cookie and a short-lived token each address a different question. None supplies a general duration for provider storage, customer logs or later deletion. The FAQ directs readers asking about session data and protections to the processing addendum and service-specific terms. Those references identify where applicable obligations must be examined; they do not constitute evidence that deletion occurred for an individual record. Storage duration and actual deletion remain separate questions requiring relevant terms and operational evidence.

The FAQ also makes a vendor statement about GDPR commitments through the Cloud processing addendum. That statement should remain attributed to Google and its defined obligations. It does not independently establish that a particular site's notice, configuration, legal basis or handling of user requests is compliant. The product-release privacy policy review explains the broader task of aligning product claims with their supporting sources. Here the service-specific decision is concrete: keep Customer Data roles, stated purposes, cookie behavior and unverified retention outcomes in separate parts of the explanation.

Account and transaction context is not a device inventory

The assessment schema includes optional userInfo and transactionData objects because the service supports account and payment-related features. Those objects describe application context, not a universal list of properties automatically read from every browser. A customer can hold information through its account system or checkout process independently of the client integration. If it submits that context for assessment, the privacy significance comes from the additional data path and purpose, not from relabeling every field as device fingerprinting.

UserInfo.accountId is optional. Its description concerns logged-in requests and login or registration requests, and it instructs callers to leave it blank for non-logged-in actions or guest checkout. createAccountTime similarly describes the associated account's creation time and should be left blank when no account is associated with the current user, including the stated guest cases. These instructions support a concrete minimization choice: do not manufacture persistent account context for an anonymous operation merely to fill available schema fields.

The distinction between account identity and other identifiers also matters. userInfo.userIds can contain identifiers such as an email address, phone number or username under the documented structure. Guest-related identifier support elsewhere in the schema does not cancel the specific instruction to leave accountId blank for guest checkout. Nor does an optional list create a requirement to send every identifier already known to the business. Each submitted category needs a relevant feature purpose and an accurate description of its source.

The older hashedAccountId field is explicitly deprecated, with the reference directing callers to the account identifier in userInfo instead. Its historical presence must not become a new recommendation to add a hashed identity to every request. A hashed identifier can still provide a stable association within a system; the word hashed does not itself establish anonymity or remove the need to explain linkage. The current design decision should follow the supported field and applicable account conditions, rather than reproduce an obsolete example as general privacy advice.

Transaction data expands the context in a different direction. The schema describes payment method, currency, transaction value, shipping and billing information, purchased items, payment-party information and gateway response details. These fields can reveal characteristics of a commercial interaction rather than browser capabilities. The FAQ separately says that installing the service on a transaction page involves examination of certain transaction signals and that fuller transaction information can be supplied through the fraud-related integration. Those statements do not prove that every site submits every transaction object.

Feature settings qualify the resulting assessment. The reference connects transactionData with Fraud Prevention and documents how fraudPrevention interacts with the feature's Cloud configuration. This means data inclusion, feature enablement and returned assessment are related but distinct facts. A request may be designed for one purpose while another deployment enables additional features. A truthful inventory therefore identifies the deployed relationship rather than treating all possible transaction outputs as present on every payment page.

Some transaction descriptions carry precise distinctions worth preserving. cardLastFour describes the last four digits, not a complete payment-card number. Gateway verification response codes describe payment processing results, not a request to submit the underlying verification secret. transactionId is a custom identifier used to reference a transaction, with repeated attempts at the same transaction using the same identifier according to the reference. These are contextual categories with different linkage and sensitivity implications. Combining them under an undifferentiated “technical signal” label would hide information the site owner intentionally shares.

For a hypothetical owned guest checkout, the expected decision could be to leave account-specific fields blank, include only transaction context required by the selected feature and avoid duplicating unnecessary identifiers. That is a design scenario, not an executed assessment or a guarantee that a particular configuration is sufficient. The backend owner can establish actual submitted categories without exposing customer values, while the privacy owner determines how their purposes and recipients are described. Minimization belongs at the request-construction boundary; it cannot be delegated to a browser setting after the application has supplied the data.

Browser controls stop before backend and contract decisions

BotBrowser's browser fingerprinting overview documents profile-backed controls over browser-exposed surfaces, including Navigator properties, graphics, audio, fonts, screen dimensions and timing. It describes browser-native operation rather than page JavaScript injection. This supports a product capability claim about the documented browser configuration. It does not establish which of those surfaces current reCAPTCHA code reads, whether a chosen configuration changes a provider decision or whether every rendering result is identical across environments.

A page-level property change has a different placement. It operates in the JavaScript environment and paths that actually encounter that change. Its presence alone cannot establish the state of every other execution context or native operation. Browser-native controls have their own documented configuration and support boundaries rather than relying on one page's property replacement. The useful comparison concerns where the control acts and what it supports, not an effectiveness ranking against a third-party service. Neither placement is evidence of an unobserved vendor call.

The local evidence limitation is decisive for any provider-specific claim. The reviewed material contains no current vendor-attributed V8 JSONL capture. Historical generic Canvas and WebGL rows use an embedding-page execution location and do not supply vendor callsite attribution. Monitoring validation requirements can describe how a successful observation should be checked, but do not prove that such a capture ran. No current browser API inventory follows from those materials, and no new live capture establishes one. General knowledge of a browser surface cannot fill that attribution gap.

Different claims require different evidence. An attributable browser event could establish a read during a defined phase. A redacted backend request could establish a customer submission. An assessment response could establish returned token properties. A processing agreement could establish stated responsibilities, while an operational audit would be needed for actual retention or deletion behavior. Moving between these claims requires additional evidence, not just a stronger description of the same artifact. A response field may be well documented without revealing its underlying browser execution.

Privacy questionAppropriate evidence and ownerExpected decision
Did vendor code read a browser interface?Current attributable runtime event from an authorized observationLeave the claim unresolved without source attribution
Did the customer submit account or request context?Redacted request construction and submission evidence from the backend ownerMinimize unnecessary fields at that boundary
What did the assessment return?Scoped response evidence interpreted using the REST referenceSeparate caller context from output-only properties
Which Customer Data purposes apply?Applicable terms and privacy explanation from the contractual ownerPreserve the FAQ's qualified service relationship
Was a record deleted?Applicable obligation plus operational evidence from its custodianDo not substitute token expiry or browser logs

Browser controls cannot remove information the customer's server already possesses and chooses to submit. Changing a page-visible property does not edit userInfo, suppress a backend transactionData object or rewrite an application log. Nor does a browser profile change the Cloud processing agreement or delete records retained by another party. Network observations remain a separate relationship as well. A documented browser surface setting is therefore not a promise of anonymous operation, universal acceptance or control over every recipient's information.

An owned integration can make these boundaries reviewable without collecting private values. Identify the categories actually submitted, the output categories actually consumed, the enabled feature conditions and the responsible contractual relationship. Where evidence is missing, retain the specific unanswered question instead of populating an imagined device inventory. This produces a reCAPTCHA-specific explanation: client-token observations, customer additions and Customer Data obligations are separately accountable. The next useful change belongs to the component that owns the data, whether that is browser configuration, backend request construction or the site's processing explanation.

FAQ

Does omitting Event.userIpAddress mean reCAPTCHA cannot observe an address?

No. That field is an optional caller input. The REST reference separately documents output-only clientProperties.userIpAddress at token generation. Omitting one submission field does not establish the absence of the provider's own network or token-time observations.

Does clientProperties.userAgent prove a JavaScript Navigator read?

No. The reference describes a User-Agent header string observed during token generation. That output does not identify a JavaScript callsite or establish a current browser API inventory. Header provenance and browser-interface execution are different claims.

No. The current FAQ explicitly says the cookie remains unaffected. Its Customer Data controller and processor explanation concerns the named service and Cloud terms; it is not a statement that browser storage or processing ended.

Is every optional assessment field appropriate for every visitor?

No. Feature conditions and field-specific instructions still apply. Universal requires expectedAction, Express tokenless assessments require an Express key, and account fields include instructions to leave them blank for specified anonymous or guest actions.

Can token expiry establish a provider deletion deadline?

No. The documented two-minute token lifetime concerns using the token for assessment. It does not establish how long provider records, customer submissions or application logs are stored, or prove that a particular record was deleted.

Sources

Practical conclusion

Map reCAPTCHA information by origin before deciding what a browser control can change. Separate customer-submitted Event fields from token-time clientProperties, apply the selected feature's conditions and use the current Customer Data terms for processing responsibilities. The available evidence establishes no current vendor-attributed browser API inventory or deletion outcome. For an owned integration, verify actual submitted categories, remove unnecessary account and request context, and align the site's explanation with the service relationship it uses.

#Privacy#Browser Fingerprinting

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.