Skip to content

Parquet file viewer and CSV / Excel converter

Explore columnar Apache Parquet datasets, inspect Snappy or Zstd compression codecs, and export filtered slices to spreadsheets without Python or cloud uploads.

Open Apache Parquet file (SNAPPY / ZSTD / GZIP / UNCOMPRESSED)

Drop a .parquet dataset file here

Metadata and row groups decode offline in your browser Web Worker.

How to use Parquet viewer

  1. Load a local Parquet dataset. Drop a .parquet or .pq file onto the drop zone, or click Load sample Parquet to inspect sample-telemetry.parquet with latency and region metrics.
  2. Review metadata cards and schema definitions. Inspect Total Rows, Schema Columns, Compression codecs, and Writer details alongside physical and logical column types.
  3. Load windowed row slices. Set Start row, pick a Page size of 100, 250, 500, or 1,000 rows, click Load slice, and narrow visible records with Filter loaded rows.
  4. Export tabular or JSON output. Click Export CSV for UTF-8 BOM spreadsheets, Export Excel for a Parquet Data workbook sheet, or Export JSON for structured arrays.

Everything runs in this browser tab. Nothing you paste or open is uploaded or logged, so it's safe for keys, tokens and private data.

How does a Parquet viewer read columnar files without uploads?

An in-memory buffer adapter reads trailing footer bytes first to decode column definitions and row-group offsets inside a local Web Worker. Selective decompression extracts only the requested row window, letting this Parquet to CSV and Excel converter inspect binary tables in browser memory.

Unlike row-oriented formats, the Apache Parquet file format specification wraps columnar row groups between four-byte PAR1 header and footer magic markers. Our reader checks that uploaded files meet a 12 byte minimum length and verifies both 4 byte PAR1 signatures (0x50 0x41 0x52 0x31) before decoding the trailing Thrift metadata.

After validating those bytes, hyparquet reads metadata via a zero-copy slice wrapper (AsyncBuffer) inside dev.worker.ts without duplicating buffers across threads. Click Load sample Parquet for sample-telemetry.parquet (4 rows with id, service, latency_ms, and region) or inspect local SQLite databases in WebAssembly.

Summary cards show Total Rows, Schema Columns (row groups and format version), Compression codecs, and Writer metadata without network transfers.

Inspecting Parquet column schemas, INT64 types, and row groups

Every Parquet file separates nested logical presentation from compact column chunks stored on disk. The schema grid reveals five attributes per column: Column, Physical Type, Logical / Converted, Repetition, and Codec.

Physical types, logical annotations, and INT64 precision

Columns store low-level bytes as primitives like INT64, DOUBLE, or BYTE_ARRAY while attaching semantic tags such as UTF8, DECIMAL, or TIMESTAMP_MILLIS described under Apache Parquet physical and logical types. Inspecting both physical primitives and converted annotations clarifies why raw storage differs from rendered spreadsheet columns.

When 64-bit INT64 IDs decode into JavaScript bigint values, integers beyond 53 bits exceed IEEE 754 precision limits documented in the MDN Number.MAX_SAFE_INTEGER reference. Values inside -9,007,199,254,740,991 to 9,007,199,254,740,991 stay numeric, whereas larger identifiers serialize as exact decimal strings so trailing digits never corrupt.

Handling timestamps, binary blobs, and nested structs

Non-primitive columns normalize into readable inspection strings before table rendering or spreadsheet export. Native JavaScript Date objects format to standard ISO 8601 UTC timestamps (toISOString()), while Uint8Array binary columns display compact 0x hex previews covering the first 16 bytes with an ellipsis when truncated.

Nested STRUCT, LIST, and MAP fields run through a BigInt-safe JSON serializer so complex warehouse events remain readable in single spreadsheet cells. When debugging line-oriented JSON logs exported alongside Parquet tables, verify raw event lines with the JSONL Viewer & Validator offline.

Windowed row-group pagination with Start row and Page size

Loading millions of columnar rows simultaneously would exhaust browser DOM memory fast. Set Start row (0 up to totalRows - 1) and choose a Page size of 100, 250 (default), 500, or 1,000 rows, then click Load slice to materialize only that window.

Parquet type or value Raw storage example Normalized viewer output CSV / Excel / JSON behavior Precision or length note
INT64 within safe bounds 4291042 (bigint) Numeric 4291042 Written as numeric cell or JSON number Up to 53-bit IEEE 754 integers
INT64 outside safe bounds 9223372036854775000 (bigint) Decimal string "9223372036854775000" Exported as string to prevent rounding Preserves full 64-bit precision
TIMESTAMP (Date) Epoch millisecond column 2026-11-15T10:30:00.000Z ISO 8601 UTC timestamp string Uniform timezone formatting
BYTE_ARRAY binary Uint8Array(64) 0x50415231... hex preview Compact 16-byte prefix summary Avoids unreadable binary glyphs
Nested STRUCT / LIST { region: "iad", ok: true } Compact JSON string Preserves nested keys inside single cell BigInt-safe stringification

Decoding Snappy, Zstd, and Gzip compression codecs locally

