Documentation

CSV Workbench is a powerful, privacy-first browser application for validating and managing CSV files. Built with React 19 and powered by WebAssembly validation engines, it provides enterprise-grade CSV validation entirely within your browser. Offline-capable Progressive Web App (PWA) with Service Workers. Requires latest Chrome or latest Edge on laptop/desktop.

Key Features

What CSV Workbench Looks Like

Here's a preview of the CSV Workbench interface showing the CSV editor, validation features, and schema management:

The CsvSchema framework is a powerful tool for ensuring data quality and consistency. By defining a clear, machine-readable contract for CSV files, it offers significant advantages for both human data handlers and automated systems. Its primary benefits are improved data integrity, accelerated development cycles, and more resilient data-driven systems.

For Data Practitioners

Data practitioners—including analysts, developers, and scientists—can leverage CsvSchema to streamline their workflows and build trust in their data.

For Automated Systems

For automated systems such as ETL pipelines and microservices, CsvSchema acts as a critical data quality gatekeeper, ensuring reliability and predictability.

The CSV Schema validation framework consists of four essential core components that work together to provide comprehensive data validation. CSV Workbench supports two schema standards: CSV Workbench Schema and Frictionless Table Schema — the format is auto-detected when you add a schema file.

Four User-Facing Validation Operations

The validation framework provides four user-facing validation operations that combine multiple validation steps behind the scenes:

CSV Workbench requires modern browser features for optimal performance and security.

Required Browser Features

• File System Access API - For reading and writing local files
• IndexedDB - For storing file metadata (not file content)
• WebAssembly - For high-performance validation engines
• Web Workers - For background validation processing
• Service Workers - For offline functionality (PWA)

Technical Terms

Understanding these technical terms will help you better understand how CSV Workbench works:

Get started with CSV Workbench in just a few simple steps.

1. Access the Application

Navigate to app.csvworkbench.com using latest Chrome or latest Edge.

2. Open a CSV File

Click "CSV Data Files" in the left sidebar, then click "Add CSV File Reference". Select a CSV file from your computer. The browser will request permission to access the file.

3. View and Edit Your Data

Once opened, your CSV file appears in an editable table (for files ≤50MB). You can:

• Click any cell to edit its value
• Add new rows or columns
• Delete rows or columns
• Rename column headers
• Move columns left or right

All changes are auto-saved immediately to your local file.

4. Generate or Load a Schema

To validate your data, you need a schema. You can either:

• Generate automatically: Click "Generate Schema from Data" to create a schema based on your CSV
• Load existing: Associate an existing schema file from the "Associated Schema" dropdown

5. Validate Your Data

Once a schema is associated, click "Validate with Schema". The validation runs in a background worker and shows progress. Results appear in a detailed dialog showing:

• Validation status (success/failure)
• Error and warning counts
• Detailed error messages with row/column locations
• Processing time and performance metrics
• Raw JSON response from the validation engine

CSV Folders is a screen in the left-hand navigation (between Home and CSV Data Files) where you manage the local folders that CSV Workbench may read from and write to. Because the browser's File System Access API requires explicit user approval for every folder, this screen is the single place where you grant, review, and revoke that access.

Adding a Folder

1. Navigate to CSV Folders in the left sidebar.
2. Click "Add Folder".
3. The browser's folder picker opens — select the directory you want CSV Workbench to access and grant read/write permission.
4. The folder appears in the table with a Granted permission badge.

Folder Table

Each registered folder shows the following columns:

• Display Name — User-editable label for the folder (defaults to the directory name).
• Directory Name — The actual name of the directory on disk (read-only).
• Permission — Current access status: Granted, Needs Permission, or Denied.
• Added — When the folder was first registered.
• Actions — Re-authorize, Edit Name, Remove.

Permission States

Folder Actions

• Re-authorize — Appears when permission is Needs Permission or Denied. Triggers the browser permission prompt to restore access.
• Edit Name — Change the display name shown in CSV Workbench. The underlying directory on disk is not affected.
• Remove — Removes the folder from the registry. No files on disk are deleted; CSV Workbench simply forgets the folder.

Undo / Redo Support

Adding, removing, and renaming folders are all undoable operations. Use Ctrl+Z / Cmd+Z to undo or Ctrl+Y / Cmd+Y to redo. The Undo and Redo buttons in the app header also reflect these operations.

CSV Workbench provides a comprehensive file management system for your CSV files.

