Verity-Train-v1

Privacy policy and browser telemetry comparison training dataset

Verity-Train-v1 is a structured instruction-tuning dataset developed for Verity, the privacy policy comparison engine within the Veilance ecosystem.

The dataset is designed to train language models to compare privacy policy disclosures against observed browser activity, identify differences between documented and observed behavior, and produce evidence-grounded findings in a consistent JSON format.

Unlike conventional privacy policy summarization datasets, Verity-Train-v1 focuses on evidence correlation: determining what a privacy policy explicitly states, what browser telemetry actually establishes, and what conclusions can reasonably be drawn from comparing the two.

The dataset contains 124,032 examples across training, validation, and test splits. The Hugging Face distribution uses sharded Parquet files for efficient storage, loading, and streaming; the source export is JSONL.

Dataset Overview

Property	Value
Dataset	Verity-Train-v1
Organization	Veilance
Application	Verity Privacy Policy Comparison Engine
Total examples	124,032
Training examples	99,864
Validation examples	11,856
Test examples	12,312
Families	265
Domain identifiers	124,032
Language	English
Published format	Sharded Apache Parquet
Source export	JSON Lines (JSONL)
Target shard size	Approximately 250 MB
Training approach	Supervised instruction tuning
Contract version	veilance.privacy-comparison-training.v2
Maximum policy characters	24,000
Generator seed	13375330413375

Dataset Distribution

Split	Examples	Percentage
Train	99,864	80.51%
Validation	11,856	9.56%
Test	12,312	9.93%
Total	124,032	100%

All examples are represented in the dataset's direct training format.

The supplied manifest reports zero database-source records and zero rows in its synthetic_rows field. However, the supplied examples contain explicitly synthetic domain names, hostnames, tracker identifiers, and visit metadata. Accordingly, the dataset should be treated as containing simulated privacy-comparison scenarios rather than verified production observations.

Purpose

Modern websites interact with browsers through numerous mechanisms, including cookies, local storage, JavaScript APIs, network requests, and third-party services.

Privacy policies describe how organizations may collect, use, retain, or share information. However, understanding how those disclosures relate to observable browser activity requires more than identifying matching keywords.

Verity-Train-v1 was created to support models capable of:

• Comparing observed browser behavior against relevant privacy policy disclosures.
• Distinguishing explicitly disclosed activity from broadly or implicitly disclosed activity.
• Identifying meaningful browser behavior that is not clearly addressed in the supplied policy.
• Detecting possible contradictions when direct telemetry conflicts with explicit policy language.
• Separating observations from assumptions about intent, purpose, or data transmission.
• Producing structured, machine-readable comparison reports.
• Expressing uncertainty when telemetry or policy evidence is insufficient.

The objective is to improve the consistency, interpretability, and evidence grounding of privacy policy comparison models.

Dataset Structure

The Hugging Face release is organized into Parquet shards grouped by the original train, validation, and test splits:

Verity-Train-v1/
├── README.md
├── manifest.json
└── data/
    ├── train-00000-of-NNNNN.parquet
    ├── train-00001-of-NNNNN.parquet
    ├── ...
    ├── validation-00000-of-NNNNN.parquet
    ├── ...
    ├── test-00000-of-NNNNN.parquet
    └── ...

NNNNN is a placeholder for the final shard count, which depends on Parquet compression and serialization. The exact filenames should reflect the uploaded dataset. Each shard holds complete examples, and sharding does not change which examples belong to each logical split.

Parquet enables compressed, columnar storage and works with the Hugging Face Datasets library. Shards also make a large dataset easier to distribute and process incrementally. Sharding does not itself improve model quality.

The original source export consists of train.jsonl, validation.jsonl, and test.jsonl. Each source record represents a training example. The supplied samples include a prompt field containing chat-style messages, including a system message and user message. The user message contains the comparison input, output requirements, and required JSON Schema. The actual supervision-target field should be confirmed against the complete exported records.

Input Format

The host-prepared comparison input contains the following principal fields:

