What JSON shape does this tool expect?

An array of objects works best, and it's the common case: each object becomes one CSV row, and the union of every object's keys becomes the header. A single JSON object (not wrapped in an array) works too and produces a one-row CSV with that object's own keys as headers. A flat array of primitives, like [1, 2, 3] or ["a", "b"], is accepted as well, but there's no key to use as a column name, so it gets wrapped into a single column literally named 'value'. Then there's an array of arrays, like [[1,2],[3,4]]. Each inner array doesn't become a row of separate columns, it gets serialized whole as a JSON string into that same 'value' column instead, because the converter's column-detection logic is built around object keys, not positional array elements. If your data is naturally tabular but shaped as arrays instead of objects, convert it to an array of objects with named keys first.

How are nested objects handled?

Nested objects flatten into dot-notation columns: { "user": { "name": "Ada", "address": { "city": "London" } } } becomes two columns, user.name and user.address.city, with the nesting fully collapsed into the column name no matter how many levels deep it goes. This works recursively at any depth, so a five-level-deep nested field ends up as a five-segment dot-notation column name. There's a small special case for an empty nested object ({}): since it has no keys to flatten, it becomes a single column holding the literal string "{}" rather than disappearing or producing an empty column name. Flattening trades structure for tabularity, which is the whole point of a spreadsheet-friendly format, but it means you can't convert the resulting CSV back into the exact original JSON shape without already knowing that dots in a header name meant nesting rather than literal characters in a key.

What happens to nested arrays inside a row?

Arrays inside a row get serialized as a JSON string in a single cell, since CSV has no native concept of a nested list. { "id": 1, "tags": ["admin", "editor"] } produces a tags column containing the literal text ["admin","editor"], quoted per RFC 4180 because that JSON text itself contains commas and quote characters. That holds whether the array contains primitives or objects, an array of objects gets serialized the same way, as one big JSON string in one cell, not expanded into further columns or rows. Open the resulting CSV in a spreadsheet and that cell just looks like raw text, not a usable list; you'd need to parse it back out with a formula or a script to work with the individual items. If the array values matter as much as the flat fields, it's worth asking whether CSV is even the right target format, or whether you should flatten the array into a fixed number of numbered columns (tags.0, tags.1, ...) by hand first.

What if different objects have different keys?

The converter collects the union of all keys across every object in the array as columns, in first-seen order rather than alphabetical, so a later object introducing a new key just adds a column at the end without disturbing the ones already established. Rows missing a given key get an empty cell there, indistinguishable in the output from a row where that key was explicitly present with a value of null, since both render as blank. That's deliberate. Building the full column set up front, instead of only using the first object's keys, means data doesn't silently disappear just because it happened to show up partway through the array, which is exactly what a naive implementation that only looks at row one would do. The tradeoff: a single outlier object with a rare extra key adds a column that's blank for every other row, so check the header row for one-off keys if you want a tighter CSV.

Is my JSON data uploaded to a server when converting to CSV?

No. Parsing, flattening, and CSV serialization all happen locally in your browser. There's no backend call that receives your JSON or the resulting CSV, and downloading the file is handled client-side too, generated directly in the browser rather than fetched from a server. Nothing about your data, including its size or structure, gets transmitted anywhere. That matters especially here because JSON-to-CSV conversion usually involves exporting real records, user data, order histories, log entries, for someone to open in a spreadsheet, exactly the kind of data you don't want passing through a third-party server even briefly. Check your browser's network panel while converting if you want to confirm it yourself; there's no request tied to the JSON you pasted or the CSV you downloaded.

How is this different from JSON to XML or JSON to YAML?