Opening Files

Navigate to CSV Data Files and click "Add CSV File Reference". The browser's file picker will open, allowing you to select a CSV file from your computer.

File List View

The CSV Data Files view shows all your opened files with:

• File Name - The name of your CSV file
• Size - File size in KB/MB/GB
• Associated Schema - Which schema (if any) is linked to this file
• Last Accessed - When you last opened this file
• Actions - Edit, validate, or remove the file reference

File Metadata

You can add descriptions and notes to your files for better organization. Click the "Edit Information" button in the CSV Data Editor to add:

• Description - A brief description of the file's purpose
• Notes - Additional notes or context

Removing File References

If a file is no longer needed or has been moved/deleted, you can remove its reference from CSV Workbench. This only removes the reference - it does not delete the actual file from your computer.

CSV Workbench provides powerful editing capabilities using the File System Access API for direct file operations.

Editing Cells

Click any cell to open the edit dialog. You can:

• Edit single-line or multi-line text values
• View the current row and column information
• See validation errors for that cell (if any)

Changes are saved immediately when you click "Save".

Adding and Deleting Rows

Use the "Add Row" button to insert a new row. Fill in values for each column, then click "Add Row" to save. The new row is appended to the end of your CSV file.

To delete rows, select them using the checkboxes and click "Remove Selected". You can also delete individual rows using the delete button in the Actions column.

Managing Columns

Column operations include:

• Add Column: Click "Add Column" to insert a new column with an optional default value
• Rename Column: Click the edit icon next to any column header to rename it
• Move Column: Select a column by clicking its header, then use "Move Column Left/Right" buttons

Auto-Save

All changes are automatically saved to your local file immediately. You'll see a confirmation message when changes are saved successfully.

CSV Workbench supports two schema standards. You can use either format to define validation rules for your CSV files.

Creating Schemas

There are three ways to create a schema:

• Auto-Generate: Click "Generate Schema from Data" in the CSV Data Editor. You will be prompted to choose between CSV Workbench Schema and Frictionless Table Schema format before generation begins.
• Manual Creation: Navigate to "CSV Schemas" and click "Create New Schema" to build a CSV Workbench schema from scratch using the Schema Editor.
• Add Existing Schema: Navigate to "CSV Schemas" and click "Add Schema Reference" to add an existing schema file (either format) from your computer.

Schema Format Badge

Every schema reference in the CSV Schemas list displays a format badge so you can tell at a glance which standard it uses:

• CSV Workbench — internally-defined schema standard
• Frictionless — Frictionless Table Schema standard

Editing Schemas

Each schema format has its own dedicated editor:

• CSV Workbench Schema Editor: Provides fields for name, version, description, governance metadata, column definitions (data types and constraints), and settings (header row, additional columns).
• Frictionless Schema Editor: Provides a field table with type, format, and constraint editing; schema-level properties (missing values, primary key, foreign keys, unique keys); and a live JSON preview. See the Frictionless Table Schema section for full details.

Associating Schemas with CSV Files

In the CSV Data Editor, use the "Associated Schema" dropdown to link a schema to your CSV file. Both CSV Workbench and Frictionless schemas appear in the dropdown, each labelled with its format badge. Once associated, click "Validate Data" to validate the CSV against the schema's rules. The correct validation engine is selected automatically based on the schema format.

CSV Workbench provides four user-facing validation operations powered by WebAssembly engines. Each operation combines multiple validation steps to ensure data quality.

Validation Operations

Running Validation

Validation runs in a Web Worker to keep the UI responsive. For large files, you'll see:

• Progress indicator: Shows percentage complete and current phase
• Row counter: Displays rows processed vs. total rows
• Performance metrics: Processing time

Understanding Results

Validation results include:

• Status: Success or failure
• Error Count: Number of critical errors found
• Warning Count: Number of warnings (non-critical issues)
• Error Details: Each error shows row number, column name, value, and suggested fix
• Raw JSON: Complete response from the validation engine for debugging

The CSV Workbench Schema is the internally-defined schema standard. It is purpose-built for CSV validation with six dedicated data types, rich constraints, and governance metadata fields.

Six CSV Data Types

See the Data Types section for full details on each type and its constraints.

Schema Editor Features