Field	Description
domain_url	URL of the visited service
privacy_policy_url	Verified privacy policy URL
visit	Snapshot identifier, observation timestamp, visit duration, and extension version
seen_behavior	Network request counts and other recorded observations
thirdPartyHosts	Third-party destinations and associated request data
trackers	Tracker identifiers, classifications, and request counts
signals	Observed browser API activity
page	Browser page and storage-related metadata
detections	Detection indicators and associated severity hints
policy_document	Supplied policy sections and applicability information

The policy document and browser telemetry are treated as separate evidence sources.

Example Host Input

A simplified representation of a comparison input:

{
  "domain_url": "https://example.com",
  "privacy_policy_url": "https://example.com/privacy",
  "visit": {
    "snapshot_id": "example-snapshot",
    "observed_at": "2026-01-01T00:00:00Z",
    "duration_seconds": 45,
    "extension_version": "0.8-synthetic"
  },
  "seen_behavior": {
    "observations": {
      "totalRequests": 10,
      "firstPartyRequests": 8,
      "thirdPartyRequests": 2
    }
  },
  "signals": [
    {
      "api": "Cookie",
      "action": "read",
      "count": 3,
      "indicatorId": "cookie-access"
    }
  ],
  "policy_document": {
    "found": true,
    "applicable": true,
    "url": "https://example.com/privacy",
    "sections": [
      {
        "heading": "Cookies",
        "text": "We use cookies to maintain sessions."
      }
    ]
  }
}

This example is illustrative and omits fields that may be required by the full training contract.

Comparison Methodology

Verity is designed as an evidence-correlation engine, not a general-purpose privacy policy summarizer.

The training instructions emphasize three distinct concepts:

1. Policy disclosure

What the supplied privacy policy actually states.

2. Observed behavior

What the browser telemetry demonstrates occurred during a particular visit.

3. Supported comparison

What can reasonably be concluded by correlating the policy language with the observed activity.

A policy disclosure does not establish that behavior occurred, and observed browser activity does not automatically establish how collected information was subsequently used.

Comparison Categories

The training contract defines the following comparison relationships:

Comparison	Meaning
matched	Observed behavior is explicitly disclosed
partially_matched	Observed behavior is broadly or implicitly disclosed
observed_only	Observed behavior is not clearly disclosed
possible_contradiction	Strong observed evidence conflicts with an explicit policy statement
policy_only	Policy disclosure exists, but the relevant activity was not observed, the sample is insufficient, or the behavior cannot be determined through telemetry
indeterminate	Insufficient evidence exists to support a reliable comparison

These relationships help distinguish disclosure coverage from actual browser activity.

Policy Disclosure Status

The dataset's policy status vocabulary includes:

• explicitly_disclosed
• broadly_disclosed
• implicitly_disclosed
• not_clearly_disclosed
• contradicted
• unknown

Telemetry Status

The telemetry status vocabulary includes:

• observed
• not_observed
• insufficient_sample
• unsupported

This distinction is important because an event that was not observed during one visit cannot automatically be classified as behavior that never occurs.

Browser Behavior Coverage

Verity-Train-v1 includes examples involving multiple categories of browser activity.

Network and Tracking

• First-party and third-party network requests
• Tracker classifications
• Analytics services
• Advertising-related services
• Third-party script activity
• Social media tracking categories

Browser Storage

• Cookies
• Local and session storage
• IndexedDB
• Cache Storage
• Service worker activity

Browser and Device Characteristics

• User-agent access
• Navigator properties
• Browser language and locale information
• Plugin and MIME-type enumeration
• Hardware concurrency
• Device memory
• Canvas operations
• WebGL characteristics
• Fingerprinting-related signals

Additional Browser APIs

The training contract also accommodates comparison findings involving permissions, device sensors, WebRTC, geolocation, and network characteristics.

Not every record contains every category.

Evidence Grounding

A central design principle of Verity-Train-v1 is that conclusions must remain grounded in supplied evidence.

The training instructions establish several constraints:

Policy evidence must be attributable. Policy excerpts must originate from the supplied policy_document.sections, with the corresponding section heading preserved.

