Does this read any of the actual row data?

No. Only the file's footer metadata (its schema definition) is read, the column data pages themselves are never decoded, which is why this works even on very large files almost instantly.

What do the type labels like "STRING / UTF8 / BYTE_ARRAY" mean?

Parquet columns can carry up to three layers of type information: a physical storage type (like BYTE_ARRAY), an older converted type (like UTF8), and a newer logical type (like STRING) that superseded converted types. This tool shows whichever of these are present on a column, most specific first.

How is this different from the Parquet Metadata Reader?

This tool answers "what columns exist and what type is each one". The Parquet Metadata Reader instead answers file-level questions: total row count, how many row groups the file has, the writer's created_by string, and total byte size. Use this one for column-level structure, the other for file-level statistics.

Can this tool show nested (list or map) columns?

Yes, at the top level, a nested group column still gets a row with its own name; its inner fields aren't currently expanded into separate rows, since most everyday Parquet files here use flat, scalar columns.

Parquet Schema Reader - Read Column Types Online

Overview

Introduction

Sometimes you don't need to see any data at all, you just need to know what columns a Parquet file has and what type each one is, before deciding how to process it. This tool answers exactly that, instantly.

Upload a .parquet file and get a simple table of column name and type, read straight from the file's own embedded schema definition rather than inferred by sampling rows.

What Is Parquet Schema Reader?

A Parquet schema inspector that parses a file's footer metadata to recover its full column definition list, without decoding any row data pages.

Each column's type is described using whichever of Parquet's physical, converted, and logical type layers are actually present, so a text column shows as something like "STRING / UTF8 / BYTE_ARRAY" rather than just an opaque low-level storage type.

How Parquet Schema Reader Works

The uploaded file is wrapped as an in-memory buffer, and only its footer metadata is read, which is where Parquet stores the full schema as a flat list of elements before it's organized into a tree.

That schema is turned into a tree structure and walked one level deep to list every top-level column, with each column's logical type, converted type, and physical type formatted into a single readable label, falling back to "unknown" for any column missing all three.

When To Use Parquet Schema Reader

Use it before writing code against an unfamiliar Parquet file, to confirm exact column names and types without guessing from a data preview.

It's also useful for quickly checking whether a Parquet writer produced the column types you expected, for example confirming a numeric column landed as INT64 rather than being written as a string.

Often used alongside Parquet Metadata Reader and Parquet Reader and Viewer.

Features

Advantages

Reads only the file's footer, so it's fast even on very large Parquet files since no row data is decoded.
Shows all available type layers (logical, converted, physical) rather than just one, giving the most specific type information the file actually contains.
Works entirely client-side, no upload or server round trip required.

Limitations

Nested group columns (lists, maps) are shown at their top level only; inner fields aren't expanded into separate rows.
This tool shows structure only, not actual values, use the Parquet Reader and Viewer to see real data.

Examples

Reading a simple Parquet file's schema

Input

(a .parquet file with columns id INT64, name STRING, active BOOLEAN)

Output

id - INT64
name - STRING / UTF8 / BYTE_ARRAY
active - BOOLEAN

Each column's name and available type layers are listed in a simple two-column table, with no row data read at all.

Best Practices & Notes

Best Practices

Check this tool before the Parquet Reader and Viewer when you only need to confirm structure, it's faster since no data pages are decoded.
Pair with the Parquet Metadata Reader for a complete picture: this tool for column structure, that one for row counts and file-level stats.
Compare the schema against what a downstream tool or pipeline expects before a bulk conversion, catching a column name or type mismatch here is cheaper than after the fact.

Developer Notes

Type labels are built by checking `logical_type`, then `converted_type`, then the raw physical `type` field on each schema element, joining whichever are present with " / " rather than picking only one, since a column can legitimately have all three set and the more specific ones are more useful to a reader deciding how to handle the data.

Parquet Schema Reader Use Cases

Confirming exact column names and types before writing code against an unfamiliar Parquet file
Verifying a Parquet writer produced the expected column types
Quickly documenting a Parquet file's structure without opening a full data processing environment

Common Mistakes

Expecting this tool to show sample values, it only shows structure; use the Parquet Reader and Viewer for actual data.
Assuming every column will show all three type layers, many columns only have a physical type set, and this tool falls back gracefully rather than showing an error.

Tips

Use the type label to decide which converter to use downstream, for example a column with an INTEGER logical type is safe to treat as a number after CSV conversion.
If a column shows "unknown", it likely means the schema element is missing type information entirely, which is unusual but not necessarily an error in the file.

Parquet Schema Reader