• Basic Information: Name, version, description, and notes
• Column Definitions: Add, edit, or remove columns with specific data types and constraints
• Governance Fields: Author, contact, business owner, technical owner, documentation links, review cycle, data classification, compliance level, tags
• Settings: First row header, allow additional columns, meta schema version
• Auto-Save: Changes are written to disk automatically
• Validate Schema: Validates the schema against the CSV Workbench meta-schema

Generating a CSV Workbench Schema

In the CSV Data Editor, click "Generate Schema from Data", then select "CSV Workbench Schema" in the format choice dialog. The WASM engine analyzes your CSV data and infers column types and constraints. A review dialog shows detected column types with confidence levels, sample values, and the raw schema JSON. Click "Accept Schema" to save the schema file and automatically associate it with the CSV file.

CSV Workbench supports the Frictionless Table Schema standard — the open data schema format defined by the Frictionless Data project and compatible with frictionless-py v5. Frictionless schemas are portable JSON files that can be used with a wide range of data tools beyond CSV Workbench.

Adding a Frictionless Schema

Navigate to CSV Schemas and click "Add Schema Reference". Select a .json file from your computer. CSV Workbench automatically detects whether the file is a valid Frictionless Table Schema and saves it with the Frictionless badge. If the file is not a valid Frictionless schema, the CSV Workbench WASM engine is tried next. If both engines reject the file, detailed error information is shown and the reference is not saved.

Generating a Frictionless Schema

In the CSV Data Editor, click "Generate Schema from Data", then select "Frictionless Table Schema" in the format choice dialog. The Frictionless WASM engine analyzes your CSV data using the frictionless-py v5 type-candidate algorithm and infers field types. A review dialog shows the detected fields with their inferred types and the raw schema JSON. Click "Accept Schema" to save the schema file and automatically associate it with the CSV file.

Frictionless Schema Editor

Click the edit icon on any Frictionless schema reference to open the Frictionless Schema Editor. The editor provides:

• File Information: Name, size, description, and notes (editable)
• Associated CSV Data Files: Shows which CSV files are linked to this schema, with quick navigation to the CSV Data Editor
• Schema-Level Properties: Missing values, primary key, foreign keys, unique keys — see Schema-Level Properties
• Fields Table: Add, edit, or delete fields with full type, format, and constraint support — see Field Types and Constraints
• View Schema JSON: Expandable live JSON preview with copy and download
• Validate Schema: Validates the schema against the Frictionless meta-schema using the WASM engine; results shown in the unified validation dialog
• Auto-Save: Changes are validated and written to disk automatically; a status indicator shows saving / saved / error state

Validating CSV Data Against a Frictionless Schema

In the CSV Data Editor, associate a Frictionless schema using the "Associated Schema" dropdown (Frictionless schemas are labelled with the purple Frictionless badge). Then click "Validate Data". The Frictionless WASM engine reads both files fresh from disk and produces a validation report showing:

• Overall valid/invalid status with error and warning counts
• Row count, field count, and processing time
• Per-error details: error type, row number, field name, and message
• Raw JSON from the Frictionless WASM engine (copy and download)

Frictionless Table Schema supports 16 field types. Each field has a name, a type (default: string), and an optional format. Additional metadata fields (title, description, example, rdfType) are also supported.

Type-Specific Properties

Each Frictionless field can have a constraints object that restricts the values accepted for that field. Constraints are validated by the WASM engine when you validate a CSV file against a Frictionless schema.

In addition to field definitions, a Frictionless Table Schema can define schema-level properties that apply across all fields. These are configured in the Schema-Level Properties card of the Frictionless Schema Editor.

CSV Workbench supports six data types as defined in CSV Schema version 1.0, each with rich constraint options.

CSV Workbench provides comprehensive ISO 8601 and RFC 3339 datetime validation with flexible format support and timezone handling.

ISO 8601 vs RFC 3339

Understanding the relationship between these standards is crucial for proper datetime validation:

Supported DateTime Formats

The validation engine automatically detects and validates four ISO 8601 variants:

Date Validation Features

Time Component Validation

• Hour: Range 0-23 (24-hour format)
• Minute: Range 0-59
• Second: Range 0-59
• Fractional Seconds: Supported with nanosecond precision (e.g., 10:30:00.123)

Timezone Support

The validation engine strictly enforces IANA Time Zone Database IDs in schemas.

