Dift

Dift is an open-source CLI platform for dataset comparison, drift detection, and data trust validation.

It helps data teams instantly understand:

what changed
why it matters
whether the new data is safe to trust

What's New in v0.5.0

Dift v0.5.0 introduces advanced drift analysis, outlier detection, reusable configurations, saved comparison profiles, improved reporting, and stronger dataset risk analysis.

New Features

Numeric drift detection
Advanced categorical drift analysis
Outlier detection using IQR analysis
Outlier severity classification
Outlier risk scoring
Frequency distribution shift detection
Numeric drift reporting across all report formats
Improved Excel reporting
Improved HTML reporting
Better CSV drift summaries
Enhanced weighted risk scoring
Improved warning system
Better drift visibility in console reports

Why Dift?

Bad data breaks:

dashboards
reports
ETL pipelines
analytics workflows
ML models
business decisions

Dift helps teams catch risky data changes before they cause damage.

Features (v0.5.0)

Supported Formats

CSV
Parquet
Excel (.xlsx, .xls)
JSON

Drift Detection

Numeric Drift

Mean shift detection
Standard deviation drift
Range shift detection
Configurable drift thresholds
Severity classification

Categorical Drift

New categorical value detection
Removed categorical value detection
Frequency distribution shifts
Severity classification

Outlier Detection

IQR outlier detection
Outlier spike detection
Outlier percentage tracking
Risk integration

Output Options

Rich CLI report
JSON report
CSV summary report
Excel workbook report
HTML dashboard-style report

HTML Templates

Customize your HTML reports:

dift old.csv new.csv --report html --template clean

Available templates:

default
clean
compact
enterprise
dark

Numeric Drift Thresholds

Control drift sensitivity using --threshold.

Default threshold:

0.1

Example:

dift old.csv new.csv --key id --threshold 0.2

This helps detect silent numeric drift in:

ML datasets
ETL pipelines
analytics tables
production data feeds

Output Directory Support

Save reports to a directory without specifying filenames:

dift old.csv new.csv --report json --output-dir reports/

Auto-generated filenames:

dift_report.json
dift_report.csv
dift_report.xlsx
dift_report.html

Configuration System

Dift supports reusable configuration files for cleaner and reproducible workflows.

dift old.csv new.csv --config examples/config_sample.yaml

Supported Formats

YAML (.yaml, .yml)
TOML (.toml)
JSON (.json)

Example YAML Config

old_dataset: "example/old.csv"
new_dataset: "examples/new.csv"
key: "customer_id"
threshold: 0.05
report: "html"

Example TOML Config

old_dataset = "examples/old.csv"
new_dataset = "examples/new.csv"
key = "customer_id"
threshold = 0.1
report = "json"

Example JSON Config

{
  "old_dataset": "examples/old.csv",
  "new_dataset": "examples/new.csv",
  "key": "customer_id",
  "threshold": 0.2,
  "report": "csv"
}

Dataset Paths in Config Files

Dift can also load dataset paths directly from config files.

This means you can run a comparison without typing the old and new dataset paths in the terminal every time.

dift --config examples/config_with_datasets.yaml

YAML Example

old_dataset: examples/old.csv
new_dataset: examples/new.csv
key: customer_id
threshold: 0.2
report: html
output: reports/config_report.html

CLI Override Example

CLI arguments still override config values.

dift examples/old_drift.csv examples/new_drift.csv \
  --config examples/config_with_datasets.yaml \
  --report json \
  --output override_report.json

In this case, Dift uses:

datasets from the CLI
report/output from the CLI
remaining values from the config file

Reusable Threshold Configurations

Dift supports reusable threshold policies for advanced drift detection workflows.

Threshold configurations help teams:

standardize drift sensitivity
customize validation rules
apply column-specific policies
reuse validation settings across environments

Global Threshold Configuration

thresholds:
  numeric: 0.1
  categorical: 0.2
  outlier: 0.15

Column-Level Threshold Overrides

thresholds:
  numeric: 0.1
  categorical: 0.2
  outlier: 0.15

  columns:
    revenue:
      numeric: 0.05
      outlier: 0.1

    segment:
      categorical: 0.3

Full Threshold Config Example

old_dataset: examples/old.csv
new_dataset: examples/new.csv

key: customer_id
report: html
output: reports/threshold_report.html

thresholds:
  numeric: 0.1
  categorical: 0.2
  outlier: 0.15

  columns:
    revenue:
      numeric: 0.05
      outlier: 0.1

    status:
      categorical: 0.3