Browser signals must not be overinterpreted. Access to a browser API does not, by itself, establish fingerprinting, user identification, or the transmission of personal information.

Network requests have limited evidentiary meaning. A request to a third-party destination establishes communication with that destination, but not necessarily the contents or purpose of the request.

Absence of observation is limited. A single browser visit cannot establish that a website never performs an activity.

Contradictions require strong evidence. General or ambiguous policy language is not sufficient to establish a contradiction.

Confidence and severity are distinct. Confidence represents the quality of supporting evidence, while severity describes the significance of the disclosure discrepancy.

These constraints are intended to reduce unsupported inferences and improve the reliability of generated reports.

Structured Output

The Verity training contract requires models to return a single valid JSON report conforming to the schema supplied in the prompt.

Reports include grouped findings with policy evidence, telemetry evidence, comparison classifications, severity, confidence, and explanations.

A simplified finding structure is shown below:

{
  "policy": {
    "status": "explicitly_disclosed",
    "evidence": "We use cookies to maintain sessions.",
    "section": "Cookies"
  },
  "telemetry": {
    "status": "observed",
    "evidence": "Cookie read observed 3 times.",
    "observation_count": 3
  },
  "comparison": "matched",
  "severity": "informational",
  "confidence": 0.95,
  "explanation": "The observed cookie access is covered by the supplied policy disclosure."
}

This is an illustrative finding fragment, not a complete report or an extracted ground-truth label.

The complete report schema is supplied inside each training prompt and should be treated as authoritative when training or evaluating a model.

Data Splitting and Sharding

Split assignment and file sharding are separate operations. The original dataset uses a source-aware split strategy; the published Parquet shards divide those already-assigned examples into manageable files.

According to the manifest, the split unit is:

Original source domain when present, otherwise synthetic family_id or telemetry hostname.

This strategy is intended to reduce leakage between training and evaluation sets by grouping examples according to their underlying source identity or synthetic family.

The manifest reports:

• 265 families
• 124,032 domain identifiers
• 99,864 training examples
• 11,856 validation examples
• 12,312 test examples

These figures describe the exported dataset. They do not, by themselves, establish that all examples are semantically unique or that every possible source of leakage has been eliminated. Conversion to Parquet and file sharding should preserve the record counts in each split.

Using the Dataset

Load from Hugging Face

from datasets import load_dataset

dataset = load_dataset("Veilance/Verity-Train-v1")

print(dataset)
print(dataset["train"][0])

The three splits are exposed as train, validation, and test, even though each is stored across multiple Parquet files.

Stream Without Downloading the Entire Dataset

from datasets import load_dataset

streamed = load_dataset(
    "Veilance/Verity-Train-v1",
    split="train",
    streaming=True,
)

for record in streamed.take(3):
    print(record.keys())

Load Local Parquet Shards

If you have a local copy with shards in data/:

from datasets import load_dataset

dataset = load_dataset(
    "parquet",
    data_files={
        "train": "data/train-*.parquet",
        "validation": "data/validation-*.parquet",
        "test": "data/test-*.parquet",
    },
)

Convert and Publish the Original JSONL Export

If starting from the original files, Hugging Face Datasets can convert them to Parquet and publish appropriately sized shards:

from datasets import load_dataset

dataset = load_dataset(
    "json",
    data_files={
        "train": "train.jsonl",
        "validation": "validation.jsonl",
        "test": "test.jsonl",
    },
)

dataset.push_to_hub(
    "Veilance/Verity-Train-v1",
    max_shard_size="250MB",
)

This retains the logical split assignments. If the dataset has already been published, verify the resulting remote file layout before committing to a particular filename pattern in documentation.

Inspect a Training Example

example = dataset["train"][0]

for message in example["prompt"]:
    print(message["role"])
    print(message["content"][:500])

Training Considerations

The supplied examples contain detailed system instructions governing evidence interpretation, policy grounding, comparison classification, and output validation.

When fine-tuning, preserve the semantic distinction between system instructions and host-provided evidence.