• IANA IDs Only: Must use canonical IDs like America/New_York, Europe/London, Asia/Tokyo.
• UTC: Use UTC. The schema validation rejects Z and GMT (though Z is accepted in data values for offsets).
• No Abbreviations: Abbreviations like PST, CET, EST are rejected to prevent ambiguity.
• Schema-Time Validation: Invalid timezones are caught when you validate the schema itself.

Flexible Parsing Modes

Custom Pattern Support

When using Standard: CUSTOM, patterns MUST use Rust strftime syntax.

Common supported specifiers:

Validation Architecture

The validation uses a two-phase approach for optimal performance:

DateTime Error Codes

The validation engine emits specific error codes for different validation failures:

Schema Validation Errors (Caught when editing schema)

• SCHEMA_DATETIME_JAVA_PATTERN_DETECTED: Pattern uses unsupported syntax. Remediation: Use strftime syntax (e.g., %Y-%m-%d).
• SCHEMA_DATETIME_INVALID_PATTERN_SYNTAX: Pattern contains invalid strftime specifiers.
• SCHEMA_DATETIME_INVALID_TIMEZONE: Timezone is not a valid IANA ID (e.g., PST). Remediation: Use America/Los_Angeles.

Data Validation Errors (Caught when validating CSV)

• DATETIME_INVALID_FORMAT: Value doesn't match expected ISO8601 variant
• DATETIME_PATTERN_MISMATCH: Value doesn't match custom pattern
• DATETIME_INVALID_DATE: Non-existent date (e.g., Feb 30, invalid leap year)
• DATETIME_UNSUPPORTED_STANDARD: Unsupported datetime standard specified

The SQL Query feature lets you run SQL SELECT statements directly against any CSV file you have open in CSV Workbench—without uploading the file or installing any database software. The query engine runs entirely inside your browser in a dedicated background thread, so the UI stays responsive even on large files.

Opening the SQL Query Panel

1. Open any CSV file reference in the CSV Data Editor.
2. Click the SQL Query tab (next to the Data tab).
3. Type a SQL SELECT statement in the query editor.
4. Choose a Row Limit from the dropdown (100 / 500 / 1,000 / 5,000 / 10,000 rows).
5. Click Run Query.

Query Panel Controls

How to Reference Your CSV File in SQL

The SQL engine accepts three equivalent forms. Use whichever feels most natural:

SELECT "Region", COUNT(*) AS cnt
GROUP BY "Region"
ORDER BY cnt DESC
LIMIT 20

SELECT * FROM SalesRecords10k.csv LIMIT 10

SELECT * FROM read_csv('query_target.csv', header=true, delim=',') LIMIT 10

All three forms produce identical results. Form 1 is the most convenient for quick exploration. Form 3 is useful for complex queries that use CTEs or subqueries where the file reference must appear explicitly.

The SQL engine supports a broad subset of standard SQL. The following reference covers the clauses and functions most useful for CSV data analysis.

SELECT Statement Structure

SELECT  <column_list>
FROM    <file_reference>
WHERE   <condition>
GROUP BY <columns>
HAVING  <aggregate_condition>
ORDER BY <columns> [ASC | DESC]
LIMIT   <n>

All clauses except SELECT are optional. When using Form 1 (bare SELECT), the FROM clause is also optional—the engine inserts it automatically.

Column Names

Column names that contain spaces or special characters must be enclosed in double quotes:

-- Column names with spaces require double quotes
SELECT "Order ID", "Item Type", "Total Profit"
FROM SalesRecords10k.csv
LIMIT 10

-- Simple column names (no spaces) can be unquoted
SELECT Region, Country
FROM SalesRecords10k.csv
LIMIT 10

Filtering with WHERE

-- Equality and comparison
SELECT * FROM SalesRecords10k.csv
WHERE "Sales Channel" = 'Online'
  AND "Units Sold" > 1000
LIMIT 100

-- IN list
SELECT * FROM SalesRecords10k.csv
WHERE "Order Priority" IN ('C', 'H')
LIMIT 100

-- LIKE pattern matching
SELECT * FROM SalesRecords10k.csv
WHERE "Country" LIKE 'United%'
LIMIT 100

Aggregation and Grouping

-- COUNT, SUM, AVG, MIN, MAX
SELECT
  "Region",
  COUNT(*)                       AS order_count,
  SUM("Units Sold")              AS total_units,
  ROUND(AVG("Total Profit"), 2)  AS avg_profit
FROM SalesRecords10k.csv
GROUP BY "Region"
ORDER BY order_count DESC

