How to Open, Edit and Convert a Parquet File Online (No Install)

You download a dataset — from Hugging Face, from an analytics export, from a client's data team — and it arrives as data.parquet. Excel refuses it. The preview pane shows binary garbage. The Stack Overflow answer says install Python, install pandas, install pyarrow, and write four lines of code just to see what columns are in it.

For a file you only need to look at, that is an absurd amount of setup. This guide covers how to open, inspect, edit, query and convert Parquet files entirely in a browser tab using Parquetbay — and, just as importantly, when a browser is the wrong place to do it.

Why This Matters

Parquet stopped being a Hadoop-era niche format and became the default currency of data exchange. Hugging Face's dataset viewer automatically converts and publishes public datasets as Parquet (docs), and any dataset already in Parquet is published as is. Analytics warehouses export to it. Model evaluation logs land in it. Embeddings get shipped in it.

Which means a growing number of people who are not data engineers now routinely receive Parquet files — and the tooling assumes you are one.

What Parquet Actually Is (And Why Excel Chokes)

A CSV stores data as rows: read line 1, you get every field of record 1. Parquet stores data as columns: all the values of user_id are together, then all the values of timestamp, and so on.

That single flip buys three things:

• Compression that actually works. A column holds one kind of value, so similar data sits next to similar data. Parquetbay lets you write with Snappy, Zstandard, or no compression at all.
• Column pruning. A query touching 3 of 200 columns reads only those 3 off disk. On a wide table this is the difference between a second and a minute.
• A schema inside the file. Types travel with the data. No more guessing whether a CSV column is a string, an integer, or a date in an ambiguous format.

The cost is that it is a binary format with an embedded schema, not lines of text. There is nothing for a spreadsheet program to parse, which is why the double-click fails.

Step 1: Open the File — Without Uploading It

Go to parquetbay.com and drop the file on the page.

The critical property here is that nothing uploads. Processing happens in the browser tab, using WebAssembly. There is no account system, no analytics, and no advertising trackers.

You do not have to take that on faith, and you shouldn't — this is the exact claim most "free online converter" sites make while doing the opposite. Open your browser's developer tools, switch to the Network panel, and load the file. If the tool is telling the truth, no request carries a row of your data. That takes fifteen seconds and it is the only verification that matters when the file contains anything sensitive.

Formats it will open:

Multiple files open as tabs, and an Excel workbook exposes each sheet separately — useful when the actual task is comparing two exports rather than reading one.

Step 2: Inspect Before You Touch Anything

The grid is virtualized: it renders only the rows currently visible, so scrolling a large table stays responsive instead of trying to paint a million rows into the DOM.

Before editing, use column profiling. It reports each column's type, null count, distinct count, and value distribution. This is the step people skip and then regret. Profiling answers the three questions that determine whether the dataset is usable at all:

• Is this column actually the type I assumed?
• How many nulls am I about to silently average over?
• Is this "categorical" column 12 distinct values, or 400,000?

Step 3: Edit — And Understand What "Edit" Means

You can edit cells directly, add and delete rows and columns, rename and reorder columns, cast types, and run find and replace across a single column or the whole table. Changes are journaled, so individual steps can be reordered, disabled, or undone before you export.

There is a concept here worth internalising, because it explains behaviour that otherwise looks like a bug:

Parquet files are immutable, so every edit — in DuckDB, in Spark, or on this page — is really a read, a transform and the rewrite.

Nothing edits a Parquet file in place. Anywhere. What you are building in the editor is a pipeline of transformations that gets applied when you write a new file. Two consequences follow:

• Your original file is never modified. That is a safety property, not a limitation.
• Edits live in memory until you export. Close the tab and unexported changes are gone, by design — there is no server holding them.

One behaviour worth flagging: a failed type conversion produces null, not a silent coercion into something wrong. Cast a column of messy strings to integer and the unparseable values become null rather than zero. That is the correct choice — zero would quietly corrupt every downstream average — but it means you should re-profile the column after casting to see how many rows you just lost.

Step 4: Query It With SQL, Locally

The transform pipeline handles filter, sort, derive, rename, cast and reshape. Past that, there is a DuckDB SQL console — DuckDB compiled to WebAssembly, running inside the tab.

That is a genuinely serious analytical engine, not a toy query box. Joins, window functions and aggregates all work, and results open as their own tab, which means you can chain: query, inspect the result, query the result.

SELECT
  category,
  COUNT(*)                AS rows,
  AVG(score)              AS avg_score,
  COUNT(*) FILTER (WHERE score IS NULL) AS missing
