JSON to Excel Converter

Why JSON-to-Excel conversion is not straightforward

A JSON file is a tree of typed values: objects with named keys, arrays with ordered elements, and leaves that can be strings, numbers, booleans, or null. An Excel spreadsheet is a flat grid of rows and columns, where each cell holds a single value and the structure is implicit in the row–column position. Converting one to the other means deciding how to map the hierarchy.

The tool on this page applies a single flattening rule: every leaf value in the JSON tree becomes a cell, and its column header is constructed by concatenating the keys that lead to it, separated by dots. For example, an object {"address": {"city": "Paris", "zip": 75001}} yields two columns: address.city and address.zip. This dot‑path notation is not needed when converting from CSV or Excel, which are already flat — it is the key difference that justifies a dedicated conversion page.

How the flattening algorithm works

The tool expects a “table‑shaped” JSON input. In practice that means the top‑level value should be an array of objects or an array of arrays. A single object is accepted too – it converts to a one‑row table. What fails is a file that is not valid JSON at all – a trailing comma, single‑quoted strings, an unclosed bracket – which produces the message “This JSON is invalid or not table‑shaped.”

Array of objects

When the JSON is an array of objects, each object becomes one row. The set of all keys across all objects — including nested keys — defines the column headers. The algorithm walks every object recursively:

• For each key–value pair, if the value is a primitive (string, number, boolean, null), it writes that value into the cell belonging to that key’s dot‑path.
• If the value is another object, the algorithm recurses, extending the dot‑path with each subkey.
• If the value is an array of primitives, it becomes a single cell containing the JSON representation of that array — e.g., [1,2,3] as a string. Recursive flattening of arrays of objects inside objects is not supported for columns; instead the nested array is treated as a scalar value. The exception is when the top level is an array of arrays, described below.
• If an object is missing a key that appears in other objects, the missing cell is left empty. Null values become empty cells as well.

Consider this JSON:

[
  {"name": "Alice", "stats": {"age": 30, "active": true}},
  {"name": "Bob", "stats": {"age": 25, "active": false}, "nickname": null}
]

The tool produces columns: name, stats.age, stats.active, nickname. Row 1 has "Alice", 30, true, empty. Row 2 has "Bob", 25, false, empty.

Array of arrays

If the top‑level JSON is an array of arrays (e.g., [ [1, "x"], [2, "y"] ]), each inner array becomes a row, and no header row is generated — the first inner array is simply the first row of the sheet. No flattening of nested arrays occurs because there are no keys to concatenate. A top‑level array can even mix objects with other values: any element that is not an object is placed in a column named value (arrays land there as their JSON text).

What happens with nested arrays of objects

The flattening rule has a limitation: if an object contains an array of objects, that array is not expanded into separate rows. Instead the entire array is stringified as JSON and placed in a single cell. For example:

[
  {"id": 1, "items": [{"sku": "A"}, {"sku": "B"}]}
]

produces a single row with columns id and items. The items cell contains [{"sku":"A"},{"sku":"B"}] as a string. If you need each item on its own row, you must pre‑flatten the data before uploading.

Data types in the output: preserving numbers and booleans

CSV conversion loses type information: every value becomes a text string. The XLSX format, by contrast, stores native cell types: number (IEEE 754 double), boolean, string, date, and error. When the tool converts JSON to XLSX, it maps JSON primitives to the corresponding Excel cell types:

This means a column of numbers stays numeric in Excel. You can sum it, format it, or use it in formulas without needing to convert strings. A column of booleans appears as TRUE/FALSE, which Excel can use in logical functions. This is a practical advantage over JSON‑to‑CSV workflows where booleans become the strings "true" or "false".

There is a catch: if a field contains mixed types across rows (e.g., a number in one row and a string in another), the tool writes each cell with its own type. Excel will then store a mix of numeric and text cells in the same column. Most spreadsheet applications handle this gracefully, but pivot tables and certain formulas may behave unexpectedly.

The XLSX file format and what the tool produces

