Convert JSON to Parquet

API responses and exports arrive as JSON, which is convenient to produce and expensive to analyse. This converter flattens the nested structure into columns, assigns each one a real type, and writes a compressed Parquet file you can query directly.

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

JSONParquet

Runs on your device
Options

Reading JSON

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 JSON to Parquet

  1. Finds the records: a top-level array, a single object, or the array inside an envelope like {"data": [...]}.
  2. Flattens nested objects into dotted columns, so {"user":{"id":7}} becomes a user.id column.
  3. Takes the union of keys across every record, so records with missing fields produce nulls rather than failing.
  4. Infers a type per column and writes it as a compressed Parquet column.
Format differences

JSON vs Parquet

Nested, self-describing records that every language can read. Typed, compressed, columnar storage built for analytical scans.

JSONParquet
Type informationStrings, numbers, booleans, nullFull — ints, floats, booleans, timestamps, decimals
StructureNested objects and arraysColumnar, with nested type support
CompressionNoneBuilt in (Snappy, Gzip, Zstd)
Typical file sizeLargest — keys repeat on every recordTypically 5–15% of the CSV
SchemaImplicit, per recordStored in the file footer
Human-readableYes, though verboseNo — binary
Tool supportEvery language, nativelySpark, DuckDB, pandas, BigQuery, Athena
Worth knowing

What to watch out for

Arrays are kept as JSON text, not exploded

A tags array becomes one column containing ["a","b"] as a string. Exploding arrays into tags.0 and tags.1 would make your column count depend on the longest array in the file, which turns one unusual record into hundreds of empty columns.

Ragged records widen the schema

Because columns are the union of all keys, a handful of records with extra fields adds columns that are null everywhere else. Use the record path option to target a consistent subset if this gets noisy.

Mixed types across records fall back to text

If id is a number in most records and a string in a few, the column is written as text to avoid losing data. Fixing the inconsistency upstream produces a much better Parquet file.

When you need this

Common reasons to convert JSON to Parquet

Making API exports queryable

A directory of JSON responses is awkward to analyse. One Parquet file loads into DuckDB or Spark and answers questions in milliseconds.

Feeding a data lake

Most lake table formats — Delta, Iceberg, Hudi — store their data as Parquet underneath. Converting at the edge saves a processing step later.

Shrinking verbose exports

JSON repeats every key on every record. Parquet stores each column once, which is why the size difference on large exports is dramatic.

FAQ

JSON to Parquet questions

Is my JSON uploaded to a server?
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.
How is nested JSON represented in Parquet?
As flattened columns with dotted names. Parquet does support genuinely nested types, but flat columns are what query engines optimise for and what most downstream tools expect. You can change the separator or turn flattening off in the options.
My JSON is wrapped in an envelope. Will that work?
Yes. A document like {"status":"ok","data":[...]} is unwrapped automatically when it contains exactly one array. For anything more complex, set the record path — for example result.items — in the input options.
What if my file is one JSON object per line?
That is JSON Lines, not JSON. Use the JSONL to Parquet converter instead; it reads the file line by line and tolerates a malformed line without failing the whole conversion.
How large a JSON 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.