AWS WAF CAPTCHA: Tokens, Signals and Privacy
AWS WAF CAPTCHA uses session tokens, browser signals and separate challenge clocks. Understand what encryption, timing and browser controls do not establish.
BotBrowser Team
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.
AWS WAF CAPTCHA is more than the puzzle visible on a page. Its documented token carries session state, separate challenge and CAPTCHA timestamps, and information gathered from the browser. Integrating the application SDK adds interaction categories such as mouse movement, key presses and form interaction. BotBrowser provides profile-backed browser surface consistency through native engine paths rather than page-context JavaScript injection; it does not control AWS token validation, provider records or the application's authorization decisions.
The privacy question is not simply whether a person sees a challenge. A silent step can still collect information, and an encrypted cookie can still associate requests with a session. Conversely, a session identifier does not establish a person's identity. These distinctions matter when an application describes its collection, assesses which integrations it actually needs, or explains why a successful CAPTCHA is not permission to access protected data.
TL;DR
aws-waf-tokenis an encrypted session token, not merely a visible puzzle receipt. AWS documents browser interrogation and additional interaction collection when the application SDK is integrated.- Challenge and CAPTCHA have separate timestamps. The documented default immunity of 300 seconds concerns the age of those checks, not deletion of collected records.
- AWS describes gathered information as non-unique and not mappable to an individual human. That vendor statement does not remove the documented session association or decide an application's legal obligations.
- A valid token lets the relevant action continue through remaining web ACL rules. It does not authorize an account action or guarantee that the application returns a page.
- Encryption limits visibility of token contents; it does not establish minimal collection, an absence of processing, or a provider-wide storage deadline.
Contents
- A session token beyond the visible puzzle
- Documented signals and observation limits
- Two freshness clocks, not a deletion schedule
- A valid token and the remaining decisions
- Encryption, visibility and data custody
- Browser controls and accountable privacy choices
- Practical conclusion
A session token beyond the visible puzzle
The AWS token characteristics documentation names the cookie aws-waf-token and describes the token as encrypted. It also says the token fingerprints the client session with a sticky granular identifier. That is a more specific description than “the website uses a CAPTCHA.” The visible puzzle is one possible interaction in a larger session mechanism, while the cookie represents state that can accompany subsequent requests. The FunCaptcha session analysis separates another provider's completion and backend verification; AWS timing and token semantics should not be transferred to Arkose.
The documented contents include the latest successful silent-challenge timestamp and, when CAPTCHA is used, the latest successful CAPTCHA timestamp. AWS also describes additional information about the client and its behavior. These are categories in a public description, not a complete field schema. AWS explicitly withholds a complete account of token contents and encryption details for security reasons. An assessment can preserve those limits without inventing hidden fields or treating an opaque value as empty.
The cookie name identifies a storage and transmission mechanism. The session identifier describes an association that AWS says the mechanism supports. Encryption describes the representation of the contents. Those three properties answer different questions, even though they refer to the same token. A privacy inventory that records only “encrypted cookie” misses why the state exists and how it participates in associating requests across a session.
AWS explains token use across application integrations and managed protections, rather than presenting the token as exclusive to one puzzle. A challenge can initialize a token when needed. A CAPTCHA interstitial without an existing token first invokes a challenge, then runs the puzzle and updates the appropriate timestamp after completion. A person can therefore encounter one visible task while the documented system performs more than one kind of session validation.
This is distinct from the rule-group structure in AWS WAF Bot Control and client observations. That subject concerns protection levels, labels and responses. The additional privacy issue is the continuity represented by aws-waf-token: a later request can carry state produced by earlier browser processing. A single response code cannot describe that history, and the existence of a rule group does not by itself reveal which integration generated the state.
For an application owner, the first useful distinction is between an enabled feature and a state observed in one session. Documentation can establish that an SDK adds an interaction-collection path. The application's actual deployment establishes whether that SDK is included, where it runs and which parts of the application use it. Neither a generic product name nor an isolated cookie inspection proves those deployment details. Feature availability and active collection need separate evidence.
Session continuity also should not be expanded into a universal identity claim. The token description concerns a client session, and AWS characterizes the information as non-unique and not mappable to an individual human. That does not say a token is a civil identity. It also does not say an application holds no other information about a signed-in session. The token's documented scope and the application's account records remain different parts of the data map.
For example, an application may separately know that a request belongs to an authenticated account. That is an illustrative application context, not a claim that AWS receives the account's full profile inside the token. The privacy assessment needs to distinguish what the provider documents from the information the application already holds. Treating both parties as holding the same information is as misleading as assuming that neither can associate successive requests with any context.
Documented signals and observation limits
AWS says all tokens include browser-interrogation data, including indications of automation and browser-setting inconsistencies. Its description attributes this collection to scripts run by the Challenge action and application integration SDKs. This supports a statement about documented signal categories. It does not supply an exhaustive browser API list, a collection order, a scoring rule or a present-day observation of a particular website's script.
The same source distinguishes an additional path for applications that integrate an SDK. That path passively collects interaction information, including mouse movements, key presses and interaction with HTML forms on the page. “Passive” describes the user's interaction with the application rather than an additional visible puzzle. It does not mean that the information has no privacy significance, and it does not mean that every deployment without a visible puzzle has the same collection configuration.
The category key presses must retain its actual evidential scope. It is not sufficient evidence to claim that the SDK stores the text of every password or every form value. Likewise, a reference to form interaction is not a public schema of submitted field contents. A privacy concern can be stated accurately without turning category names into unsupported claims about transmitted fields. The documented collection is enough to justify asking which interactions are necessary for the deployed purpose.
| Evidence available | Supported conclusion | Unestablished conclusion |
|---|---|---|
| Token characteristics page | AWS documents browser-interrogation categories | Every API executed by a current script |
| SDK interaction description | Integrated SDKs add documented interaction categories | Every site enables that SDK or stores every field value |
A browser stores aws-waf-token | The named cookie exists in that observed context | Complete decoded token contents or provider retention |
| Source-attributed V8 events | Particular browser interfaces executed in the captured context | Every value was transmitted or stored remotely |
The choice rule is to match a claim to the evidence row that can answer it. A product document supports a product-description claim. A runtime statement about an API requires a relevant runtime record. A server-storage statement requires evidence about the receiving service or its applicable commitments. Adding more browser detail cannot fill a missing service-retention fact because the two observations concern different stages of processing.
No source-attributed V8 capture of an AWS collector is presented here. An older API-hook record, an opaque network request or a list of familiar fingerprinting properties cannot be promoted into a new observation of what an AWS script read. A source-attributed --bot-v8-log event would be the appropriate starting point for an execution claim, but even that event would need its frame, source and capture context before it could support attribution to a particular component.
The broader browser fingerprinting explanation describes why browser properties can contribute to correlation. That general mechanism is not a substitute for evidence that a named vendor read a named interface. An API can be available without being called, called without its result being sent, or used by another script on the same page. Conflating these cases turns a plausible theory about collection into an assertion the available evidence does not establish.
The AWS token documentation therefore supplies a useful privacy boundary in its own terms. Browser interrogation and SDK interactivity are separate documented inputs. The first does not establish which individual rendering or timing APIs were used; the second does not establish the exact content of any interaction record. An integrating business can ask the provider and its own implementation owners for those details rather than deriving a proprietary collection specification from generic browser knowledge.
Evidence restraint also reduces unnecessary handling of sensitive material. A team assessing whether form-interaction collection is enabled may be able to answer from its integration inventory and applicable documentation without recording real users' input. A different question about an observed API call needs a deliberately scoped, authorized capture. The useful privacy principle is not to collect a richer trace merely because a tool can produce one when the assessment concerns a simpler deployment fact.
The resulting exposure is still concrete. The vendor describes information that connects browser characteristics, session validation and application interaction. These can be relevant to a security purpose while also deserving limits on collection, use and access. That is an engineering and governance question about the real integration. It does not require claiming that a session is a person, that a particular field contains personal text, or that a browser trace proves a provider's storage practices.
Two freshness clocks, not a deletion schedule
The immunity-time documentation defines how AWS evaluates timestamp freshness. When a challenge or CAPTCHA succeeds, its corresponding timestamp is updated inside the token. At inspection, AWS compares that timestamp's age with the configured immunity time. This is a decision about how recently a particular kind of session validation succeeded, not a public schedule for erasing every record associated with the session.
The documented web ACL default is 300 seconds for each immunity time. The matching number can hide an important structural distinction: Challenge and CAPTCHA still have separate timestamps and separate settings. Equal defaults do not merge the two records into one clock. Nor does the default establish the effective policy of every rule, because the documentation permits rule-level settings and explains inheritance when a specific rule does not supply its own value.
The token-use page explains that a CAPTCHA puzzle updates the CAPTCHA timestamp and a silent challenge updates the challenge timestamp. Those are different events even when they occur during one user-visible interaction. A report that records only “CAPTCHA passed recently” discards which validation actually happened and which timestamp the later policy is considering. The original event and the later freshness test need to remain distinguishable.
An illustrative application may require a CAPTCHA-related check for one operation and encounter a Challenge action on another path. The fact that both paths belong to the same application does not prove that they test the same timestamp under the same inherited setting. This example describes the documented separation, not a configuration recommendation. The appropriate owner needs to inspect the actual web ACL and rule arrangement before explaining the observed policy to a support or privacy team.
AWS also states that application SDKs use the web ACL's challenge immunity time. That is another reason a rule label or a visible puzzle alone cannot describe the complete timing arrangement. The source identifies which setting the SDK uses; it does not say that every application path is governed by one identical CAPTCHA schedule. A deployment description should name the relevant mechanism rather than compressing several checks into “the CAPTCHA lifetime.”
The word expired needs similar care. In this documentation it describes the applicable timestamp failing an age check. That does not establish that the browser cookie was removed, the provider erased its records, or an application deleted a log entry. Those may be separate events governed by separate mechanisms. It is possible to describe the timestamp state precisely without asserting anything about those other lifecycles, because the documentation's own age test has a narrower purpose.
| Timing question | Relevant documented fact | Separate question |
|---|---|---|
| How recent must challenge validation be? | Applicable Challenge immunity setting | How long a service record is retained |
| How recent must puzzle completion be? | Applicable CAPTCHA immunity setting | Whether an application still holds an associated account log |
| Which setting does an unspecified rule use? | Inheritance from its web ACL | Whether another rule uses an override |
| Which setting does the SDK use? | Web ACL Challenge immunity time | Whether other collection is enabled in the application |
For privacy communication, using the default 300 seconds as a retention promise would be a category error. The documentation establishes when a later request may need another check. It does not establish when every resulting record disappears. A notice that says data is deleted after that period would need independent support from the applicable service terms and the application's actual storage policy, not merely a screenshot of an immunity setting.
A short freshness interval should not be interpreted as stronger data minimization, and a longer interval should not automatically be interpreted as longer provider storage. Those properties can interact in an implemented system, but their relationship is not established by the timestamp policy alone. The factual claim available here is about repeated validation. Any claim about collection volume or stored history needs evidence scoped to that different outcome.
This distinction also improves accessibility and support discussions. An account of repeated prompts should identify the relevant challenge mechanism and effective policy rather than assuming that a user lost an application login. Token freshness, cookie persistence and application authentication are not interchangeable state names. They can affect the same user journey, but each has its own owner and evidence. A precise explanation avoids responding to a security-state question by making unsupported claims about unrelated account or storage behavior.
A valid token and the remaining decisions
According to AWS action behavior, a valid token causes a CAPTCHA or Challenge action to behave similarly to Count. AWS applies the configured labels and request customizations and continues evaluating the remaining web ACL rules. This is a continuation condition at a particular action. It is not an unconditional approval of the request, and it is not a replacement for the application's own authentication and permission checks.
The distinction is essential when a support report says a CAPTCHA was completed but an operation still failed. The report may accurately describe the visible task while saying nothing about later rules or application permissions. There is no contradiction in the documented control flow: one action can continue and another component can still decline the operation. The source supports that separation without diagnosing the actual cause of any particular failed request.
For missing, invalid or expired token state, the same documentation says AWS stops evaluating that request through the web ACL and prevents it from reaching its intended destination. The returned content also depends on whether the request can handle the HTML interstitial. A top-level page and an application request expecting another content type are not equivalent contexts simply because they originate from the same browser.
That distinction helps separate a rendering symptom from a privacy fact. Seeing no puzzle in an application view does not prove that no challenge-related response occurred. Seeing an interstitial does not reveal its full token contents. The documented request expectations explain why a challenge mechanism and a user-visible page are related but not synonymous. An actual deployment diagnosis still requires authorized application and service evidence rather than an inference from what one screenshot did not display.
The current action-behavior page explicitly documents CORS response headers that expose x-amzn-waf-action to JavaScript, including cross-origin requests. This is a documented visibility property, not a claim based on a fresh HTTP capture. It means the header cannot accurately be described as categorically unavailable to cross-origin application code under the current documented response behavior. It does not mean that every response body or cookie becomes readable without restriction.
The header is also a different kind of information from an internal rule history. An action marker can describe the response's action category without supplying every earlier observation, label or downstream decision. A privacy inventory should not turn visibility of one header into visibility of the entire service's reasoning. Conversely, an opaque token does not prevent the application from observing every aspect of the surrounding request flow. Representation and visibility vary by field and by participant.
The browser environment and the receiving service thus occupy separate decision domains. The BotBrowser fingerprinting guide describes native browser-surface controls. It does not describe a mechanism for granting an application permission or instructing AWS to accept a token. A page-level patch operates in another modification layer, but comparing those layers does not establish a vendor-specific outcome. Browser consistency and service authorization should not be combined into one success metric.
For an owned integration, a useful diagnostic record can distinguish the applicable action, whether it continued, the remaining web ACL result and the application's own response category. The necessary detail depends on the authorized service logs available to the operator. This is not a request to expose raw tokens to support channels. A full cookie value can introduce unnecessary session material into another system when a lower-detail state description would answer the operational question.
The same separation applies to privacy decisions. A business can conclude that it needs a documented check for a security purpose while separately deciding what application records should be retained and who may access them. Completing the check does not settle those governance choices. Nor does a subsequent application denial prove that the browser disclosed no information earlier in the flow. Each stage has to be assessed for what it receives and decides, not only whether the final page loaded.
Encryption, visibility and data custody
The encrypted-token statement concerns how token contents are represented. It does not mean the browser interrogation never occurred. AWS explicitly describes scripts gathering information and putting results into the token. Collection, representation and later evaluation are separate stages. An opaque value can protect contents from some readers while still carrying meaningful session state for the service that issues and evaluates it.
This is why a token's unreadability to an ordinary page inspection is not proof of an absence of data. Equally, opacity is not evidence of any particular secret field. The public source establishes the existence of documented categories and the lack of a complete published contents description. A responsible assessment retains both facts: some collection is described, and the full representation is not independently established by those documents.
A browser-side log answers a different question. A source-attributed runtime event may show that a particular interface was read in a particular context. It does not reveal whether the result was included in aws-waf-token, retained elsewhere, discarded, transformed or used for a final decision. Those are data-flow and service-processing questions. Evidence for an earlier stage should not be stretched across a boundary where the observation ends.
The AWS description of SDK interaction makes this especially important for real user activity. An integration can involve meaningful interaction categories even when its full per-event schema is not documented. A collection assessment should establish the intended purpose, applicable configuration and parties handling the data. It should not fill the missing schema with assumptions from a different provider or from a generic fingerprinting demonstration.
Application records introduce another independently governed destination. An application might record a high-level request outcome, or a support system might receive diagnostic information during an investigation. These are examples of possible customer-side records, not claims that AWS creates those copies by default. Their retention and access controls belong to the systems that actually produce them. The token's encryption statement supplies no deletion promise for a customer database or support attachment.
The same caution applies to the non-unique-information statement. AWS's characterization should remain attributed, because it describes the vendor's claim about gathered information. An application's separate association with an account or transaction can alter the context in which data is handled. That does not prove the token alone identifies a person. It demonstrates why a business cannot complete its assessment using one vendor sentence detached from its own application relationships.
There is no provider-retention deadline established by the four AWS token and action pages cited here. That is a limit of this evidence set, not a finding of indefinite storage or improper processing. A real storage assessment needs the currently applicable agreement, policy and implementation evidence. The absence of a deadline in these pages should lead to a specific unanswered retention question, rather than an invented duration derived from 300 seconds or an unsupported accusation about the provider.
For a privacy-oriented data map, the useful columns are the participant, documented information category, processing purpose, representation and relevant storage commitment. The browser cookie and an application log should not automatically share one row merely because they relate to the same session. One is a named token representation; the other may be a customer-controlled record. Distinguishing them makes it possible to ask the appropriate owner for an actual access or deletion policy.
Browser controls and accountable privacy choices
BotBrowser documents profile-backed protection through native engine paths, rather than JavaScript injected into the page. This is relevant to the browser surface exposed to content and to consistency among documented profile-backed properties. A page-context modification operates at another layer. That architectural distinction does not determine which AWS integrations an application enables or how a provider interprets information it receives. Neither layer supplies an external retention policy or an application's lawful processing purpose.
The product boundary matters more than a vendor ranking. There is no evidence here comparing AWS outcomes under native browser controls and a patch-level tool. There is also no source-attributed runtime inventory of AWS API reads. The supported capability claim concerns documented browser-surface controls. The service-side limits concern tokens, policy and storage. Keeping those claims separate allows a privacy discussion without promising access or prescribing ways to change a site's security outcome.
For an application owner, the decision aid below starts with the question to be answered rather than a preferred tool. Its entries follow the AWS token, timing and action documentation. A browser setting can be relevant to one row without resolving the others. The evidence required for a privacy decision should follow the boundary that owns that decision.
| Question for an owned integration | First accountable evidence | Decision boundary |
|---|---|---|
| Is SDK interaction collection enabled? | Application integration inventory and current SDK documentation | Feature availability is not deployment proof |
| Why was another check requested? | Effective rule and web ACL timestamp policy | Freshness is not login state or deletion |
| Did the application authorize the operation? | Application permissions and its own request outcome | Token continuation is not authorization |
| What browser APIs actually executed? | Authorized, source-attributed V8 capture | API execution is not a complete remote-storage trace |
| How long are related records retained? | Applicable provider commitments and customer storage policies | Token immunity does not answer retention |
The session-versus-person distinction is useful when communicating the result to non-specialists. A cookie can associate events with a session without establishing a person's identity, and an application can hold additional context separately. The assessment should describe the associations that actually exist rather than switching between the labels “anonymous” and “identified” as if one token name decided every relationship in the system.
Collection minimization can then be evaluated against the intended security purpose. The documentation distinguishes browser interrogation from SDK interaction categories, so those categories should not be collapsed into a single unspecified “browser check.” The application owner needs to establish which paths are enabled and which product requirements they support. This is a review of the owner's integration, not an instruction to modify another site's checks or to assume that a different browser eliminates service-side association.
An authorized technical investigation should likewise avoid collecting real session material without need. A high-level outcome, a configuration fact or a deliberately scoped test capture may answer the question more appropriately than a production token copied into a ticket. This is a handling choice for the operator, not a claim about AWS's default support process. The principle follows from the fact that aws-waf-token represents session state and therefore deserves a more specific handling rationale than an ordinary decorative cookie label.
Frequently asked questions
Does an invisible challenge mean no information was gathered?
No. AWS documents browser interrogation by Challenge scripts and SDKs in its token characteristics. Visibility of a puzzle and existence of collection are different properties; the enabled integration still needs to be established for the application in question.
Does the 300-second default determine how long AWS stores related data?
No. The immunity setting governs timestamp freshness. These pages do not establish an end-to-end deletion deadline. Provider commitments and customer records require their own retention evidence.
Can a browser privacy tool replace the application's authorization checks?
No. The documented action flow continues through remaining rules when the applicable token is valid. Browser-surface consistency does not grant account permissions or control the receiving application's decisions.
Sources
- AWS WAF token characteristics
- CAPTCHA and Challenge action behavior
- How AWS WAF uses tokens
- Timestamp expiration and token immunity
- BotBrowser browser fingerprinting overview
Practical conclusion
Assess AWS WAF CAPTCHA as a documented session-token mechanism, not only a visible puzzle. Establish which browser and SDK collection paths the owned application enables, distinguish the two freshness clocks, and keep remaining web ACL and application decisions separate. Token encryption does not establish minimal collection or deletion, and a default immunity setting is not a retention promise. Before changing an integration, confirm its actual collection purpose and the applicable provider and customer storage boundaries with the owners responsible for them.
This article is part of the guide: What Is a Browser Fingerprint? Canvas Fingerprinting
Related Articles
AWS WAF Bot Control: What a Client Actually Sees
FingerprintFunCaptcha: Signals, Sessions and Privacy
FingerprinthCaptcha Privacy: Signals and Evidence Boundaries
FingerprintKasada Challenge Signals and Privacy Explained
NetworkCAPTCHA Types: What a Checkbox Actually Tells You
FingerprintCloudflare Turnstile: Signals and Privacy
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.