Process Large JSON Files - Worker, No localStorage Dump

Stats action

The worker parses once, walks the tree, and returns counts. You get nodes, objects, arrays, and keys without building a second copy of the file as indented text. That is the right first pass on a 30 MB dump when you only need to know how bushy it is.

Pretty action

{
  "users": [
    { "id": 1, "name": "Ada" },
    { "id": 2, "name": "Grace" }
  ],
  "ok": true
}

Download pretty.json. The preview may truncate; the download is the full string. Pretty-print of a 50 MB value can hitch when the string returns to the page - that is why stats exists.

Minify action

The worker returns a compact JSON.stringify with no extra whitespace. Download minified.json. Minify does not change keys or values; it only removes formatting characters outside of strings.

Inspecting a production API dump without uploading it

Support and backend teams often download a JSON export that is too large for a paste box. This page reads the File locally, so the dump never crosses the network. Stats tells you whether the file is a huge array, a nested object, or both before you decide to pretty-print.

Pretty-printing a minified export for a one-off review

Warehouse extracts and backup files are often one line. Pretty-print in the worker, download the result, then open a slice in an editor. Do not restore that pretty string into localStorage; that is the failure mode this tool is designed to avoid.

Minifying a formatted dump before you attach it

Someone formatted a 15 MB file with 2-space indent and email can no longer attach it. Minify in the worker and download the compact twin. The data is unchanged; only whitespace outside strings is gone.

Estimating shape before you write a parser

Node, object, array, and key counts are a cheap sketch of the document. A file with millions of nodes and few objects is probably a giant array of primitives or short records. A file with many objects and keys is a nested config or a graph. That sketch belongs here, not in a frozen textarea.

Keeping secrets off a formatter that persists drafts

Other JSON tools on this site may persist textarea drafts for 30 days. A customer export should not land there. This processor stores only the last action preference and the panel width - never the file bytes.

Rejecting files that would freeze the tab

The 50 MB cap is the product. Files over the cap get a size error instead of a silent hang. That is better than pretending a browser can stream a 2 GB dump. Split the file locally, then process a shard.

Checking that an export is actually JSON

Logs named .json are sometimes NDJSON or concatenated objects. The worker’s JSON.parse will fail with a message. That is the signal to split lines in a script, not to paste the blob into a repair tool that expects a small draft.

Preparing a smaller sample for query or schema tools

After you know the file is valid JSON, cut a sample and use JSON query or JSON Schema on a slice. This page is the intake step for large files, not a JSONPath engine and not a contract checker.

How large a JSON file can I process?

The documented cap is 50 MB. Some devices will run out of memory sooner. This is not a streaming GB parser and will not mmap a 2 GB dump in a tab. Split huge files locally before you open them here.

Why not use the JSON editor or formatter?

The editor and formatter hold the document in a textarea and typically persist drafts in localStorage. Browser quota for localStorage is around 5 MB per origin. A 20 MB API dump does not belong there. This page reads a File, parses in a Web Worker, and never writes the payload to localStorage.

Does the file leave my computer?

No. The File API and the worker run locally. Closing the tab drops the in-memory copy. Nothing is uploaded. That is why this tool is safe for exports that contain customer records, as long as nobody else can read the tab while it is open.

What if parse fails?

You get the worker error string. Repair small drafts on JSON repair; this processor expects a complete JSON value, not NDJSON lines unless you wrap them yourself. A trailing comma or concatenated log lines will fail JSON.parse inside the worker.

Can I pretty-print NDJSON?

Not as a single JSON.parse. NDJSON is one value per line. Concatenating lines is a different job. Split lines in a local script, or wrap them into a JSON array first, then process the array here if it still fits under 50 MB.

Will pretty-print of a huge file freeze the UI?

The parse runs in a worker. Serializing a 50 MB pretty string can still hitch when it returns to the page. Stats-only mode avoids building a giant output string. The on-page preview truncates very large pretty output so the DOM does not paint a million characters.

Why is the file not saved in localStorage?

localStorage is the wrong place for a multi-megabyte dump. Quota is small, the UI thread would freeze on restore, and you would be writing a copy of a file that already lives on disk. This page stores only the panel width (and optionally the last action), never the file bytes.

What do stats mode counts mean?

After parse, the worker walks the value and counts nodes, objects, arrays, and keys. Nodes include every value visited. Objects and arrays are structural. Keys are the number of object properties seen, not unique names across the file. Stats mode does not require building a pretty-printed twin.

Is this a streaming parser for gigabyte dumps?

No. The worker still holds the full string and the parsed value in RAM. The 50 MB cap is an honest browser limit, not a marketing understatement of a streaming engine. For gigabyte logs use jq, a local script, or a database - not a tab.

Is this JSON file processor free?

Yes. No signup and no upload quota, because there is no upload. Process files you are willing to hold in RAM, then download pretty or minified output when the worker finishes.