Data warehouses write column pages with distinct block compressors depending on whether queries prioritize CPU throughput or storage footprint. Our worker reads codec tags directly from row-group column metadata and dispatches matching pure-JavaScript or WASM-free decoders.

Supported compression formats and Parquet magic checks

Using hyparquet-compressors, the viewer decodes UNCOMPRESSED, SNAPPY, GZIP, and ZSTD pages straight from local byte slices in accordance with Apache Parquet data page compression codecs. Even mixed-codec files where one column uses SNAPPY and another uses ZSTD decode transparently column by column.

Files lacking matching leading and trailing PAR1 markers fail fast with an explicit invalid Parquet signature message before any row allocation happens. Unsupported experimental codecs such as LZO or Brotli likewise raise clear diagnostic errors naming the missing codec.

Filtering rows and exporting slices to CSV, Excel, and JSON

Typing into Filter loaded rows... searches across every normalized column value in your active slice and updates Total Rows loaded counters dynamically. Matching results export straight from browser RAM via three toolbar actions:

  • Export CSV: Prepends a UTF-8 byte order mark (\uFEFF) and applies MITRE CWE-1236 formula escaping so cells starting with =, +, -, or @ never trigger spreadsheet code execution.
  • Export Excel: Writes filtered rows into a typed Parquet Data sheet inside a .xlsx workbook ready for desktop Excel or LibreOffice Calc.
  • Export JSON: Outputs a two-space indented JSON object array of your filtered slice, which pairs cleanly with our flat CSV to structured JSON converter when harmonizing mixed pipeline formats.

When should you slice rows before converting Parquet to CSV or Excel?

Spreadsheet applications slow down dramatically past tens of thousands of unindexed rows, and browser tables stall when painting thousands of DOM cells simultaneously. Choosing targeted Start row offsets and moderate Page size windows keeps exploration snappy across 50 MB analytics partitions.

Because Filter loaded rows... filters your currently loaded window (250 rows by default, up to 1,000 in UI controls and 10,000 in library helpers) and renders at most 500 table rows on screen, slicing protects tab stability. Check row-group totals and column widths first, start at row 0 with 250 rows to inspect schema mappings, then step forward by 1,000-row pages when auditing tail partitions or data anomalies.

Tip: Export targeted slices in batches of 500 or 1,000 rows instead of opening massive raw files in spreadsheet software. You retain 100% of column fidelity without exhausting workbook memory.

Integrating Parquet exports into spreadsheet and lakehouse checks

Data engineers and financial analysts frequently pull partitioned Parquet extracts from Spark, DuckDB, Snowflake, or Pandas object storage for fast reconciliation without configuring Python or CLI runtimes. Exporting filtered slices locally guarantees confidential revenue figures, customer identifiers, and internal telemetry stay off untrusted third-party upload sites.

Every CSV download writes a UTF-8 byte order mark alongside MITRE CWE-1236 formula escaping so cells starting with symbols open safely in Excel. Excel workbooks (Parquet Data sheet) and formatted JSON slices retain clean column typing across downstream validation scripts, audit trackers, and BI workbooks without losing large identifier precision.

When audit checks span multiple daily Parquet extracts exported to CSV, stitch downloaded column slices together cleanly using multi-file CSV joins without Python scripts inside the same private browser workspace before finalizing quarterly reconciliation reports, financial sign-offs, or engineering schema handoffs.

Questions

How can I open a Parquet file in Chrome without Python or DuckDB?

Drop any .parquet or .pq file directly onto the page to inspect schemas and row slices inside a local JavaScript Web Worker. Pure-browser decoding handles footer parsing and page decompression locally without installing Python, PyArrow, DuckDB, or native command-line packages.

Why do huge INT64 integers export as strings instead of numbers?

JavaScript numbers use 53-bit IEEE 754 precision and round integers outside negative 9,007,199,254,740,991 to positive 9,007,199,254,740,991. Any 64-bit INT64 bigint beyond safe bounds serializes automatically to a decimal string so transaction keys and snowflake IDs never lose trailing digits.

Which Parquet compression codecs work inside this browser viewer?

The Web Worker bundles hyparquet-compressors to decode UNCOMPRESSED, SNAPPY, GZIP, and ZSTD data pages offline. Less common codecs such as LZO or Brotli report an unsupported codec error instead of failing silently when reading compressed column chunks.

Does row filtering search the entire Parquet file or just the loaded slice?

Typing into Filter loaded rows scans every normalized cell inside your active slice window and updates the preview table up to 500 visible rows. To inspect later row groups in huge datasets, adjust Start row and Page size and click Load slice.

What is the maximum number of rows rendered or loaded per Parquet slice?

The user interface presets Page size at 100, 250, 500, or 1,000 rows and displays up to 500 matching rows in the table DOM to avoid browser freezes. Library slice helpers accept up to 10,000 rows per batch.

How does the tool protect exported CSV cells from Excel formula injection?

Exported CSV tables run MITRE CWE-1236 formula neutralization before triggering a download. Any string value starting with an equals, plus, minus, or at sign receives a leading apostrophe, and the file begins with a UTF-8 byte order mark for reliable Excel encoding.

Updated