Parquet Viewer
Open and read .parquet files in your browser. Browse the schema, page through a virtualized table over millions of rows, compute column statistics, and expand nested data, all locally, with nothing uploaded.
Free, no sign-up, and fully client-side. Your file never leaves your browser. Opens .parquet, .parq, .pq.
Open the viewer and drop a file to get started.
What is a Parquet file?
Apache Parquet is a columnar storage format used throughout data engineering and analytics, Spark, pandas, DuckDB, Arrow and virtually every data lake. It stores data in row groups with per-column compression and encoding, which makes it compact and fast to scan, but not human-readable without tooling.
Instead of firing up a notebook and calling read_parquet just to see what is inside, open the file here. ViewKit reads row groups on demand directly from the file on your disk, so even million-row files page instantly, and nothing is uploaded.
What you can do with the Parquet viewer
Schema tree
Browse nested columns with their physical and logical types (lists, structs, maps, decimals, timestamps).
Virtualized table
Scroll millions of rows smoothly, only the visible rows, read from the relevant row group, are ever in the DOM.
Column statistics
Stream min, max, null counts and distinct values across every row group with a progress bar.
Nested & wide data
List/struct/map values expand as JSON, double-click a column edge to fit its width, and you can sort loaded rows or hide columns.
How to open a Parquet file
- 1
Drop your .parquet file onto the box above (or click to browse). It is read in your browser, nothing uploads.
- 2
Browse the schema tree, then page through the virtualized table; scroll anywhere and only those row groups are fetched.
- 3
Click the Σ on a column for statistics, double-click a column edge to fit its content, or sort and hide columns as needed.
Doing the same thing in code
The same inspection in Python, using pyarrow:
import pyarrow.parquet as pq
pf = pq.ParquetFile("data.parquet")
print(pf.schema_arrow) # column names and logical types
print(pf.metadata.num_rows, pf.metadata.num_row_groups)
print(pf.metadata.row_group(0).column(0).statistics)
print(pf.read_row_group(0).slice(0, 10).to_pandas())pyarrow reads the schema and row-group metadata without reading the data itself. pandas.read_parquet is shorter but loads the entire file into memory first. This page reads the metadata up front and fetches row groups only as you scroll.
Parquet viewer: frequently asked questions
Does it read compressed Parquet?
Yes, Snappy, Gzip, Zstd, Brotli and LZ4-compressed files are all supported.
Why does my Parquet file show zero rows?
A Parquet file can carry a complete schema and contain no row groups, which is what an empty write or an interrupted job produces. The schema tree looks correct while the table stays empty. The row-group count distinguishes this from a failed read.
Can I open a partitioned dataset or a folder of Parquet files?
A partitioned dataset is a directory of individual .parquet part files, usually with the partition keys encoded in the folder names. Open any single part file to inspect the schema and the data; the partition columns live in the paths rather than inside the parts.
What do the column statistics tell me?
Each row group stores the min, max and null count per column, and query engines use them to skip row groups that cannot match a filter. They show the actual range of a column, whether a column is entirely null, and whether min and max are identical across every row group, which indicates the data is not sorted on that column.
Can it open very large Parquet files?
Yes. It reads row groups on demand straight from the file, so it never loads the whole file into memory, million-row, multi-row-group files open and scroll smoothly.
Is my data uploaded?
No. Parsing happens entirely in your browser; your file’s contents never leave your machine.
Can I see nested and 64-bit columns?
Yes, list/struct/map columns render as expandable JSON, and 64-bit integers, decimals, UUIDs, float16 and timestamps are handled without losing precision.