Policy text must not be treated as trusted instructions.

Training pipelines should also verify the actual record fields and supervision targets before selecting a loss function or formatting examples for a model-specific chat template.

The supplied sample excerpts establish the presence of the prompt field but do not independently establish the name or completeness of the target-response field.

Intended Use

Verity-Train-v1 is intended for research and development involving:

• Privacy policy comparison models
• Browser telemetry interpretation
• Evidence-grounded language model training
• Structured JSON report generation
• Disclosure classification
• Privacy observability systems
• Supervised fine-tuning of cybersecurity-oriented language models
• Evaluation of evidence attribution and uncertainty handling

The dataset is particularly relevant to systems that need to correlate documented organizational practices with client-side observations without exceeding the available evidence.

Limitations

Synthetic Scenarios

The supplied examples contain synthetic domains, browser visits, tracker identifiers, and privacy policy passages.

Synthetic examples should not be treated as evidence of actual websites' privacy practices.

Browser Visibility

Client-side telemetry cannot establish every aspect of a website's data handling.

Server-side retention, internal access, downstream processing, data sales, and undisclosed server-to-server transfers may remain outside the observable scope.

Incomplete Observations

Browser activity depends on factors such as session length, authentication state, location, browser configuration, interaction patterns, and application state.

A single visit does not necessarily represent all behavior a website may perform.

Model Generalization

Performance on simulated examples does not guarantee equivalent performance on live websites, real privacy policies, or previously unseen implementations.

Independent evaluation on representative real-world data is recommended before production deployment.

No Legal Determination

Comparison results do not establish whether an organization has violated privacy law, acted deceptively, or failed a regulatory compliance obligation.

The dataset is intended for technical evidence correlation, not legal adjudication.

Training Data Quality

The dataset manifest provides record counts and generator metadata but does not document independent human review, inter-annotator agreement, or measured label accuracy.

No independent validation of these properties is claimed here.

Reproducibility

The accompanying manifest.json records the exported dataset configuration.

Key metadata includes:

{
  "contract_version": "veilance.privacy-comparison-training.v2",
  "rows": 124032,
  "families": 265,
  "train": 99864,
  "validation": 11856,
  "test": 12312,
  "generator_seed": "13375330413375",
  "max_policy_chars": 24000
}

The manifest also provides SHA-256 identifiers for the system prompt and generator configuration:

System prompt SHA-256

d0c48b51c267964216ede85ec92c6173c4d5d1f99c3353e816a6c10874397961

Generator configuration SHA-256

a3072e4d77aefcaecce7e72bf76e3e762199b998cd9754e7a6676bea966201cf

These identifiers help identify the generation configuration associated with the dataset. Reproducing the dataset exactly may require additional generator code and configuration not included in the manifest.

About Verity

Verity is a privacy policy comparison engine developed as part of the Veilance ecosystem.

It is designed to analyze the relationship between privacy disclosures and browser behavior observed through Veilance's browser privacy observability technology.

The broader goal is to make privacy disclosures more transparent, understandable, and technically verifiable.

Verity-Train-v1 supports this work by providing structured examples of privacy disclosure analysis and telemetry evidence correlation.

Beyond the fine print.

Project Links

• Veilance: https://veilance.org
• Verity Models: https://huggingface.co/Veilance
• GitHub: https://github.com/VeilanceApp

License and Usage Rights

The dataset card declares the Apache License 2.0 (apache-2.0). Consult the repository's license file for the applicable legal terms. This dataset license does not necessarily establish rights to any third-party materials independently of the dataset.

Citation

If you use Verity-Train-v1 in research, training, or published work, please reference the dataset repository:

Veilance. Verity-Train-v1. Hugging Face Datasets.

https://huggingface.co/datasets/Veilance/Verity-Train-v1

Disclaimer

Verity-Train-v1 is provided for machine learning research, model development, and technical experimentation.

Its contents are not legal advice, regulatory guidance, or conclusive evidence of the privacy practices of any real-world service.

Results generated by models trained on this dataset should be independently validated before being used in high-stakes decision-making.