Convert JSON to Parquet Online Free

Pack JSON arrays or NDJSON into a typed, columnar Apache Parquet file. Nested objects become structs, arrays become repeated columns, and types are inferred from your data.

By ChangeThisFile Team · Last updated: March 2026

Quick Answer

ChangeThisFile converts JSON to Apache Parquet by parsing the top-level array (or NDJSON stream), unifying keys into a Parquet schema with nested structs and lists, inferring types, and writing a Snappy-compressed columnar file. The output is standard Apache Parquet — readable by Spark, DuckDB, Polars, and PyArrow. Free, encrypted upload, files auto-deleted after conversion.

Free No signup required Encrypted transfer · Auto-deleted Under 2 minutes Updated May 2026

Convert JSON to Apache Parquet

Drop your JSON file here to convert it instantly

Drag & drop your .json file here, or click to browse

Convert to Apache Parquet instantly

JSON vs Apache Parquet: Format Comparison

Key differences between the two formats

Feature	JSON	Parquet
Storage layout	Row-oriented text	Column-oriented binary
Schema	Implicit per-document	Embedded, strongly typed
Nested data	Native objects and arrays	Structs, lists, maps (Dremel)
Compression	None (text)	Snappy/GZIP/ZSTD/LZ4 per column
File size	Verbose (repeated keys)	Compact (5-10× smaller typical)
Query speed	Full scan, line-by-line	Column projection + row-group skip
Best for	APIs, debugging, MongoDB	Analytics, Spark/DuckDB pipelines

When to Convert

Common scenarios where this conversion is useful

Compacting verbose JSON exports

JSON repeats every key on every record. Parquet stores keys once in the schema and compresses values column-by-column — often shrinking a JSON dump 5-10×.

Loading API dumps into a data warehouse

An API export sitting as JSON or NDJSON loads slowly into Spark/DuckDB. Convert to Parquet once, then re-query cheaply.

Type-locking event streams

JSON event logs from app analytics or webhook captures lack types. A one-shot conversion infers types so downstream queries don't need to cast at read time.

Building a partitioned data lake

Turn daily JSON event dumps into per-day Parquet partitions for Hive-style query layouts in Athena, BigQuery, or Trino.

Who Uses This Conversion

Tailored guidance for different workflows

For Backend Developers

Convert a JSON API dump into Parquet for cheaper warehousing in S3 + Athena
Compress a webhook event log into a queryable Parquet file for ad-hoc analysis
Hand a Parquet file to the data team instead of a multi-gig JSON export

Normalize record shapes first — heterogeneous JSON can produce wide, sparse Parquet schemas

Use NDJSON instead of one giant array if your file is approaching the 50MB limit

For Data Engineers

Stage external JSON data as Parquet before ingesting into Snowflake, BigQuery, or Athena
Convert daily JSON dumps to Parquet partitions for a Hive-style layout in S3
Build a quick local DuckDB warehouse from JSON event streams

Inspect the inferred schema with `pq.read_schema(...)` before committing a downstream pipeline

If a column is mixed-type, pre-clean upstream — STRING fallback can mask type bugs

How to Convert JSON to Apache Parquet

1

Upload your .json file

Drop a JSON array, NDJSON file, or single-object JSON. Up to 50MB per upload on the anonymous endpoint.
2

Schema unification and encoding

Records are scanned to unify keys into a Parquet schema. Types are inferred (int, double, boolean, ISO timestamp, string), nested objects become structs, and arrays become repeated fields.
3

Download the Parquet file

Snappy-compressed Parquet is delivered as a download. The uploaded JSON is auto-deleted from disk immediately after conversion.

Automate this conversion

Convert JSON to Apache Parquet via API

Integrate this conversion into your pipeline with 3 lines of code. Free tier: 1,000 conversions/month.

curl -X POST https://changethisfile.com/v1/convert \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -F "file=@input.json" \
  -F "target=parquet" \
  -o output.parquet --fail

const form = new FormData();
form.append('file', fileInput.files[0]);
form.append('target', 'parquet');

const res = await fetch('https://changethisfile.com/v1/convert', {
  method: 'POST',
  headers: { 'Authorization': 'Bearer YOUR_API_KEY' },
  body: form
});
const blob = await res.blob(); // your converted Apache Parquet file

Replace YOUR_API_KEY with your free key — no credit card needed.

Get a free API key

Frequently Asked Questions

Does this support NDJSON (newline-delimited JSON)?

Yes. The converter accepts a top-level JSON array, NDJSON (one object per line), or a single JSON object. NDJSON is preferred for very large files because it streams without holding the full document in memory.

How are nested objects and arrays mapped?

Nested objects become Parquet structs (group types). Arrays become repeated fields (Dremel-encoded). The resulting schema is the union of all keys seen across records; missing keys in any record become NULL.

How is the schema inferred?

The converter scans records to collect the union of all keys, then samples values per leaf field. Consistent integers → INT64, consistent numbers → DOUBLE, consistent booleans → BOOLEAN, ISO 8601 strings → TIMESTAMP, otherwise STRING. Mixed types fall back to STRING.

What happens if my JSON records have different shapes?

The output schema is the union of all keys. Records missing a key get NULL in that column. Records with extra keys not seen earlier in the scan may trigger a re-emission of the schema; for best results, normalize your JSON or pre-flatten irregular records.

What compression is used?

Snappy by default. It's the ecosystem default and balances ratio with decode speed. The output is a single row group; repartition with PyArrow if you need a specific row-group layout.

Will Spark / DuckDB / PyArrow read this?

Yes. Output is standard Apache Parquet with a Thrift footer and Snappy column compression — compatible with PyArrow 8+, DuckDB 0.7+, Spark 3.x, and Polars.

What's the size limit?

50MB per upload, 5 requests per minute per IP on the anonymous endpoint. Use the authenticated /v1/convert API for higher limits.

Are my files private?

Yes. HTTPS upload, ephemeral temp directory, deleted immediately after the conversion response. We don't log file contents.

How are nulls and missing values handled?

JSON `null` → Parquet NULL. Missing keys in a record → NULL in that column. Empty strings stay as empty strings, not NULL.

Related Conversions

Compare JSON vs Apache Parquet

Related Tools

Free tools to edit, optimize, and manage your files.

Data Prettify Data Validate Merge CSV

Read our guides on file formats and conversion

Ready to convert your file?

Convert JSON to Apache Parquet instantly — free, no signup required.

Start Converting