FROM data
GROUP BY category
ORDER BY rows DESC;

For anyone who already knows SQL, this is usually faster than clicking through a transform UI — and it is the same dialect you would run against DuckDB on your laptop, so the query is portable the moment the dataset outgrows the browser.

Step 5: Convert and Export

Export to any supported format, independent of what you opened. Parquet output takes a compression choice: Snappy (fast, the common default), Zstandard (smaller files, more CPU), or uncompressed.

Beyond the data formats, it will also emit text: Markdown, SQL, HTML, YAML, XML, and LaTeX — handy when the real destination is a README, a docs page, or a paper rather than another pipeline.

The common conversions have dedicated pages:

• Parquet to CSV
• CSV to Parquet
• Parquet to JSON
• Parquet to Excel

A note on the direction most people get wrong: converting CSV to Parquet before analysis is often the highest-value thirty seconds in the whole workflow. You get compression, real types, and a schema that stops the next tool from guessing.

Open Your Parquet File

The Honest Limits

Memory is the ceiling. There is no fixed row cap, but capacity depends on your browser, device memory, the file's encoding, column types, and what you are doing to it. A compressed file needs meaningfully more memory once decoded than its size on disk suggests.

It needs JavaScript and WebAssembly. Not an issue on a modern browser, occasionally an issue on a locked-down managed device.

No service worker. Reloading the page generally needs a network connection to re-fetch static assets, so it is not a true offline app.

Unexported edits are lost on close. Worth repeating because it will bite someone.

When you hit those limits, the escape hatch is straightforward and free: install DuckDB locally and run the same SQL against the file directly. Nothing you learned in the browser is wasted.

Where This Fits an AI Workflow

Three recurring jobs where the browser tool is genuinely the right one:

Triaging a downloaded dataset. Before writing any training or evaluation code, open the file, profile the columns, and find out how many nulls and duplicates you actually have. Ten minutes here routinely saves a wasted run.

Inspecting evaluation logs. Eval harnesses emit per-example results in Parquet. Sorting by score to read the worst failures — a WHERE score IS NULL OR score < 0.3 in the SQL console — is the fastest route to understanding why a model is failing rather than just that it is.

Handing data to a non-technical stakeholder. They want XLSX. The pipeline emits Parquet. This is a two-click conversion instead of a script.

If what you actually want is charts and narrative answers rather than the file itself, a chat-based analyst like Julius AI is the better fit — different job, different tool.

Frequently Asked Questions

Do I need Python or pandas to read a Parquet file? No. That is the standard answer online, and it is overkill for inspection. A browser tool or a local DuckDB install reads Parquet directly. Reach for Python when you need the file inside a larger program, not to look at it.

Can I edit a Parquet file in place? No tool can — the format is immutable. Every editor, including this one, reads, transforms and writes a new file. What varies is whether the tool is honest about it.

How does this compare to opening the file in DuckDB directly? Same engine. The browser version adds a grid, profiling, a reversible transform pipeline and format conversion, at the cost of a memory ceiling. Use the browser for exploration and one-off conversions; use the local install for anything scripted, scheduled, or too big.

Is Parquet better than CSV? For analytics, in almost every respect: smaller, faster, typed, self-describing. CSV keeps exactly one advantage, and it is a real one — every program on earth can read it. That is why the conversion tools exist in both directions.

Three Free Browser Tools Worth Bookmarking

Parquetbay belongs to a small category of tools that solve one unglamorous problem completely — free, no account, no upsell. Two others earn a place in the same bookmark folder:

The pairing that comes up most often in practice: a dataset too large to email and too large for a transfer service's free tier. Profile and trim it in Parquetbay, export to compressed Parquet, then hand the result straight to the other machine with Pairchute — no cloud copy at either step.

One honest distinction across the three: Parquetbay and Pairchute never upload anything, and you can verify that in the Network panel. DumpReader does upload, parsing server-side and discarding the bytes with the response — a different privacy model, worth knowing in advance.

The Bottom Line

Parquet became the default format for AI and analytics data, and the tooling never caught up for people who just need to look inside a file. A browser tab with a virtualized grid, column profiling, a reversible edit pipeline and a local DuckDB console closes most of that gap — for free, with no account, and without your dataset leaving the machine.

Use it for triage, inspection, and one-off conversion. Graduate to a local DuckDB install the moment the dataset stops fitting in memory or the job needs to run twice.

Open Parquetbay — Free, Nothing Uploaded