XLSX is a zipped XML package (Office Open XML). It can contain multiple worksheets, named ranges, formulas, cell styles, conditional formatting, charts, and more. This tool writes only the bare minimum: a single worksheet with the data from the JSON.

• No formulas are calculated. Even if the JSON contained expressions (unlikely), they are treated as literal strings.
• No cell styling. No bold headers, no column widths, no font choices. The first row becomes the header row (containing the dot‑path keys), but it is not visually distinguished.
• A single worksheet is produced, named Sheet1. There is no option to split the JSON into multiple sheets or to add metadata.
• The output file is the direct result of the in‑browser conversion. Its size depends on the amount of flattened data.

The tool displays a preview of the converted table (first 8 rows and 8 columns), the number of rows and columns, and the output file size before download.

Client-side processing and file size limits

The entire conversion runs in the browser. No file is uploaded to a server. This matters for data privacy: if the JSON contains sensitive information, it never leaves the user’s machine. The page also imposes practical limits to prevent browser crashes:

• File size limit: 8 MB. Larger files are rejected with: “This file is too large. Use a file under {max}.”
• Row limit: 10,000 rows — “This table has more than {max} rows.”
• Column limit: 200 columns — “This table has more than {max} columns.”
• Timing out: a conversion that runs past about 12 seconds is stopped — “This conversion is taking too long. Try a smaller file.”
• Cancellation: The user can cancel the conversion, which triggers “Conversion cancelled.”

These limits exist because flattening a deeply nested JSON with thousands of objects can generate many columns and rows, consuming memory. The tool enforces them to keep the page responsive.

Common mistakes and how to avoid them

1. Uploading an object instead of an array

The most frequent mistake is sending a file that is not valid JSON — for example with a trailing comma or single‑quoted strings. The tool then returns “This JSON is invalid or not table‑shaped.” Fix: run the file through a JSON validator and correct the syntax. Note that a single object like {"users": [... ]} is valid input, but it converts to a one‑row table with the whole array stringified into one cell — if you want one row per user, pass the inner array instead.

2. Deeply nested objects with many unique keys

If your JSON has objects with widely varying keys (e.g., one object has 50 keys, another has 100 unrelated keys), the flattening algorithm produces a column for every unique key path. This can quickly exceed the column limit. Solution: normalise the structure or pre‑flatten in code.

3. Arrays of objects inside objects

As noted, these are not expanded into rows. The cell becomes a JSON string. If you need them as separate rows, unnest the array in your source JSON, duplicating parent fields as necessary.

4. Empty arrays

An empty array [] at the top level produces “This file has no table rows.” because there are zero objects to convert. An empty array as a value inside an object becomes the string [] in the cell.

5. Mixing array-of-objects with array-of-arrays

Mixing is allowed, but non‑object elements do not get their own columns: the tool collects them under a value column, and an inner array is stored there as its JSON text. If that is not what you want, split such data into two separate conversions.

FAQ

Why does the output use dot‑path column names like address.city?

Because JSON objects can be nested. A flat spreadsheet column needs a single name. The dot path is the standard way to represent hierarchy in a header. The alternative (e.g., “address.city”) is unambiguous and easy to split in Excel if needed.

Can I convert a JSON file that contains a single object?

Yes. A single object converts to a one‑row table: its keys become the columns. Wrapping it in square brackets ([{...}]) gives the same result.

Will Excel formulas from my JSON be preserved?

No. The tool treats all JSON values as data, not as formulas. If you have a string "=SUM(A1:A10)", it will appear in the cell as that literal text, not as a calculated sum.

What happens to null values?

Null values produce empty cells. Excel displays them as blank cells.

Why does the tool say “This table has more than {max} columns”?

The tool caps tables at 200 columns to avoid creating a spreadsheet that would be impractical or crash the browser. If your JSON has many distinct keys (especially nested ones), the flattened header row can exceed this limit. Consider reducing the number of keys or splitting the data.

Is my data safe when using this page?

Yes. The entire conversion occurs client‑side in your browser. No file is uploaded to any server. You can verify this by disconnecting your network after the page loads — the conversion still works.