JSON to CSV Converter — Online & Private

How JSON to CSV conversion works

JSON to CSV Converter runs JSON payloads through a deterministic, fully client-side pipeline and produces CSV output in a single pass — no round-trips, no queues, no waiting on someone else's server. Paste an array of objects (or a single object) into the input pane — nested objects are flattened with dot paths automatically. Press Run Conversion (or just pause typing — the studio parses as you go), and the generated output appears on the right with line numbers, syntax highlighting, and one-click copy or download.

JSON shape detection — arrays, objects, and flattening

The parser accepts the four shapes real JSON data arrives in: an array of objects (the canonical form — every API list endpoint), a single object (one row), an array of arrays (positional columns, first row as header), and an object of arrays (column name to values, the plotly/ dataframe encoding). No configuration is needed — the shape is detected structurally, and anything outside those forms is rejected with a precise message instead of a wrong answer.

Nested objects are flattened with dot paths — user.name becomes its own column named user.name — and array values serialize to their JSON text, so a nested API response converts without losing structure. Null becomes an empty cell, and numbers and booleans keep their native types into typed outputs. Headers are the union of keys in first-seen order, so records with missing fields convert with blanks rather than errors.

JSON to CSV: from trees to rectangles without losing data

CSV is rectangular; JSON is a tree — and the distance between those two shapes is where converters usually lose data. This one flattens deliberately: nested objects become dot-path columns (user.address.city stays addressable and auditable), arrays serialize to their JSON text inside the cell, and null becomes an empty cell rather than the string 'null'. The header set is the union of keys across every record in first-seen order, so sparse JSON — objects with different fields — converts with blanks instead of errors, and nothing is silently dropped because it appeared in row 402 but not row 1.

The type story is preserved honestly: JSON numbers and booleans keep their native types through the pipeline and serialize naturally into the CSV text (1200.5, true), while strings stay strings. No date guessing, no number coercion of identifier-like strings, no silent reformatting — the CSV is the JSON, flattened and quoted, and nothing else. That discipline is what makes the output safe to import into a database or spreadsheet without a data-integrity review.

RFC 4180 quoting and delimiter control

The generated CSV follows RFC 4180 exactly: fields containing the delimiter, a double quote, a line break, or leading/trailing whitespace are wrapped in quotes with internal quotes doubled — the escaping every spreadsheet, database loader, and pandas read_csv honors identically. Fields that need no quoting are emitted bare, so a clean table converts to visually clean CSV rather than a wall of unnecessary quotation marks.

The delimiter is a first-class option: comma (the default), semicolon (European spreadsheet exports), tab (TSV for shell pipelines and Excel paste), and pipe (legacy database dumps). Switching delimiters re-quotes on the fly — a field that was safe bare next to a comma gets quoted the moment you pick semicolons — so the output is always valid for the dialect you selected, never just a find-and-replace.

Private by architecture: your data never leaves the browser

Every stage of this conversion — parsing, type inference, and output generation — executes locally inside your browser's JavaScript engine. The input is never transmitted, logged, or stored: there is no upload endpoint, no queue, no telemetry, and no account to create. Files larger than 1MB are handed to a background Web Worker so the interface keeps animating at 60fps even on hundred-thousand-row imports, and the page keeps working offline once loaded because it is a fully static export.

That architecture makes the tool safe for the exports you would never paste into a random website: customer PII, financial line items, internal Salesforce extracts, and unreleased product data. Paste it, convert it, copy or download the result — and the bytes never moved from your machine.

Limits and practical tips

Inputs are capped at 15MB per file or paste — hundreds of thousands of rows in practice — purely as a browser-safety guard rather than a server policy, since there is no server involved at all. Processing is single-pass and deterministic: the same input with the same options always produces byte-identical output, which makes the generator safe to keep in CI pipelines and documentation. Pick the delimiter your consumer expects before copying — switching it later means re-checking which fields got quoted.

How do I convert JSON to CSV?

Paste your JSON — an array of objects, a single object, an array of arrays, or an object of column arrays — into the input pane and press Run Conversion. Every object becomes a row, the union of keys becomes the header in first-seen order, and the RFC 4180-quoted CSV appears instantly with copy and download buttons.

How are nested objects converted?

Nested objects are flattened with dot paths: user.name becomes a column named user.name, so a one-level API response converts cleanly. Arrays serialize to their JSON text within the cell. Deeply nested or recursive structures still convert — every leaf scalar becomes its own dotted column — so the output is always rectangular and spreadsheet-ready.

Is my JSON uploaded to a server?

No. Parsing and CSV generation run entirely inside your browser — the bytes never leave your machine, nothing is logged, and the page works offline once loaded. That makes it safe for payloads containing customer PII, internal API responses, or unreleased data.

What JSON shapes are supported?

Four: an array of objects (the canonical API list), a single object (one row), an array of arrays (first row is the header), and an object of arrays (column name to values). Anything else — bare numbers, strings, or mixed arrays — is rejected with a specific message rather than converted to nonsense.

Does the converter handle large JSON files?

Yes — pastes and files up to 15MB, comfortably hundreds of thousands of rows. Inputs over 1MB are parsed in a background Web Worker so the page stays responsive, and conversion time scales linearly with row count. The header union is computed in a single pass, so wide objects with sparse keys do not quadratic-bomb the parser.

What happens to null values and missing fields?

JSON null becomes an empty CSV cell, and records missing a key that other records carry get the same empty cell for it — the header set is the union of all keys, so sparse arrays of objects convert with blanks rather than errors or dropped columns. That is the correct default for spreadsheets and database imports, where an empty cell is the universal 'no value' signal. The string 'null' from your data stays the literal text 'null', distinct from a real JSON null.

Why is my deeply nested JSON producing so many columns?

Because flattening is exhaustive by design: every leaf scalar becomes its own dot-path column (user.address.city), which preserves all data at the cost of width. If the output is wider than you want, pre-shape the JSON (map it to the fields you need) or post-filter the CSV columns — both are safer than a converter guessing which branches to collapse. Arrays inside objects serialize to JSON text in a single cell rather than exploding, so width is bounded by your object depth, not array length.