Token360 Data Inspection Header: Scope and Verification
Verify the Token360 data inspection header at the client and route boundaries. A prepared header does not prove retention, training or residency policy.
API INTEGRATION · REQUEST CONTROLS
By Yuki Yu · Documentation analysis and local request-construction check · Reviewed November 7, 2026
The Token360-DataInspection header requests documented upstream inspection behavior for supported generation routes. It is not a general privacy switch. Verify the header your application constructs, confirm support for the selected route, and keep retention, training and residency requirements separate. A successful generation does not verify all those conditions.
An integration can contain a setting called “private mode” while the underlying request changes only one header. That mismatch makes review harder: the interface appears to promise more than the implementation establishes. Name the setting after its actual scope and attach separate evidence to any broader requirement.
This article combines official documentation with six local Python request-construction cases. No request was sent to Token360 or an upstream provider. The recorded results inspect prepared headers only; they do not test content inspection, moderation, storage or data-policy enforcement.
Read first: Token360’s Security and Data Handling guide defines the control. This article focuses on its request-level integration and the evidence needed to describe it accurately.
What does the data inspection header actually specify?
Treat the header as a scoped request setting whose interpretation depends on the selected service route. Record the intended value separately from what the client constructs and what the service supports. Those are three different observations. A configuration flag, by itself, establishes neither delivery of the header nor the resulting upstream behavior.
As reviewed November 7, 2026, Token360 documentsToken360-DataInspection: true|false for generation requests. Omission defaults to false. Support varies by route, and models without a configured switch retain their upstream behavior. The documentation explicitly separates this control from retention, residency and training opt-outs.
Use the actual requirement in a review record. “Request the documented inspection setting on model/route X” is specific. “Make every copy of our data private” needs additional controls and commitments. The latter should not be reduced to a checkbox mapped to one request field.
Evidence
What it establishes
What remains unverified
Application configuration
The setting your application intends to use
Whether request construction preserves it
Prepared request headers
The header in that local request object
Transmission and remote handling
Applicable route documentation or confirmation
The stated support and scope
Behavior beyond that documented scope
Successful output
The request produced a usable response
Inspection, retention, training or location guarantees
Where does the value belong in an API request?
Place a documented HTTP header in the client’s request-header mechanism, rather than assuming an identically named JSON field will have the same effect. Then inspect the resulting request representation after defaults and per-call options are combined. Configuration location matters because a client can preserve a field while placing it in the wrong part of the request.
MDN’s HTTP header reference describes headers as request and response fields carrying additional information. A body parameter and a header are different parts of that message. Use the selected client library’s documented way to set custom headers; do not invent a Token360 payload parameter to stand in for one.
# Header fragment only — not a complete API request.
# Select the value according to the documented route and approved policy.
Token360-DataInspection: false
This fragment is not a recommendation to choose a particular policy. It shows the location and spelling of one documented request field. It contains no endpoint, model, authentication or generation payload, and should not be presented as a complete tested API example.
In application code, keep “not configured” separate from an explicit false value. A common conditional pattern adds a field only when its value is truthy. That can accidentally drop an explicit false setting. A later default-merge step can also overwrite a value that appeared correct earlier in the configuration path.
What did the six local construction cases show?
The local check showed that intended configuration and prepared headers can diverge before a network request exists. Three deliberately correct constructions preserved their declared intent; three deliberately flawed constructions did not. These are controlled examples of client assembly, not a measured defect rate for an SDK, Token360 or any upstream model service.
We executed
Copy header-construction-check.py:
"""Local request-construction demonstration. No API call or credential is used.
Python standard library only. Values are inspected in urllib Request objects,
not on a wire, at Token360, or at any upstream provider.
"""
import json
from urllib.request import Request
HEADER = 'Token360-DataInspection'
def explicit_headers(value):
return {} if value is None else {HEADER: 'true' if value else 'false'}
def prepare(headers, body):
request = Request('https://example.invalid/generation',
data=json.dumps(body).encode(), headers=headers, method='POST')
return {k.lower(): v for k, v in request.header_items()}.get(HEADER.lower())
cases = [
('explicit_true', 'true', explicit_headers(True), {}),
('explicit_false', 'false', explicit_headers(False), {}),
('intentional_omission', None, explicit_headers(None), {}),
('truthiness_bug_false', 'false', {HEADER:'false'} if False else {}, {}),
('body_only_false', 'false', {}, {HEADER: False}),
('later_default_overwrites_false', 'false',
{**explicit_headers(False), **{HEADER: 'true'}}, {}),
]
results = []
for name, expected, headers, body in cases:
observed = prepare(headers, body)
results.append({'case': name, 'intended_header': expected,
'prepared_header': observed,
'matches_declared_intent': observed == expected})
assert [r['matches_declared_intent'] for r in results] == [True, True, True, False, False, False]
if __name__ == '__main__':
print(json.dumps({'scope':'local urllib Request objects only; no network or credentials',
'cases':results}, indent=2))
on November 7, 2026. It constructs urllib.request.Request objects addressed to example.invalid, reads their header entries and never opens a connection. It uses no API key. The
The script deliberately includes mistakes to make the distinction observable. It does not show that an actual Token360 integration has those mistakes. It also does not model the service’s defaulting rules or any upstream control.
Because the documented omitted value is currently false, dropping an explicit false header does not by itself prove different service behavior. The finding is narrower: the client lost its explicit instruction. That distinction is useful when reviewing configuration precedence, future changes or a shared wrapper used by several clients.
For your application, inspect the final prepared request produced by the real library and wrapper rather than copying this example’s construction code as a production adapter. The useful property is preservation of declared intent at that boundary, not use of a particular Python class.
Why does a correctly prepared header not finish verification?
A local request object is evidence about the client at a specific point. It cannot observe later middleware, network transmission, gateway interpretation or the selected upstream route. Continue verification at the boundaries your team can inspect, and obtain scoped service evidence for the parts it cannot. Keep unknown behavior explicitly unknown.
For example, an application could prepare the expected header and then pass the request through another wrapper that reconstructs the header set. Our local script does not exercise such a wrapper. It therefore cannot prove that the actual integration sends the same fields or that a remote service interprets them as intended.
The local experiment checks construction only. A complete integration review needs evidence appropriate to each later boundary.
Token360’s routing documentation distinguishes a public model identifier from its eligible service routes. Record the model, endpoint and relevant account configuration when asking whether a control is supported. Do not generalize one route’s documented behavior to every model or media workflow.
A useful confirmation request is: “For this model, endpoint and account configuration, is this header supported, what behavior does each value request, and what happens when the route lacks the switch?” Ask for the answer’s scope and date. Do not request a universal privacy assurance when the unresolved issue is a specific route capability.
How should a team record the requirement without overclaiming?
Separate what the business requires, what the application requests and what the evidence confirms. Each row should identify a subject and an owner. This prevents a correctly configured request option from being promoted into a claim about storage, training or geography that nobody has actually verified for the workload.
A proposed integration record could contain:
Field
Example entry type
Evidence owner
Workload scope
Model ID, endpoint, environment and feature
Application owner
Requested setting
Explicit value or deliberate omission
Configuration owner
Client construction
Sanitized prepared-header inspection
Integration engineer
Route support
Dated documentation or scoped confirmation
Platform contact
Separate data requirements
References to approved retention, training and location decisions
Relevant internal reviewer
Open questions
Unknown behavior and the next verification step
Named follow-up owner
This is a proposed record format, not a completed account assessment. Use “unconfirmed” when evidence is missing. A generated asset or an HTTP success response should not fill a policy-confirmation cell simply because it is the only screenshot available.
For geographic requirements, continue with the data-residency scope guide. Keep that review separate rather than expanding this header article into a second residency checklist. The same principle applies to retention and training decisions: link the appropriate approved record instead of duplicating an unsupported promise.
What should change when the model, client or route changes?
Recheck the boundary affected by the change instead of treating an old screenshot as permanent evidence. A client upgrade can change request assembly; a configuration update can change precedence; a model or route change can alter support. Preserve the original review scope so that the team can identify which evidence needs to be renewed.
A practical release check can inspect the intended value and final header without submitting real customer content. If an authorized remote check is needed, agree on a non-sensitive payload, the exact question being tested and any expected cost. Do not use a prohibited-content experiment as a proxy for understanding a documented setting.
When the requirement is mandatory but support remains unresolved, escalate the configuration decision rather than silently declaring it satisfied. Record the limitation in the handoff to the application owner. Any decision to proceed should be based on the actual workload requirements, not on a generic success indicator.
Keep logs narrow. Record the setting and relevant request reference when appropriate, but avoid dumping authorization headers, input content or signed asset URLs into the review file. The goal is to preserve useful integration evidence without creating an unnecessary new copy of sensitive material.
Frequently asked questions
Can I call this setting “private mode” in my interface?
That name is broader than the documented control. Prefer a scoped label and explain what has been confirmed. Only make broader claims when separate evidence supports them.
Does a missing header prove the request failed?
No. A construction mismatch and a remote failure are different findings. Compare the intended configuration with the service’s documented defaults before describing any behavioral consequence.
Did the local script test an upstream provider?
No. It only inspected local request objects. It made no network calls and used no credentials, so it cannot establish any provider’s inspection behavior.
Can a successful generation verify the data-handling requirement?
It verifies a functional result, not every condition under which that result was produced. Obtain evidence that addresses the requirement itself.
Read next: use Security and Data Handling for the current control definition, and Routing and Reliability when reviewing route scope. About Token360 provides platform context; this article does not certify a customer configuration or establish a contractual data guarantee.
Developer Guide
API
Bring your next idea to life.
Create a video scene in Creator, or explore models for images, audio, and text to find the right capabilities for your project.