Run Using Threshold Configs

dift --config examples/config_thresholds.yaml

CLI Threshold Override

CLI thresholds still override global numeric thresholds for backward compatibility.

dift --config examples/config_thresholds.yaml --threshold 0.5

This overrides:

thresholds:
  numeric: 0.1

But preserves:

categorical thresholds
outlier thresholds
column-level overrides

Supported Threshold Types

Threshold Type	Purpose
numeric	Numeric drift detection
categorical	Frequency shift detection
outlier	Outlier spike detection
columns	Column-specific overrides

Example Use Cases

Sensitive Revenue Monitoring

columns:
  revenue:
    numeric: 0.02

Detect even small revenue drift changes.

Relaxed Categorical Drift

columns:
  segment:
    categorical: 0.4

Reduce noise for highly variable categorical fields.

Strict Outlier Detection

columns:
  transactions:
    outlier: 0.05

Catch abnormal spikes aggressively.

Environment-Based Configurations

Dift supports reusable environment-specific configurations for development, staging, and production workflows.

This helps teams maintain different comparison settings across environments while keeping configs clean and reusable.

Select an Environment

dift --config examples/config_env.yaml --env development

Example Environment Config

YAML

key: customer_id
report: html
output: reports/env_report.html

environments:
  development:
    old_dataset: examples/old.csv
    new_dataset: examples/new.csv
    threshold: 0.2

  staging:
    old_dataset: staging_old.csv
    new_dataset: staging_new.csv
    threshold: 0.15

  production:
    old_dataset: ${OLD_DATASET}
    new_dataset: ${NEW_DATASET}
    threshold: 0.1

Environment Variable Support

Dift supports environment variable interpolation inside config files.

Example:

old_dataset: ${OLD_DATASET}
new_dataset: ${NEW_DATASET}

Set variables before running Dift.

Git Bash / Linux / Mac

export OLD_DATASET=examples/old.csv
export NEW_DATASET=examples/new.csv

PowerShell

$env:OLD_DATASET="examples/old.csv"
$env:NEW_DATASET="examples/new.csv"

Then run:

dift --config examples/config_env.yaml --env production

Missing Environment Variables

If a required environment variable is missing, Dift shows a helpful error.

Example:

Error: Missing environment variable 'OLD_DATASET'

Environment Workflow Benefits

Environment configs help support:

development workflows
staging validation
production deployment checks
CI/CD pipelines
secret management preparation
reusable automation workflows

Saved Comparison Profiles

Dift supports reusable saved comparison profiles.

Profiles help automate recurring dataset checks and validation workflows.

Create a Profile

dift profile create nightly-check \
  --old examples/old.csv \
  --new examples/new.csv \
  --key customer_id \
  --report html \
  --threshold 0.1

Run a Profile

dift profile run nightly-check

List Profiles

dift profile list

Show Profile Details

dift profile show nightly-check

Delete a Profile

dift profile delete nightly-check

Configuration Priority

Dift resolves settings using:

CLI arguments > Saved Profiles > Config Files > Defaults

This makes Dift flexible for:

automation
CI/CD pipelines
scheduled validations
reusable workflows

Batch Dataset Comparison

Dift supports batch comparison workflows for validating multiple dataset pairs in one command.

This is useful for:

ETL validation pipelines
scheduled dataset monitoring
multi-table warehouse checks
automated regression testing

Folder Structure Example

data/
├── old/
│   ├── customers.csv
│   ├── orders.csv
│   └── products.csv
│
└── new/
    ├── customers.csv
    ├── orders.csv
    └── products.csv

Dift automatically matches files by filename.

Example:

old/customers.csv <--> new/customers.csv
old/orders.csv <--> new/orders.csv

Run Batch Comparison

dift batch \
  --old-dir data/old \
  --new-dir data/new \
  --key id

Generate Batch HTML Reports

dift batch \
  --old-dir data/old \
  --new-dir data/new \
  --key id \
  --report html \
  --output-dir reports/batch

Example output structure:

reports/
└── batch/
    ├── customers/
    │   └── dift_report.html
    ├── orders/
    │   └── dift_report.html
    └── products/
        └── dift_report.html

Batch CSV Reports

dift batch \
  --old-dir data/old \
  --new-dir data/new \
  --report csv \
  --output-dir reports/csv

Continue On Error

By default, Dift continues running other comparisons even if one fails.

