Parquet File Viewer

Open a .parquet file in your browser to read its footer: column names and types, row count, row groups, compression codecs and the writer.

The interactive tool loads here when JavaScript runs.

About this tool

What is the Parquet File Viewer?

The Parquet File Viewer reads the metadata footer of an Apache Parquet file directly in your browser. Choose a .parquet file and it shows every leaf column with its physical type, logical type (STRING, DATE, DECIMAL(10,2), TIMESTAMP(MICROS) and so on), repetition and whether it can be null, plus the total row count, the number of row groups, the compression codecs and encodings used, and the library that wrote the file.

It reads only the footer, so even a multi-gigabyte file is summarised quickly and nothing is uploaded. It does not decode row values: showing data would need every codec (Snappy, ZSTD, GZIP and others) and Parquet's page encodings. For rows, use DuckDB, pandas or parquet-tools.

The converter turns the summary into JSON, YAML or CSV. You can also paste your own JSON, for example an array of rows exported from another tool, into Manual Data and convert it to CSV or YAML.

  • Reads the real Parquet footer with a built-in Thrift compact decoder
  • Physical and logical types, repetition and nullability per column
  • Row count, row groups, codecs, encodings and writer version
  • JSON, YAML and CSV export of the summary
  • Files are read locally and never uploaded
Read the guide: What Is a Parquet File? Row Groups, Footers and Types Explained

Updated

How to use the Parquet File Viewer

  1. Open the Upload File tab and click Choose Parquet File.
  2. Pick a .parquet file. The footer is read locally and a toast confirms the row, column and row group counts.
  3. Review Schema Information: encodings, compression, row count, writer and the table of fields with type and nullability.
  4. Pick an Output Format (JSON, YAML or CSV) and click Convert Data. CSV lists the schema fields.
  5. Copy or download the result. To convert other JSON, paste it in the Manual Data tab first.

Worked examples

What the footer tells you

Input

A file written by parquet-cpp-arrow 15 with columns id, name and a nested address.city

Output

Rows: 1,000,000,123 in 1 row group(s)
Compression: SNAPPY, ZSTD
Encoding: PLAIN, RLE_DICTIONARY
id INT64 (not nullable), name BYTE_ARRAY (STRING), address.city BYTE_ARRAY (UTF8)

This is the footer used in the viewer's tests. The nested column shows as a dotted path, and it is nullable because its parent group address is OPTIONAL. The two string columns carry the newer STRING and the older UTF8 annotation respectively.

A file that is not Parquet

Input

export.parquet that is really a CSV

Output

Could not read export.parquet: Missing "PAR1" magic at the end of the file

Renaming a file does not change its format. The viewer checks the magic bytes instead of trusting the extension.

Background and insight

Parquet was created by Twitter and Cloudera in 2013, based on the columnar layout described in Google's 2010 Dremel paper, and became a top-level Apache project in 2015. Instead of storing rows one after another, it stores each column's values together in column chunks, grouped into row groups. Similar values sit next to each other, so dictionary and run-length encoding plus a codec such as Snappy or ZSTD shrink them dramatically, and a query that reads three columns out of fifty only reads those three.

The file layout is what makes this viewer possible. A Parquet file starts with the four bytes PAR1, then the column data, then a FileMetaData structure serialized with Apache Thrift's compact protocol, then a 4-byte little-endian length of that footer and PAR1 again. Readers seek to the end, read the length, and parse the footer to find everything else. If a file does not end in PAR1, it was truncated or is not Parquet at all.

The schema in the footer is a flattened tree. Nested columns appear as paths such as address.city, and each element is REQUIRED, OPTIONAL or REPEATED. Logical types sit on top of a handful of physical types: a string is a BYTE_ARRAY annotated as STRING, a date is an INT32 counting days since 1970-01-01, and a decimal can be INT32, INT64 or a fixed-length byte array.

Common use cases

  • Checking an export before loading it

    Confirm column names, types and row count of a data lake file before writing a COPY or CREATE TABLE statement.

  • Debugging schema drift

    Compare two files from the same pipeline to find a column that changed from INT32 to INT64 or became nullable.

  • Auditing compression

    See whether files were written with Snappy, ZSTD or no compression at all, and how many row groups they have.

  • Sharing a schema

    Convert the schema to YAML or CSV to paste into documentation or a ticket.

Tips and limitations

  • Many small row groups slow down queries. Writers such as Spark and pyarrow let you set row group size; 128 MB to 1 GB of uncompressed data per group is a common target.
  • INT96 timestamps come from older Spark and Impala writers. Modern readers prefer INT64 with a TIMESTAMP logical type.
  • Only the footer is read, so the row count comes from metadata. A file whose footer is damaged cannot be summarised.
  • Nullable means the column or one of its parent groups is OPTIONAL or REPEATED.
  • Manual Data accepts an array of row objects or an object with a sample_data array for CSV output.

Sources and further reading

  1. File Format, Apache Parquet. PAR1 magic, column chunks, row groups and the footer
  2. Metadata, Apache Parquet. The Thrift FileMetaData structure the viewer reads
  3. Logical Type Definitions, Apache Parquet. How STRING, DATE and DECIMAL sit on physical types
  4. Dremel: interactive analysis of web-scale datasets, Proceedings of the VLDB Endowment. Melnik and colleagues' 2010 Google paper that Parquet's nested columnar layout is based on

Frequently asked questions

How do I see the schema of a Parquet file without Python?

Open the file in this viewer. It reads the FileMetaData footer in your browser and lists each column's name, physical type, logical type and nullability. No install is needed, and the file is not uploaded anywhere.

Can this viewer show the rows of a Parquet file?

No. It reads the schema and statistics from the footer only. To see rows, run SELECT * FROM 'file.parquet' LIMIT 20 in DuckDB, or pandas.read_parquet in Python, both of which decode every codec and encoding.

How many rows are in my Parquet file?

Upload it and read the Rows line under Schema Information. The count comes from the num_rows field in the footer, which writers fill in from the row groups, so it is exact and does not require scanning the data.

Why is a string column shown as BYTE_ARRAY?

Parquet has only a few physical types. Text is stored as BYTE_ARRAY and marked with a STRING (or older UTF8) annotation that tells readers to decode it as UTF-8. The viewer shows both, for example BYTE_ARRAY (STRING).

What does "Missing PAR1 magic" mean?

Every Parquet file starts and ends with the four bytes PAR1. If they are missing at the end, the file was cut off during a copy or upload, or it is a different format with a .parquet extension.

Which compression codec does my Parquet file use?

The Compression line lists every codec found in the column chunk metadata, such as SNAPPY, ZSTD or GZIP. Different columns can use different codecs, so you may see more than one.

Is there an in-depth guide to the Parquet File Viewer?

Yes. “What Is a Parquet File? Row Groups, Footers and Types Explained” covers the background, how it works, common pitfalls and worked examples. Read the full guide.