XML and YAML are both still hierarchical formats: converting JSON to either one preserves the original nesting, arrays, and types, an object stays an object, a nested array stays a nested array, just rewritten in different syntax. CSV can't represent that structure at all. It's fundamentally flat, rows and columns, so this converter has to make lossy decisions XML and YAML conversion never needs to: flattening nested objects into dot-notation column names, and serializing nested arrays as opaque JSON-string cells instead of real nested data. The upshot is that JSON to XML and JSON to YAML round-trip cleanly (you can convert back to equivalent JSON), while JSON to CSV generally doesn't. Once a structure is flattened into dot-notation columns and array cells, reconstructing the original shape means knowing the flattening convention, not just having the file. Reach for CSV when the destination is a spreadsheet or a tool that only accepts tabular input; use XML or YAML when you need to preserve the data's actual shape.

Does the output strictly conform to RFC 4180?

Mostly. Quoting follows RFC 4180 exactly: any field containing the delimiter, a double quote, or a newline gets wrapped in double quotes, with internal double quotes doubled (" becomes ""), which is the escaping rule the RFC defines. Where this tool diverges is line endings. RFC 4180 specifies CRLF (\r\n) between records, but this converter joins rows with a plain \n (LF) instead, and that's what nearly every modern consumer, Excel, Google Sheets, Numbers, and pretty much every CSV-parsing library, accepts without issue despite the stricter spec. If you're feeding the output into a legacy system that enforces CRLF specifically, you may need to convert line endings afterward. The delimiter is also configurable beyond RFC 4180's comma default: this tool supports semicolon and tab as alternates, both common in practice (semicolon especially in European locales where comma is the decimal separator), though only true comma-delimited output is technically 'CSV' under the RFC's own definition.

How does a JSON null (or a missing key) show up in the CSV, compared to false or 0?

A null value and a missing key produce the exact same result: an empty cell. There's no way to tell, just from looking at the CSV, whether a blank cell means the source object had "field": null or didn't have that key at all, both collapse to nothing between the delimiters. false and 0 are different. They're real, meaningful values and get written out as the literal text false and 0, not blanked, since only undefined and null are special-cased to an empty string. This matters most for boolean fields, where it's easy to misread a blank cell as 'false' while scanning a spreadsheet when it actually means the field was absent or explicitly null, while an actual false value is spelled out plainly. If the null-versus-missing distinction matters for your data, check the source JSON directly, the CSV output alone can't tell the two apart.

JSON to CSV Converter - Convert JSON Online

Overview

Introduction

Spreadsheets and JSON speak different languages: one's rows and columns, the other's nested key-value structures. This converter bridges the two, turning an array of JSON objects into a proper CSV file you can open straight in Excel, Google Sheets, or Numbers.

That translation isn't always mechanical. JSON objects can nest arbitrarily deep, and different objects in the same array can carry different keys, neither has a direct CSV equivalent. This tool makes the same structural calls a developer would make by hand: flattening nesting into dot-notation columns, merging inconsistent keys into one header row, so you're not reshaping the data yourself before it's usable in a spreadsheet.

What Is JSON to CSV Converter?

A JSON-to-CSV converter maps each object in a JSON array to one CSV row, using the union of every object's keys as column headers, and quotes values correctly when they contain commas, quotes, or line breaks.

It also handles a single JSON object (a one-row CSV) or a flat array of primitives (wrapped into a single 'value' column). The output is a standards-compliant CSV file, not just comma-joined text, so it opens cleanly in spreadsheet software with no manual fixing needed.

Conversion runs entirely client-side. Both the CSV text and the downloadable file get produced locally in the browser, and nothing about the data you convert is sent anywhere. The output follows RFC 4180's quoting rules precisely, though it joins rows with a plain newline instead of the RFC's specified CRLF, a difference every mainstream spreadsheet application tolerates without issue.

How JSON to CSV Converter Works

The tool parses the JSON, flattens nested objects into dot-notation column names (e.g. address.city), collects every distinct key across all rows to build a stable header row, and serializes nested arrays as JSON strings inside a single cell. Values get quoted per RFC 4180 whenever they contain the delimiter, a quote character, or a newline.

Column order follows first-seen order across the array, not alphabetical sorting. If the first object has keys id, name, email, those become the first three columns even if a later object introduces something new like role. That keeps the layout predictable and close to your source JSON's shape instead of shuffling columns based on a sort nobody asked for.

A few input shapes get special treatment. An empty array produces an empty output string rather than a header-only CSV. A bare object (not wrapped in an array) produces a single data row. And an array of arrays has no keys to use as column names, so each inner array gets serialized whole into one 'value' column instead of being expanded positionally.

When To Use JSON to CSV Converter

Use it when you've got API output, a database export, or a log file in JSON form and need to hand it to someone who lives in spreadsheets, or when you need to import the data into a tool that only takes CSV.

It also comes up mid-pipeline, turning a JSON fixture into CSV to feed a data-import step, or converting a JSON log export so it can be filtered and pivoted in a spreadsheet instead of grepped by hand.

Often used alongside JSON to XML Converter, JSON to YAML Converter and JSON Formatter & Beautifier.

Features

Advantages

Automatically detects and merges columns across objects with inconsistent keys.
Flattens nested objects into readable dot-notation columns instead of dropping the data.
Produces RFC 4180-compliant quoting, so values with commas or quotes don't break the file.
Works entirely offline, which matters when the data contains sensitive records.

Limitations

Deeply nested arrays get serialized as JSON strings rather than expanded into further rows or columns.
Very wide objects (hundreds of distinct keys) can produce unwieldy CSVs; spreadsheets just aren't built for deep hierarchies.
CSV has no native types, so numbers, booleans, and strings all become plain text in the output.

CSV vs. JSON: When to Use Each

CSV vs. JSON: When to Use Each
	CSV	JSON
Natural fit for	Flat, tabular data (rows and columns)	Nested, hierarchical data
Opens directly in	Excel, Google Sheets, Numbers	Code editors, API tools
Preserves data types	No, everything is text	Yes, strings, numbers, booleans, null
Best for	Sharing data with non-technical teammates	APIs, configs, and structured data

Examples

Array of user objects

Input

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

Output

id,name
1,Ada
2,Grace

Each object becomes a row, and the union of keys across both objects becomes the header row.

Flattening a nested object into dot-notation columns

Input

[{"id":1,"user":{"name":"Ada","address":{"city":"London"}}}]

Output

id,user.name,user.address.city
1,Ada,London

Nesting collapses fully into the column name no matter how deep it goes, a value two levels down (address.city inside user) becomes a single flat column, user.address.city.

Nested array serialized as a single JSON-string cell

Input

[{"id":1,"tags":["admin","editor"]}]

Output

id,tags
1,"[""admin"",""editor""]"

The tags array gets written as the literal text ["admin","editor"] inside one cell, quoted because that JSON text itself contains commas and double quotes, both of which trigger RFC 4180's quoting rules.

Escaping a value with a comma and embedded quotes

Input

[{"id":1,"note":"Hello, \"world\""}]

Output

id,note
1,"Hello, ""world"""

The note value contains both a comma and double quotes, so the whole cell gets wrapped in quotes and each internal quote is doubled, exactly as RFC 4180 specifies, and the file still parses correctly.

Merging objects with inconsistent keys

Input

[{"id":1,"name":"Ada"},{"id":2,"role":"editor"}]

Output

id,name,role
1,Ada,
2,,editor

The header row is the union of every key seen across the array, in first-seen order. The first row has no role, the second has no name, so each just gets a blank cell instead of the row being dropped or misaligned.

An array of arrays collapses to a single column

Input

[[1,2],[3,4]]

Output

value
"[1,2]"
"[3,4]"

This isn't a flat array of objects, so there are no keys to use as column names. Each inner array gets treated as a single value and serialized whole into one 'value' column instead of being expanded into separate columns per position. Want one column per position instead? Convert each inner array to an object with named keys, like {"x":1,"y":2}, before converting.

Best Practices & Notes

Best Practices

Flatten deeply nested structures in your source data before converting if you need one meaningful column per field.
Double-check columns holding arrays, they show up as raw JSON text and often need manual splitting downstream.
Use a consistent object shape across your array for the cleanest CSV output.
Got an array of arrays instead of an array of objects? Convert it to named-key objects first, or every row collapses into a single opaque 'value' column instead of one column per position.
Don't read a blank cell as false or zero. Only null and a missing key produce an empty cell, real false and 0 values get written out as text, so treat blanks as 'absent or null,' not as a falsy value.
If the destination system insists on strict RFC 4180 line endings (CRLF), post-process the downloaded file. This converter joins rows with a plain newline, which nearly all modern tools accept even though the RFC technically specifies CRLF.

Developer Notes

Column order follows first-seen order across the array, not alphabetical order, so the CSV layout stays predictable and close to your source JSON's key order. The first object encountered establishes the initial columns, and later objects only ever append new columns at the end, they never reorder existing ones. Flattening recurses through nested objects to any depth using dot-notation keys, but treats arrays as opaque leaves, JSON.stringify()'d into a single cell rather than recursed into, since there's no natural column mapping for a variable-length list. Quoting follows RFC 4180 (double-quote wrapping with doubled internal quotes) whenever a cell contains the active delimiter, a double quote, or a newline. Line endings between rows are a plain \n rather than the RFC's specified \r\n though, a deliberate simplification since virtually every real-world CSV consumer accepts bare LF just fine.

JSON to CSV Converter Use Cases

Exporting API results for a non-technical teammate to open in Excel
Preparing JSON log data for spreadsheet-based analysis
Converting a JSON fixture into CSV for a data import tool
Sharing a quick tabular view of structured JSON data
Producing a spreadsheet-ready export from a JSON API response for a stakeholder who doesn't want to touch raw JSON
Feeding flattened JSON records into a tool or import wizard that only accepts delimited text, like a CRM or a legacy database loader

Common Mistakes

Pasting a single deeply nested object and expecting multiple rows, only array elements become rows.
Expecting nested arrays to expand into columns instead of landing in a single JSON string cell.
Forgetting that CSV column order can shift if object key order varies between array items.
Passing an array of arrays instead of an array of objects and expecting one column per position. Without object keys to name the columns, each inner array collapses into a single JSON-string cell instead.
Reading a blank cell as false or 0. A blank cell actually means the key was missing or explicitly null, real false and 0 values always show up as visible text.
Assuming the output uses CRLF line endings because RFC 4180 specifies them. This converter uses a plain LF, which is fine for virtually every modern CSV consumer but can matter for strict legacy parsers.

Tips

If your data has inconsistent keys, review the header row carefully, missing values just show up as blank cells.
For deeply nested data, consider flattening manually before converting so the columns match your reporting needs.
Switch the delimiter to semicolon before sharing a CSV with a European-locale spreadsheet, where comma is often the decimal separator and Excel expects semicolon-delimited files by default.
Scan the header row for one-off column names after converting a large array. A single object with an unusual extra key adds a column that's blank for every other row, which is often a sign of a malformed or outlier record worth investigating.

JSON to CSV Converter

Overview

Introduction

What Is JSON to CSV Converter?

How JSON to CSV Converter Works

When To Use JSON to CSV Converter

Features

Advantages

Limitations

CSV vs. JSON: When to Use Each

Examples

Array of user objects

Flattening a nested object into dot-notation columns

Nested array serialized as a single JSON-string cell

Escaping a value with a comma and embedded quotes

Merging objects with inconsistent keys

An array of arrays collapses to a single column

Best Practices & Notes

Best Practices

Developer Notes

JSON to CSV Converter Use Cases

Common Mistakes

Tips

References

Frequently Asked Questions