dift batch \
  --old-dir data/old \
  --new-dir data/new \
  --continue-on-error

Stop immediately on first failure:

dift batch \
  --old-dir data/old \
  --new-dir data/new \
  --stop-on-error
old_dataset: "examples/old.csv"
new_dataset: "examples/new.csv"
key: "customer_id"
threshold: 0.05
report: "html"

Comparison History

Dift supports persistent comparison history tracking.

This helps teams monitor:

dataset drift over time
recurring quality issues
historical risk changes
long-term data trust trends

Save Comparison History

dift examples/old.csv examples/new.csv \
  --key customer_id \
  --history

By default, history is saved to:

.dift/history/history.jsonl

Custom History Directory

dift examples/old.csv examples/new.csv \
  --key customer_id \
  --history \
  --history-dir reports/history

View Saved History

dift history list

Example output:

1. 2026-05-15T12:30:00Z | risk=medium | old.csv -> new.csv
2. 2026-05-16T08:10:00Z | risk=high | prod.csv -> staging.csv

Show Detailed History Record

dift history show 1

Clear History

dift history clear

Batch Comparison History

Save history during batch workflows:

dift batch \
  --old-dir data/old \
  --new-dir data/new \
  --history \
  --history-dir reports/batch-history

Example structure:

reports/
└── batch-history/
    ├── customers/
    │   └── history.jsonl
    ├── orders/
    │   └── history.jsonl
    └── products/
        └── history.jsonl

Configuration Priority

Dift follows a strict priority chain to give you maximum flexibility:

CLI Arguments (Highest priority, overrides everything)
Configuration File (YAML, TOML, or JSON)
Internal Defaults (Threshold: 0.1, Report: console)

Scheduled Comparisons

Dift supports reusable scheduled comparison workflows for automation, monitoring, CI/CD pipelines, and recurring data quality checks.

This makes it easy to:

run nightly drift checks
automate production dataset validation
integrate with cron jobs
schedule profile-based comparisons
build monitoring workflows

Create a Reusable Profile

First create a comparison profile:

dift profile create nightly-check \
  --old examples/old.csv \
  --new examples/new.csv \
  --key customer_id \
  --report html \
  --output reports/nightly.html

This saves all comparison settings into a reusable profile.

Generate a Cron Schedule

Generate a cron-ready command:

dift schedule cron nightly-check

Example output:

0 2 * * * dift profile run nightly-check --history --strict-exit-codes

This means:

run every day
at 2:00 AM
save comparison history
use automation-friendly exit codes

Custom Schedule Times

Generate a custom cron schedule:

dift schedule cron nightly-check \
  --hour 5 \
  --minute 30

Output:

30 5 * * * dift profile run nightly-check --history --strict-exit-codes

Runs daily at 5:30 AM.

Save Scheduled Jobs

Create a named schedule:

dift schedule create daily-check \
  --profile nightly-check \
  --cron "0 2 * * *"

List Saved Schedules

dift schedule list

Example:

- daily-check

Show Schedule Details

dift schedule show daily-check

Example output:

{
  "profile": "nightly-check",
  "cron": "0 2 * * *"
}

Run a Schedule Manually

You can manually trigger a saved schedule:

dift schedule run daily-check

This runs the associated profile immediately.

Delete a Schedule

dift schedule delete daily-check

Example Cron Integration (Linux/macOS)

Open your crontab:

crontab -e

Add:

0 2 * * * dift profile run nightly-check --history --strict-exit-codes

Example Windows Task Scheduler

Use the generated command:

dift profile run nightly-check --history --strict-exit-codes

inside:

Windows Task Scheduler
Jenkins
GitHub Actions
Airflow
Prefect
Dagster
CI/CD pipelines

Automation-Friendly Exit Codes

Dift supports optional risk-based exit codes for automation workflows.

By default, Dift exits with:

when comparisons complete successfully.

Enable strict automation behavior with:

dift prod.csv candidate.csv \
  --key id \
  --strict-exit-codes

Exit Code Mapping

Exit Code	Meaning
`0`	Low-risk comparison
`1`	Medium-risk drift detected
`2`	High-risk drift detected
`3`	Runtime error, invalid input, or failed comparison

This allows Dift to automatically fail pipelines when risky dataset changes are detected.

Example

dift prod.csv staging.csv \
  --key customer_id \
  --strict-exit-codes

echo $?

Example output:

This means Dift detected a high-risk dataset change.

