Convert JSONL to Parquet

JSON Lines is what logs, event streams and exports look like on the way out of a system. Parquet is what they should look like before anyone queries them. This converter reads the file line by line and writes a typed, compressed columnar file.

  • Runs in your browser
  • No signup
  • No upload
  • Free

JSONLParquet

Runs on your device
Options

Reading JSONL

Writing Parquet

Parquet is unreadable in a text editor. That is by design.Check your new Parquet file with ParquetReader — opens Parquet files directly.
What happens

How this converter handles JSONL to Parquet

  1. Reads one JSON object per line, tolerating blank lines and trailing newlines.
  2. Skips a malformed line and reports it, rather than failing the entire file because one record was truncated.
  3. Flattens nested objects into dotted columns and takes the union of keys across every line.
  4. Infers a type per column and writes compressed Parquet.
Format differences

JSONL vs Parquet

One JSON object per line, built for streaming and appending. Typed, compressed, columnar storage built for analytical scans.

JSONLParquet
Type informationStrings, numbers, booleans, nullFull — ints, floats, booleans, timestamps, decimals
StructureOne nested object per lineColumnar, with nested type support
CompressionNoneBuilt in (Snappy, Gzip, Zstd)
Typical file sizeSlightly under JSONTypically 5–15% of the CSV
SchemaImplicit, per lineStored in the file footer
Human-readableYes, one record at a timeNo — binary
Tool supportLog pipelines, LLM training sets, BigQuerySpark, DuckDB, pandas, BigQuery, Athena
Worth knowing

What to watch out for

Truncated last lines are common and are skipped

Log files that were copied mid-write often end with a partial record. That line is skipped and counted in the warnings, so you know it happened.

Schema drift widens the table

Event streams gain fields over time. Because columns are the union of all keys, old records simply get nulls for the newer fields — which is usually what you want, but it does explain a wide result.

Deeply nested events flatten aggressively

Structured log records nested five or six levels deep produce long dotted column names. Setting a record path or pre-filtering the fields you need keeps the output manageable.

When you need this

Common reasons to convert JSONL to Parquet

Making log exports analysable

A day of JSONL logs converted to Parquet can be queried with DuckDB in seconds instead of scanned line by line.

Preparing LLM training or evaluation sets

JSONL is the standard interchange format for datasets; Parquet is far more efficient once you are filtering and sampling repeatedly.

Loading event data into a warehouse

BigQuery, Athena and Snowflake all ingest Parquet more cheaply than raw JSON, because they scan less data.

FAQ

JSONL to Parquet questions

Is my file uploaded?
No. The conversion runs in your browser using WebAssembly and JavaScript. The file is read from your disk into a Web Worker, converted in memory, and handed back as a download. It is never sent to a server, so there is nothing for us to store, log or leak.
What is the difference between JSONL, NDJSON and JSON Lines?
Nothing meaningful — they are three names for the same convention of one JSON value per line. Files use .jsonl and .ndjson interchangeably, and both work here.
What happens to a line that is not valid JSON?
It is skipped and counted. The conversion completes with a warning telling you which line failed first and how many were skipped in total, so a single bad record does not cost you the whole file.
My records do not all have the same fields. Is that a problem?
No. The column set is the union of all keys, and records missing a field get a null. This is the normal shape of event data and is handled without configuration.
How large a file can this handle?
The practical ceiling is your available RAM, not a server upload limit. Files in the low hundreds of megabytes convert comfortably on a normal laptop. Very large files are best split first, since the browser has to hold the parsed data in memory.