Convert JSON to Parquet Online Free

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

Converts to Apache Parquet on secure servers · first daily conversion free · no signup

Your first conversion each day is free. A $2.99 one-time Day Pass unlocks 24 hours and ends by itself.

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.

First daily conversion free No signup required Encrypted transfer · Async jobs kept up to 24h Queued when needed Updated May 2026

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

Developers

Convert JSON config files to Apache Parquet for compatibility with different tools or frameworks
Transform JSON API responses to Apache Parquet for debugging, logging, or documentation

Validate the converted Apache Parquet output with a linter to catch any structural issues from the conversion

Watch for data type coercion (e.g., numbers becoming strings) when converting between JSON and Apache Parquet

Data Analysts

Convert JSON exports to Apache Parquet for importing into spreadsheet software, databases, or BI tools
Transform JSON datasets to Apache Parquet for sharing with teammates who use different analysis tools

Check that column delimiters and quote escaping are handled correctly in the converted Apache Parquet file

Preview the first few rows of the Apache Parquet output to verify headers and data alignment

System Administrators

Convert JSON configuration to Apache Parquet when migrating between infrastructure tools or platforms
Transform JSON log exports to Apache Parquet for ingesting into monitoring or analysis systems

Back up the original JSON config before converting, especially for production systems

Test the converted Apache Parquet in a staging environment before deploying to production

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: 25 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