Backward Compatibility

Strict exit codes are optional.

Without --strict-exit-codes, Dift preserves the original behavior and exits successfully when comparisons complete.

Non-Interactive CLI Support

Dift supports automation-friendly execution for CI/CD pipelines, cron jobs, Airflow, Jenkins, GitHub Actions, and scheduled workflows.

Quiet Mode

Suppress non-error output:

dift old.csv new.csv \
  --key id \
  --quiet

This is useful for:

cron jobs
CI/CD pipelines
scheduled validation workflows
automated monitoring

Errors will still be displayed.

Disable Colored Output

Disable ANSI terminal colors for cleaner logs:

dift old.csv new.csv \
  --key id \
  --no-color

Useful for:

log aggregation systems
CI logs
plain-text terminals
automation tools

Fully Automation-Friendly Example

dift old.csv new.csv \
  --key id \
  --strict-exit-codes \
  --quiet \
  --no-color

This combination provides:

predictable exit codes
machine-friendly output
clean CI logs
non-interactive execution behavior

Scheduled Workflow Example

dift schedule cron nightly-check

Example output:

0 2 * * * dift profile run nightly-check --history --strict-exit-codes --quiet --no-color

DuckDB Support

Dift supports comparing datasets directly from DuckDB databases.

This enables warehouse-style comparisons, SQL-based validation, and Parquet-backed analytical workflows.

Compare DuckDB Tables

dift duckdb:///examples/warehouse.duckdb:customers_old \
     duckdb:///examples/warehouse.duckdb:customers_new \
     --key customer_id

URI Format

duckdb:///path/to/database.duckdb:table_name

Example

duckdb:///data/warehouse.duckdb:orders

Works With

existing risk scoring
HTML reports
Excel reports
JSON reports
CSV reports
drift detection
quality validation

Common Use Cases

local analytics warehouses
Parquet validation workflows
SQL-based dataset comparison
batch data quality checks

Notes

DuckDB database files must exist locally.
Remote DuckDB connections are not currently supported.
Table names may be case-sensitive depending on configuration.
DuckDB comparisons use the existing Dift comparison engine and reports.

BigQuery Support

Dift supports comparing datasets directly from Google BigQuery.

This enables cloud warehouse validation, analytical comparisons, and SQL-driven data quality workflows.

Compare BigQuery Tables

dift bigquery://my-project.analytics.customers_old \
     bigquery://my-project.analytics.customers_new \
     --key customer_id

URI Format

bigquery://project.dataset.table

Example

bigquery://acme-analytics.sales.orders

Authentication

Dift uses standard Google Cloud authentication.

Set your service account credentials:

Linux / macOS

export GOOGLE_APPLICATION_CREDENTIALS="/path/to/service-account.json"

Windows Git Bash

export GOOGLE_APPLICATION_CREDENTIALS="C:/path/to/service-account.json"

Install Dependencies

pip install google-cloud-bigquery db-dtypes

Works With

existing risk scoring
HTML reports
Excel reports
JSON reports
CSV reports
drift detection
quality validation

Common Use Cases

cloud warehouse validation
production dataset monitoring
analytics QA workflows
cross-environment data comparison
SQL-driven data quality checks

Notes

BigQuery access requires valid Google Cloud credentials.
BigQuery billing and permissions are managed through Google Cloud.
BigQuery comparisons use the existing Dift comparison engine and reports.

SQL Database Support

Dift can compare tables from SQL databases using SQLAlchemy connection strings.

This is useful for validating database migrations, checking staging vs production tables, and comparing database-backed datasets.

Compare SQL Tables

dift sqlite:///examples/old.db:customers_old \
     sqlite:///examples/new.db:customers_new \
     --key customer_id

URI Format

connection_string:table_name

Examples:

sqlite:///examples/data.db:customers
postgresql://user:password@localhost:5432/mydb:customers
mysql://user:password@localhost:3306/mydb:customers

Install Dependencies

pip install sqlalchemy

Database-specific drivers may also be required:

pip install psycopg2-binary   # PostgreSQL
pip install pymysql           # MySQL

Works With

existing row comparison
schema comparison
drift detection
risk scoring
JSON, CSV, Excel, and HTML reports

Notes

SQLite database files must exist locally.
PostgreSQL and MySQL require valid connection strings and credentials.
SQL comparisons use the existing Dift comparison engine and reports.

Requirements

Python 3.10+

Quick Install

pip install dift-cli

Then run:

dift --help