-- HAVING filters on aggregated values
SELECT "Item Type", COUNT(*) AS cnt
FROM SalesRecords10k.csv
GROUP BY "Item Type"
HAVING cnt > 500
ORDER BY cnt DESC

Common Functions

Window Functions

Window functions compute values across a set of rows related to the current row without collapsing them into a single output row:

-- RANK within a partition
WITH ranked AS (
  SELECT
    "Region",
    "Country",
    COUNT(*) AS order_count,
    RANK() OVER (
      PARTITION BY "Region"
      ORDER BY COUNT(*) DESC
    ) AS region_rank
  FROM read_csv('query_target.csv', header=true, delim=',')
  GROUP BY "Region", "Country"
)
SELECT *
FROM ranked
WHERE region_rank <= 3
ORDER BY "Region", region_rank
LIMIT 100

Common Table Expressions (CTEs)

CTEs let you break complex queries into named, readable steps:

WITH country_totals AS (
  SELECT
    "Country",
    ROUND(SUM("Total Revenue"), 2) AS country_revenue
  FROM read_csv('query_target.csv', header=true, delim=',')
  GROUP BY "Country"
),
grand_total AS (
  SELECT SUM(country_revenue) AS grand_revenue
  FROM country_totals
)
SELECT
  ct."Country",
  ct.country_revenue,
  ROUND(ct.country_revenue / gt.grand_revenue * 100, 2) AS revenue_share_pct
FROM country_totals ct
CROSS JOIN grand_total gt
ORDER BY revenue_share_pct DESC
LIMIT 20

The following examples demonstrate common SQL patterns for CSV data analysis. They use a sales dataset with columns: Region, Country, Item Type, Sales Channel, Order Priority, Order Date, Order ID, Ship Date, Units Sold, Unit Price, Unit Cost, Total Revenue, Total Cost, Total Profit.

Example 1: Preview the First 10 Rows

SELECT * LIMIT 10

Example 2: Total Revenue and Profit by Region

SELECT
  "Region",
  COUNT(*)                          AS order_count,
  SUM("Units Sold")                 AS total_units,
  ROUND(SUM("Total Revenue"), 2)    AS total_revenue,
  ROUND(SUM("Total Profit"), 2)     AS total_profit,
  ROUND(AVG("Total Profit"), 2)     AS avg_profit_per_order
FROM SalesRecords10k.csv
GROUP BY "Region"
ORDER BY total_revenue DESC

Example 3: Profit Margin by Item Type

SELECT
  "Item Type",
  COUNT(*)                                                              AS order_count,
  ROUND(SUM("Total Revenue"), 2)                                        AS total_revenue,
  ROUND(SUM("Total Profit"), 2)                                         AS total_profit,
  ROUND(SUM("Total Profit") / NULLIF(SUM("Total Revenue"), 0) * 100, 2) AS profit_margin_pct
FROM SalesRecords10k.csv
GROUP BY "Item Type"
ORDER BY profit_margin_pct DESC

Example 4: Top 5 Countries per Region (Window Function)

WITH ranked AS (
  SELECT
    "Region",
    "Country",
    COUNT(*) AS order_count,
    ROUND(SUM("Total Profit"), 2) AS total_profit,
    RANK() OVER (
      PARTITION BY "Region"
      ORDER BY COUNT(*) DESC
    ) AS region_rank
  FROM read_csv('query_target.csv', header=true, delim=',')
  GROUP BY "Region", "Country"
)
SELECT "Region", region_rank, "Country", order_count, total_profit
FROM ranked
WHERE region_rank <= 5
ORDER BY "Region", region_rank
LIMIT 500

Example 5: Monthly Revenue Trend

SELECT
  STRFTIME(CAST("Order Date" AS DATE), '%Y-%m') AS order_month,
  COUNT(*)                       AS order_count,
  ROUND(SUM("Total Revenue"), 2) AS total_revenue,
  ROUND(SUM("Total Profit"), 2)  AS total_profit
FROM SalesRecords10k.csv
GROUP BY order_month
ORDER BY order_month

Example 6: Anomaly Detection — High-Priority Orders with Low Profit Margin

SELECT
  "Order ID",
  "Country",
  "Item Type",
  "Order Priority",
  ROUND("Total Revenue", 2) AS total_revenue,
  ROUND("Total Profit", 2)  AS total_profit,
  ROUND("Total Profit" / NULLIF("Total Revenue", 0) * 100, 2) AS profit_margin_pct
