A .parquet file is an Apache Parquet columnar data file. It is widely used in data engineering, analytics, and big data pipelines. If you received a Parquet file and do not have Python, pandas, or Jupyter installed, opening it can feel like a barrier.
The good news is that you do not need a full data science environment just to read the data. You only need a tool that understands the Parquet format.
Open the Parquet Viewer to view a supported .parquet or .parq file directly in your browser without installing Python or pandas.
What is a Parquet file?
Apache Parquet is a columnar storage format designed for efficient data processing. Unlike CSV or JSON, which store data row by row, Parquet stores data column by column. A .parquet file can contain:
- Columns - each column is stored separately with its own type and compression
- Row groups - data is split into row groups for parallel reading
- Column chunks - each column within a row group is a chunk
- Pages - column chunks are further split into pages for compression
- Schema - the file stores the data types and structure
- Metadata - statistics, encodings, and compression info
Parquet is used by:
- Apache Spark
- Apache Hive
- Apache Impala
- Databricks
- BigQuery exports
- Snowflake
- Pandas (
to_parquet/read_parquet) - DuckDB
- Many data lake and warehouse systems
Why Parquet files are hard to open without Python
Parquet is a binary, columnar format. It is not plain text, so you cannot open it in a text editor or a spreadsheet directly.
Common problems include:
- Not plain text: Opening a
.parquetfile in Notepad or TextEdit shows unreadable binary data. - No Excel support: Excel cannot import Parquet without a connector or conversion.
- Python dependency: Most tutorials assume you have Python with pandas or pyarrow installed.
- Jupyter dependency: Many guides suggest opening Parquet in a Jupyter notebook, which requires a full environment.
- Large files: Parquet files in production can be hundreds of megabytes or gigabytes.
- Schema complexity: Nested columns, maps, and lists can be difficult to inspect without a proper viewer.
The result is a file you received from a data pipeline or colleague but cannot easily read.
Quick answer: what should you do?
Choose the method based on what you actually need.
| What you need to do | Better approach |
|---|---|
| Quickly view rows and columns | Use a Parquet viewer |
| Check the schema and data types | Use a viewer that shows the schema |
| Query or filter the data | Use a viewer with SQL support |
| Export to CSV or JSON | Use a viewer with export support |
| Work with very large files | Use a viewer or a data tool designed for large datasets |
| Build charts or dashboards | Export to CSV and use a spreadsheet or BI tool |
| Integrate into a pipeline | Use Python, DuckDB, or Spark |
For a quick read, FileViewerHub is designed to show supported Parquet file contents in your browser without requiring Python or pandas.
Method 1: Open the Parquet file in FileViewerHub
This method is useful when you need to read the data, check the schema, or query the file rather than build a full data pipeline.
Step 1: Open the Parquet Viewer
Go to the FileViewerHub Parquet Viewer.
The viewer supports .parquet and .parq files and processes supported file contents locally in the browser for standard viewing.
Step 2: Select the Parquet file
Drag the file into the upload area or choose it from your device.
Before parsing begins, FileViewerHub may show a large-file warning when the file exceeds the recommended size for the current device. Files above the viewer's hard browser-safety limit should be blocked rather than opened.
This limit is intentional. A Parquet file can decompress into a much larger in-memory data structure after parsing.
Step 3: View the data grid
After the file opens, verify that:
- The data grid shows rows and columns.
- Column names and data types are shown.
- Numbers, dates, and text appear as expected.
- Nested or complex columns are handled where supported.
- The total row count looks reasonable.
FileViewerHub can parse standard Parquet files produced by Spark, pandas, DuckDB, and other tools where supported.
Step 4: Check the schema
For a Parquet file, the schema is one of the most useful things to inspect. Use the viewer to check:
- Column names
- Data types (string, int, float, boolean, timestamp, etc.)
- Nullable fields
- Nested structures (maps, lists, structs)
- Row group count and sizes
If the schema looks wrong, the file may have been produced by a tool that uses non-standard types or encodings.
Step 5: Query or filter the data
For a large Parquet file, manually scrolling through thousands of records is inefficient.
If the viewer supports SQL or filtering, use it to narrow the data to what you actually need. For example, you might:
- Select specific columns
- Filter rows by a condition
- Aggregate values
- Sort by a column
- Limit the result set
Keeping the task focused is usually faster than trying to load the complete dataset into a spreadsheet.
Step 6: Export only what you need
If the viewer supports export for the current file, export the relevant rows or columns to a more portable format such as CSV or JSON.
You can then open the smaller result in:
- Excel or another spreadsheet
- A database tool
- A reporting application
- Another program for sharing
This avoids forcing a spreadsheet or editor to handle a format it does not support natively.
Method 2: Use DuckDB
DuckDB is a lightweight analytical database that can read Parquet files directly. It does not require a Python environment, though it can be used from Python if you want.
Option A: DuckDB CLI (no Python needed)
- Download the DuckDB CLI for your platform from duckdb.org.
- Open a terminal.
- Run
duckdbto start the interactive shell. - Query the Parquet file directly:
SELECT * FROM 'your_file.parquet' LIMIT 10;
- To export to CSV:
COPY (SELECT * FROM 'your_file.parquet') TO 'output.csv' (HEADER, DELIMITER ',');
Option B: DuckDB in Python (if you have Python)
If you already have Python but not pandas, DuckDB is a simpler alternative:
import duckdb
result = duckdb.sql("SELECT * FROM 'your_file.parquet' LIMIT 10").fetchall()
print(result)
Limitations
- The CLI requires a terminal, which may be unfamiliar to non-technical users.
- Very large files may still require significant memory.
- DuckDB does not provide a graphical interface for browsing data.
Method 3: Convert Parquet to CSV
If you need to work with the data in Excel or another tool that does not support Parquet, convert it first.
Convert with DuckDB
Use the COPY command shown in Method 2 to export the Parquet file to CSV.
Convert with Python (if available)
If you have Python with pandas or pyarrow:
import pandas as pd
df = pd.read_parquet('your_file.parquet')
df.to_csv('output.csv', index=False)
Convert with a browser-based viewer
If the viewer supports export, open the Parquet file and export to CSV or JSON directly.
Limitations
- Very large Parquet files may produce CSV files that are too large for Excel.
- Nested columns may not convert cleanly to CSV.
- Conversion loses Parquet's type information (dates, timestamps, booleans).
Method 4: Use a cloud data platform
If the Parquet file is stored in a cloud data platform, you may be able to query it directly without downloading it.
Options include:
- BigQuery: Load Parquet files from Cloud Storage and query with SQL.
- Snowflake: Stage Parquet files and query with SQL.
- Databricks: Upload Parquet files to DBFS and query with Spark SQL.
- Amazon Athena: Query Parquet files in S3 with SQL.
These platforms require an account and are better suited for ongoing analytics rather than a one-time file read.
What if the Parquet file still won't open?
Even with a viewer or DuckDB, some Parquet files can be difficult to read. Common causes include:
1. The file is corrupted
Parquet files can be corrupted during transfer, download, or storage.
Symptoms include:
- Parser errors
- Missing columns or rows
- Truncated data
- Invalid metadata
If you suspect corruption, try to obtain a fresh copy of the file from the original source.
2. The file uses an unsupported Parquet version
Parquet has evolved over time. Most tools support the current standard, but very old or very new versions may not be fully compatible.
If the viewer shows partial content, the file may use a version or encoding that the parser does not fully support.
3. The file uses complex nested types
Parquet supports nested types such as:
- Lists
- Maps
- Structs
- Repeated fields
Not every viewer or tool handles every nested type. If a column appears empty or shows a placeholder, the type may not be fully supported.
4. The file is very large
Parquet files in production can be hundreds of megabytes or gigabytes. A very large file may exceed browser memory limits or take a long time to parse.
If the file is large, check whether you need the entire dataset or just a specific column or row group.
5. The file is not actually a Parquet file
Some files use the .parquet or .parq extension but are not valid Parquet files. For example, a renamed file or a file from another application may carry the extension without the correct internal structure.
If the viewer cannot parse the file, check the source and confirm it was produced by a Parquet-compatible tool.
6. The file uses an unsupported compression codec
Parquet supports several compression codecs:
- Snappy
- Gzip
- LZO
- Brotli
- Zstd
- LZ4
Not every viewer supports every codec. If the file uses an uncommon codec, the viewer may fail to decompress it.
How to open a Parquet file on Windows
On Windows, options include:
- Browser-based viewer: Open the Parquet Viewer in Edge, Chrome, or Firefox. No installation required.
- DuckDB CLI: Download and run the DuckDB CLI from a terminal.
- Python with pandas or pyarrow: If you have Python installed, use pandas or pyarrow to read the file.
- Excel with a connector: Some Excel versions and add-ins can connect to Parquet via Power Query.
For a quick read on Windows, a browser-based viewer is usually the fastest option.
How to open a Parquet file on Mac
On Mac, options include:
- Browser-based viewer: Open the Parquet Viewer in Safari, Chrome, Edge, or Firefox. No installation required.
- DuckDB CLI: Download and run the DuckDB CLI from Terminal.
- Python with pandas or pyarrow: If you have Python installed (e.g., via Homebrew or conda), use pandas or pyarrow.
- Numbers: Apple Numbers cannot import Parquet directly; convert to CSV first.
For a quick read on Mac, a browser-based viewer is usually the fastest option.
How to open a Parquet file on iPhone or Android
On mobile, installing Python or DuckDB is not practical. Options include:
- Browser-based viewer: Open the Parquet Viewer in your mobile browser. No installation required.
- Cloud platform: If the file is in a cloud data platform, query it from a mobile browser.
For a quick read on mobile, a browser-based viewer is usually the only practical option.
Parquet vs CSV: when to use which
| Aspect | Parquet | CSV |
|---|---|---|
| Format | Binary, columnar | Plain text, row-based |
| Size | Much smaller (compressed) | Larger |
| Schema | Stored in the file | Inferred or manual |
| Types | Strongly typed | Untyped (everything is text) |
| Excel support | No | Yes |
| Text editor | No | Yes |
| Best for | Analytics, pipelines, large datasets | Sharing, spreadsheets, simple tools |
If your goal is to read the data once, a viewer is the simplest option. If your goal is to share the data with someone who uses Excel, convert to CSV first.
Is it safe to open a Parquet file in an online viewer?
Parquet files can contain sensitive business or personal data, depending on the source.
For standard viewing, FileViewerHub processes supported Parquet file contents locally in your browser rather than uploading the file to FileViewerHub servers.
You should still:
- Use a device you trust.
- Avoid opening files from unknown sources.
- Review exported data before sharing it.
- Be aware that Parquet metadata can reveal schema and column names that may be sensitive.
Limited technical diagnostics may be processed when a viewer fails, but diagnostic logging should exclude filenames and file contents.
Parquet viewer vs Python: which should you use?
Use a Parquet viewer when your main goal is:
- Reading rows and columns
- Checking the schema and data types
- Querying or filtering the data
- Exporting to CSV or JSON
- Opening a file without installing Python
Use Python with pandas or pyarrow when you need:
- Data transformation
- Custom analysis
- Integration with other data sources
- Building a data pipeline
- Machine learning or statistical modeling
Use DuckDB when you need:
- SQL queries on Parquet files
- Analytical processing without pandas
- A lightweight local database
- Exporting large files to CSV
Use a cloud platform when you need:
- Querying files in cloud storage
- Large-scale analytics
- Collaboration across a team
- Integration with a data warehouse
The tools solve different problems. A Parquet viewer does not need to replace Python to be useful; it can help you read the file before deciding whether to set up a full data environment.