Quick Update (Latest version: 0.5.0)

pip install --upgrade dift-cli

Cross Platform Setup

Windows (Git Bash)

python -m venv .venv
source .venv/Scripts/activate
pip install dift-cli

Windows (PowerShell)

python -m venv .venv
.venv\Scripts\Activate.ps1
pip install dift-cli

Mac / Linux

python3 -m venv .venv
source .venv/bin/activate
pip install dift-cli

pipx (Recommended)

pipx install dift-cli

Verify Install

dift --help

or

python -m dift.cli --help

Quick Start

Compare CSV Files

dift examples/old.csv examples/new.csv --key customer_id

If your paths are defined in the config, just run:

dift --config examples/config_sample.yaml

Detect Numeric Drift

dift examples/old_drift.csv examples/new_drift.csv --key id --threshold 0.1

Generate Reports

JSON

dift examples/old.csv examples/new.csv \
  --key customer_id \
  --report json \
  --output report.json

CSV

dift examples/old.csv examples/new.csv \
  --key customer_id \
  --report csv \
  --output report.csv

Excel

dift examples/old.csv examples/new.csv \
  --key customer_id \
  --report excel \
  --output report.xlsx

HTML

dift examples/old.csv examples/new.csv \
  --key customer_id \
  --report html \
  --output report.html

HTML with Template

dift examples/old.csv examples/new.csv \
  --key customer_id \
  --report html \
  --template dark \
  --output report.html

Run using Config Files

dift examples/old.csv examples/new.csv \
  --config examples/config_sample.yaml

Run using Saved Profiles

dift profile run nightly-check

Run Batch Dataset Comparison

dift batch \
  --old-dir data/old \
  --new-dir data/new \
  --key customer_id

Example Output

╭─────────────────────────╮
│ Dift Dataset Comparison │
│ Risk Level: MEDIUM      │
╰─────────────────────────╯

Warnings

Numeric drift:
'revenue'
mean shift 900.00%
(high, threshold 0.1)

Outlier spike:
'revenue' increased by 100.00%
(high)

Categorical shift:
'segment' max frequency shift 60.00%
(high)

Example Files

examples/
├── old.csv
├── new.csv
├── old.parquet
├── new.parquet
├── old.xlsx
├── new.xlsx
├── old.json
├── new.json
├── old_drift.csv
├── new_drift.csv
├── config_sample.yaml
├── config_sample.toml
├── config_sample.json
├── config_thresholds.yaml
├── config_env.yaml
├── config_with_datasets.yaml
├── config_with_datasets.toml
└── config_with_datasets.json

Use Cases

ETL Validation

dift before.csv after.csv

ML Dataset Drift

dift train_v1.csv train_v2.csv

Production vs Staging

dift prod.csv staging.csv --key id

Silent Data Drift Detection

dift train_v1.csv train_v2.csv --threshold 0.1

Automated Validation Workflow

dift profile run nightly-check

Multi-Table ETL Validation

dift batch \
  --old-dir warehouse_snapshot_1 \
  --new-dir warehouse_snapshot_2 \
  --report html \
  --output-dir reports/

Historical Drift Monitoring

dift prod.csv staging.csv \
  --key customer_id \
  --history

Track how risk and drift evolve across repeated comparison runs.

Project Structure

dift/
├── cli.py
├── core/
│   ├── comparator.py
│   ├── schema_diff.py
│   ├── row_diff.py
│   ├── quality_diff.py
│   ├── stats_diff.py
│   └── risk.py
├── io/
│   ├── config_loader.py
|   └── readers.py
├── reports/
│   ├── console_report.py
│   ├── json_report.py
│   ├── csv_report.py
│   ├── excel_report.py
│   ├── html_report.py
│   └── models.py
├── profiles.py
├── batch.py
├── thresholds.py
├── schedules.py
├── history.py
└── utils/

tests/
examples/

Run Tests

pytest

Lint:

ruff check .

Type checking:

mypy dift

Roadmap

v0.6.0

Database Support

SQL Database Integration

Direct database-to-database comparison
Table-to-table comparison support
Query-based dataset comparison
Connection string support
CLI database input support

PostgreSQL Connector

PostgreSQL table reader
Schema inference support
Query execution support
Secure connection handling

MySQL Connector

MySQL table reader
Query-based comparisons
Type compatibility handling

SQLite Connector

SQLite local database support
Lightweight comparison workflows
File-based database comparison

DuckDB Support