FROM SalesRecords10k.csv
WHERE
  "Order Priority" IN ('C', 'H')
  AND "Total Profit" / NULLIF("Total Revenue", 0) < 0.20
ORDER BY profit_margin_pct ASC
LIMIT 100

Example 7: Shipping Lag Analysis

WITH lag_calc AS (
  SELECT
    "Region",
    "Sales Channel",
    DATEDIFF(
      'day',
      CAST("Order Date" AS DATE),
      CAST("Ship Date"  AS DATE)
    ) AS days_to_ship
  FROM read_csv('query_target.csv', header=true, delim=',')
)
SELECT
  "Region",
  "Sales Channel",
  COUNT(*)                    AS order_count,
  ROUND(AVG(days_to_ship), 1) AS avg_days_to_ship,
  MAX(days_to_ship)           AS max_days_to_ship
FROM lag_calc
GROUP BY "Region", "Sales Channel"
ORDER BY avg_days_to_ship DESC
LIMIT 100

The Ask AI feature lets you describe what you want to know about your CSV data in plain English—and instantly receive a ready-to-run SQL query. No SQL knowledge required. The AI model runs entirely inside your browser; your data never leaves your computer.

How to Use Ask AI

1. Open any CSV file reference in the CSV Data Editor and click the SQL Query tab.
2. The Ask AI bar appears above the SQL editor. If no model is loaded, select a model and click Download & Load or Load Model.
3. Type your question in plain English in the Ask AI text area (e.g., "Show me the top 10 regions by total sales").
4. Click Generate SQL (or press Ctrl+Enter / Cmd+Enter).
5. Watch the SQL stream into the preview area in real time. When generation completes, the SQL is automatically placed in the SQL editor.
6. Review the generated SQL, then click Run Query to execute it.

Ask AI Panel Controls

Example Natural Language Queries

SELECT "Region",
  ROUND(SUM("Total Revenue"), 2) AS total_revenue,
  ROUND(SUM("Total Profit"), 2)  AS total_profit
FROM SalesRecords.csv
GROUP BY "Region"
ORDER BY total_revenue DESC

SELECT *
FROM SalesRecords.csv
WHERE "Country" = 'United States'
  AND "Units Sold" > 500

SELECT COUNT(*) AS total_records
FROM SalesRecords.csv

CSV Workbench includes two AI model options for natural language to SQL generation. Both run entirely in your browser—no internet connection is required after the initial download.

Available Models

Model Lifecycle

AI models follow a clear lifecycle managed from Settings > AI Models:

Managing AI Models in Settings

Navigate to Settings > AI Models to manage your AI models. From there you can:

• See which models are downloaded and which are loaded
• Download a model (with a progress bar showing download status)
• Load or unload a model from memory
• Delete cached model weights to free browser storage
• Check whether WebGPU is available in your current browser session

You can also manage models directly from the Ask AI bar in the SQL Query panel without navigating to Settings—use the inline model loader when no model is loaded, or click the AI Settings link to jump directly to the AI Models tab.

CSV Workbench handles large files efficiently with specialized processing modes.

File Size Thresholds

Validation Performance

Validation is optimized for performance:

• Memory-efficient streaming validation
• Real-time progress updates during validation
• Runs in Web Worker to keep UI responsive
• Works completely offline with PWA capabilities

CSV Workbench provides keyboard shortcuts for efficient navigation and operations.

Global Shortcuts

CSV Workbench supports configurable themes so you can match the interface to your environment and accessibility needs. Theme changes apply instantly and are preserved for future sessions.

Theme Modes

• Light: Standard light theme optimized for clarity and readability.
• Dark: Low‑light friendly theme that reduces glare.
• High Contrast: Increased contrast and clearer boundaries for improved legibility.
• System: Follows your operating system preference (Light or Dark) and honors high‑contrast settings when enabled.

How to Change the Theme

1. Open Settings in the left sidebar.
2. In Appearance, choose Light, Dark, High Contrast, or System.
3. The UI updates immediately across all screens.

System Mode Details

System mode automatically tracks your OS appearance. When your OS switches between Light and Dark, CSV Workbench follows. If your OS high‑contrast setting is enabled, high‑contrast styling is applied where available.

Accessibility

• High Contrast mode increases color contrast and adds clearer borders and focus indicators.
• Theme choices are compatible with keyboard navigation and screen readers.

CSV Workbench provides a database reset feature to clear all stored metadata and return the application to its default state.

What Gets Cleared

The database reset operation removes the following metadata from IndexedDB:

• CSV File References: Pointers to your CSV files (not the actual files)
• Schema File References: Pointers to your schema files (not the actual files)
• Schema Associations: Links between CSV files and their schemas
• Validation Cache: Cached validation results
• User Preferences: Application settings and preferences
• Saved Searches: Any saved search configurations
• Command History: Undo/redo command history

How to Reset the Database

1. Navigate to Settings in the left sidebar
2. Locate the Database Management section
3. Click the "Reset Database to Default" button
4. Read the confirmation dialog carefully
5. Type RESET in the confirmation field
6. Click "Reset Database" to confirm

When to Use Database Reset

Consider using database reset in these situations:

• Fresh Start: You want to start over with a clean slate
• Troubleshooting: Resolving persistent issues with file references or cached data
• Data Cleanup: Removing references to files that no longer exist
• Testing: Resetting the application state for testing purposes
• Privacy: Clearing all application metadata before sharing your computer

After Reset

After a successful database reset:

• The application returns to the landing page
• All metadata is cleared from IndexedDB
• You'll need to re-open your CSV and schema files
• File associations will need to be recreated
• Preferences will return to defaults

Follow these best practices for optimal results with CSV Workbench.

CSV File Preparation

• Use comma delimiters: Ensure your CSV uses commas, not tabs or semicolons
• Include headers: First row should contain column names
• Consistent columns: All rows must have the same number of fields
• Proper quoting: Use double quotes for fields containing commas or newlines
• UTF-8 encoding: Save files in UTF-8 encoding for best compatibility

Schema Design

• Start with auto-generation: Let CSV Workbench detect types automatically, then refine
• Add descriptions: Document each column's purpose for future reference
• Use appropriate types: Choose the most specific data type (e.g., MONEY instead of DECIMAL for currency)
• Set realistic constraints: Avoid overly restrictive rules that may reject valid data
• Version your schemas: Increment version numbers when making changes

Validation Workflow

• Validate early: Check CSV structure before creating schemas
• Test schemas: Use "Validate Schema" before applying to CSV files
• Review errors carefully: Each error includes row/column location and suggested fixes
• Fix systematically: Address errors by type or column for efficiency
• Re-validate after changes: Confirm fixes resolved the issues

File Organization

• Use descriptive names: Name files and schemas clearly (e.g., "customer-data-2025.csv")
• Add metadata: Use description and notes fields for context
• Associate schemas: Link schemas to CSV files for quick validation
• Keep schemas with data: Store schema files in the same directory as CSV files

Performance Tips

• Close unused tabs: Free up browser memory for better performance
• Use supported browsers: latest Chrome or latest Edge on laptop/desktop
• File size awareness: Files ≤50MB are fully editable; >50MB show read-only preview
• Offline capability: Works completely offline with PWA Service Workers
• Local processing: All validation happens in your browser

CSV Workbench is built with modern web technologies for maximum performance and security.

Technology Stack

Key Architectural Principles

• Offline-Capable: All functionality works without internet connection
• Privacy by Design: No data transmission to servers—including AI inference
• Progressive Enhancement: PWA capabilities for installable app experience
• Performance Optimization: Web Workers for background processing, lazy loading for code splitting
• Memory Efficiency: Streaming validation for large files, chunked processing
• On-Demand AI: AI models are downloaded and loaded only when explicitly requested—never at startup

Data Flow

1. User selects CSV file via File System Access API
2. File reference (not content) stored in IndexedDB
3. File content read on-demand from local file system
4. Validation runs in Web Worker with WASM engines
5. Results displayed in UI, cached for performance
6. Edits saved directly to local file via File System Access API

CSV Workbench uses specialized WebAssembly validation engines for high-performance data validation.

1. validate-basic-csv

Validates CSV structure without a schema. Ensures RFC 4180 strict compliance:

• Comma delimiter only (no tabs or other delimiters)
• Double quote character for field quoting
• Double-quote escaping (no backslash escaping)
• Consistent column counts across all rows
• Proper quote pairing and escaping

2. validate-basic-schema

Validates schema structure before use. Checks:

• Required metadata fields (name, version)
• Valid column definitions
• No duplicate column names
• Constraint logic consistency
• Meta schema compliance