Native DuckDB integration
Analytical dataset support
Parquet interoperability

Data Warehouse Support

Snowflake Connector

Snowflake authentication support
Warehouse query execution
Large-scale dataset comparison

BigQuery Connector

BigQuery dataset comparison
Service account authentication
Query-based workflows

Redshift Connector

Redshift warehouse support
Efficient table extraction
Warehouse schema compatibility

Configuration System

Config File Support

YAML configuration support
TOML configuration support
JSON configuration support
Dataset path support in configuration files

Saved Comparison Profiles

Reusable comparison profiles
Saved report configurations
Named comparison presets

Reusable Threshold Configs

Numeric drift thresholds
Categorical shift thresholds
Outlier thresholds
Column-level threshold overrides

Environment-Based Configs

Development/staging/production configs
Environment variable support
Secret management preparation

Automation Features

Scheduled Comparisons

Scheduled dataset checks
Cron-friendly execution
Time-based comparison workflows

CLI Automation Workflows

Non-interactive CLI support
Automation-friendly exit codes
Pipeline integration support

Batch Dataset Comparison

Multi-dataset comparison support
Folder-based comparisons
Batch report generation

Comparison History

Historical comparison tracking
Drift trend analysis
Historical risk tracking

Reporting Improvements

Better Excel Formatting

Severity color coding
Conditional formatting
Improved worksheet layouts
Better readability styling

Better HTML Reports

Drift highlighting
Severity badges
Improved visual summaries
Responsive layouts

Report Metadata Expansion

Execution timestamps
Runtime metrics
Dataset source metadata
Threshold metadata

Developer Experience

Testing Improvements

Connector integration tests
Cross-format consistency tests
Warehouse mock testing

CLI Improvements

Better help messages
Clearer validation errors
Progress indicators

Plugin Preparation

Extensible reader interfaces
Connector registry architecture
Internal plugin preparation

Contributing

Contributions are welcome.

See:

CONTRIBUTING.md

Ways to help:

Fix bugs
Improve docs
Add tests
Improve performance
Add connectors
Improve CLI UX

License

MIT License

Vision

Dift aims to become the open-source standard for:

dataset regression testing
data drift monitoring
ML data validation
warehouse trust checks
automated data quality enforcement

Name		Name	Last commit message	Last commit date
Latest commit History 147 Commits
.github		.github
.vscode		.vscode
assets		assets
dift		dift
docs		docs
examples		examples
tests		tests
.gitignore		.gitignore
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
README.md		README.md
SECURITY.md		SECURITY.md
pyproject.toml		pyproject.toml
requirements.txt		requirements.txt

Folders and files

Latest commit

History

Repository files navigation

Dift

What's New in v0.5.0

New Features

Why Dift?

Features (v0.5.0)

Supported Formats

Drift Detection

Numeric Drift

Categorical Drift

Outlier Detection

Output Options

HTML Templates

Numeric Drift Thresholds

Output Directory Support

Configuration System

Supported Formats

Example YAML Config

Example TOML Config

Example JSON Config

Dataset Paths in Config Files

YAML Example

CLI Override Example

Reusable Threshold Configurations

Global Threshold Configuration

Column-Level Threshold Overrides

Full Threshold Config Example

Run Using Threshold Configs

CLI Threshold Override

Supported Threshold Types

Example Use Cases

Sensitive Revenue Monitoring

Relaxed Categorical Drift

Strict Outlier Detection

Environment-Based Configurations

Select an Environment

Example Environment Config

YAML

Environment Variable Support

Git Bash / Linux / Mac

PowerShell

Missing Environment Variables

Environment Workflow Benefits

Saved Comparison Profiles

Create a Profile

Run a Profile

List Profiles

Show Profile Details

Delete a Profile

Configuration Priority

Batch Dataset Comparison

Folder Structure Example

Run Batch Comparison

Generate Batch HTML Reports

Batch CSV Reports

Continue On Error

Comparison History

Save Comparison History

Custom History Directory

View Saved History

Show Detailed History Record

Clear History

Batch Comparison History

Configuration Priority

Scheduled Comparisons

Create a Reusable Profile

Generate a Cron Schedule

Custom Schedule Times

Save Scheduled Jobs

List Saved Schedules

Show Schedule Details

Run a Schedule Manually

Delete a Schedule

Example Cron Integration (Linux/macOS)

Example Windows Task Scheduler

Automation-Friendly Exit Codes

Exit Code Mapping