3. validate-csv-schema

Validates CSV data against schema rules. Performs:

• Data type validation for each cell
• Required field presence checks
• Constraint validation (length, range, format, patterns)
• Unique key violation detection
• Cross-field dependency validation

4. validate-frictionless

Validates and generates Frictionless Table Schema. Provides three operations:

• validateFrictionlessSchema: Validates a JSON file against the Frictionless Table Schema meta-schema
• validateFrictionless: Validates a CSV file against a Frictionless Table Schema, producing a detailed report with per-row, per-field errors
• generateFrictionlessSchema: Analyzes a CSV file and generates a Frictionless Table Schema with inferred field types and constraints
• Runs in a persistent Web Worker for responsive UI during long-running validation
• Compatible with frictionless-py v5 (Frictionless Table Schema v1 and v2)

Performance Characteristics

• Memory Efficient: Streaming validation for optimized memory usage
• Background Processing: Runs in Web Worker to keep UI responsive
• Progress Tracking: Real-time progress updates during validation
• Offline-Capable: Works completely offline with PWA capabilities
• Local Processing: All validation happens in your browser with no uploads
• File Editing: Files ≤50MB fully editable; >50MB read-only preview with full validation

CSV Workbench provides full RFC 3339 compliance for datetime validation when using the ISO8601_DATETIME_OFFSET format.

What is RFC 3339?

RFC 3339 is an Internet standard (published by IETF) that defines a strict profile of ISO 8601 specifically for use in Internet protocols. It restricts ISO 8601 to a specific subset of formats to ensure better interoperability across systems.

RFC 3339 Format Specification

RFC 3339 defines the following strict format:

date-time = full-date "T" full-time

full-date = date-fullyear "-" date-month "-" date-mday
full-time = partial-time time-offset

partial-time = time-hour ":" time-minute ":" time-second [time-secfrac]
time-offset = "Z" / time-numoffset
time-numoffset = ("+" / "-") time-hour ":" time-minute

RFC 3339 Requirements

• Date Format: Only YYYY-MM-DD allowed
• Time Separator: Only T required (uppercase)
• Timezone: Only Z or ±hh:mm format
• Full Precision: Complete date and time required (no reduced precision)
• Fractional Seconds: Optional but must use period (.) as separator
• Case Sensitivity: T and Z must be uppercase

RFC 3339 vs ISO 8601

RFC 3339 is a strict subset of ISO 8601:

Implementation Details

CSV Workbench implements RFC 3339 compliance through:

• RFC 3339 Parsing: Uses standards-compliant parsing for validation
• WebAssembly Compilation: High-performance validation in the browser
• Strict Validation: Rejects any non-RFC 3339 compliant timestamps
• Comprehensive Testing: 100% test coverage for RFC 3339 edge cases

Reference

For the complete RFC 3339 specification, see:

• RFC 3339 Official Specification
• RFC 3339 vs ISO 8601 Comparison
• DateTime Validation Documentation

CSV Workbench strictly adheres to RFC 4180 (also written RFC4180), the standard specification for CSV files.

RFC 4180 Requirements

• Delimiter: Comma (,) only - no tabs, semicolons, or other delimiters
• Quote Character: Double quote (") only
• Quote Escaping: Double-quote style ("") - no backslash escaping
• Line Endings: CRLF (\r\n) per RFC 4180 standard; CSV Workbench also accepts LF (\n) as an enhancement for cross-platform compatibility
• Header Row: Optional first row containing column names
• Consistent Columns: All rows must have the same number of fields

What's Not Supported

• Tab-separated values (TSV)
• Semicolon or pipe delimiters
• Single-quote field quoting
• Backslash escape sequences
• Variable column counts per row

For complete information about data privacy, what data we collect, how we use it, and your privacy rights, please see our Privacy Policy.

For complete information about GDPR compliance and data handling, please see our Privacy Policy.

This guide documents common issues encountered when working with CSV files and how CSV Workbench helps prevent, detect, and resolve them.

grep -axv '.*' YourFile.csv

iconv -f utf-8 -t utf-8 -c YourFile.csv > YourFile-clean.csv

Name,Email,Notes
John Doe,john@example.com,=1+1
Jane Smith,jane@example.com,=cmd|'/c calc'!A1

Real-world scenarios showing how CSV Workbench solves common data quality challenges.