Convert Excel to JSON

1. 1

   Drop the spreadsheet

   Drag in an XLSX, XLSM, XLSB, XLS or ODS file. It is read on your device and the JSON appears straight away.

2. 2

   Pick the sheet and the header row

   Choose which sheet to convert, or combine every sheet into one object. If the file has a title line above its column names, set the header row to the row the names are actually on.

3. 3

   Choose the shape and the value rules

   Array of objects, 2D array, column arrays or an object keyed by the first column. Then decide how dates are written, what an empty cell becomes, and whether numbers stay numbers.

4. 4

   Copy or download

   Copy the JSON to your clipboard or download the file. Convert several workbooks and take the whole batch as one ZIP.

Convert Excel spreadsheets to structured JSON. Export XLSX, XLSM, XLSB, XLS and ODS to JSON with control over the header row, the output shape, the keys and the way values are written — built for API payloads, ETL jobs, seed data and app imports.

• Real dates. A date cell becomes 2024-05-17, not 45429. The workbook's own epoch is honoured, and no timezone is applied on the way.
• Four output shapes. An array of objects, a 2D array, column arrays, or an object keyed by a column you choose.
• Nested keys. Headers like "user.name" and "tags[0]" build real nested objects and arrays.
• A header row that is not row 1. Skip the title lines that real exports carry above their column names.
• Nothing lost quietly. Renamed keys, blank headers, path clashes and skipped rows are all listed beside the output.
• Every sheet, or one. Convert a single sheet, or produce one object keyed by sheet name.
• Batch as one file. Convert many workbooks and download the whole set as a single ZIP.

What free covers

• Correct output. Real dates, the header row, sheet selection and pretty-printed JSON are free — a correct conversion is not a premium feature.
• Files up to 15 MB. One workbook at a time, up to 50,000 rows per sheet, with the row count shown so you always know what you got.
• Every input format. XLSX, XLSM, XLSB, XLS and ODS all read on the free tier.

The same rows can be arranged four ways, and the right one depends entirely on what is going to read the JSON. Picking the shape at conversion time saves a transformation step at the other end.

Which shape do you need?

• Array of objects. The default, and what almost every REST API and JavaScript app expects. One object per row, keyed by the column headers.
• 2D array. The grid as it stands, with the header as the first row. Compact, order-preserving, and the right input for charting and table libraries.
• Column arrays. One key per column holding every value in it. This is the shape data-frame and plotting libraries load fastest.
• Keyed object. An object keyed by the first column — a lookup table. Ideal when each row has an id and you want to reach a record without scanning.

Wrapping the result

Any shape can be wrapped in a named root object, so the output arrives as { "data": [ … ] } rather than a bare array. Many APIs require the envelope, and adding it here avoids editing the file afterwards.

The header row decides the keys, and real spreadsheets make that harder than it sounds. Two columns can share a name, a header can be blank, and a header can be a phrase with spaces and punctuation that is awkward to use as a property name in code.

When two headers want the same key

• Nothing is overwritten. A second column called "Qty" becomes "qty_2" rather than replacing the first. A JSON object cannot hold the same key twice, so the alternative is losing a column.
• The rename is shown. Every renamed key is listed beside the output, so a change to your data is something you were told about rather than something you discover later.
• Sanitized keys collide more. "Item Name" and "item-name" both reduce to "item_name" once keys are made API-friendly, which is exactly when the reporting matters most.

Blank and non-Latin headers

• A blank header takes its column letter. Column D with no name becomes "D" — a key you can find in the sheet, rather than an empty string.
• Accents survive. Sanitizing "Größe" gives "groesse", not "gre". Letters outside plain ASCII are transliterated rather than deleted.
• Non-Latin headers get a position. A header with no ASCII equivalent at all becomes column_1, column_2 and so on, which is unambiguous rather than blank.

A spreadsheet cell and a JSON value are not the same kind of thing, and every converter has to decide how one becomes the other. Those decisions are settings here rather than assumptions.

How dates are written

• ISO 8601 (default). 2024-05-17, or the full stamp when the cell carries a time. Sortable, unambiguous, and what most systems accept.
• As displayed. Exactly the text the cell shows, honouring the number format the spreadsheet author chose.
• Unix timestamp. Milliseconds since 1970, for code that works in epoch time.
• Raw serial. The underlying number, for when you are round-tripping back into a spreadsheet.

Empty cells and value types

• Empty cells, your choice. An empty string, a JSON null, or the key left out of the object entirely — which produces the smallest files on sparse sheets.
• Types kept or flattened. Numbers and booleans stay native by default; switch to all-as-strings when the destination is strict about types.
• Booleans in three flavours. true and false, the strings "true" and "false", or 1 and 0.
• Error cells stay readable. #REF! and #DIV/0! are written as text, because an error is not a number and pretending otherwise hides a broken formula.

A spreadsheet is flat and JSON is not, which is usually where a conversion stops being useful. Naming a column with a path closes the gap: the header describes where the value belongs in the document, and the structure is built as the rows are read.

Paths, objects and array indexes

• Dots make objects. "address.city" and "address.country" produce one address object with two properties.
• Brackets make arrays. "tags[0]" and "tags[1]" produce a real array, not an object with the keys "0" and "1".
• Paths nest as deep as you like. "user.address.geo.lat" builds all four levels.
• Clashes are reported. If one column writes a value at "a" and another wants "a.b", the second cannot be placed — and you are told which one, rather than one of them vanishing.

Most real workbooks are not one tidy table. They have several sheets, a report title above the data, and blocks of notes off to one side.

Reading part of a sheet

• Set the header row. Point the tool at the row your column names are on and everything above it is skipped.
• Give a cell range. B3:H500 converts that block and nothing else, which is how you get clean JSON out of a sheet with notes beside the data.
• Skip blank rows. Gaps used as visual separators do not become empty records.
• Trim whitespace. Values padded for alignment in the spreadsheet come out clean.

Several sheets and big files

• One sheet at a time. Pick the sheet from the list; the preview follows your choice.
• Or all of them at once. Every sheet in one object keyed by sheet name: { "Q1": [ … ], "Q2": [ … ] }. Sheet names are kept exactly as they are.
• Row counts are shown. The number of rows converted is displayed next to the output, and if a sheet was cut off at the free row limit the tool says so rather than handing you a short file quietly.
• Large files stay responsive. The workbook is read once, off the main thread, so the page keeps responding while a 50,000-row file is parsed.

Five containers are supported, and each of them is proven by the test suite rather than merely claimed. What matters is not only the extension but whether the values, the dates and the sheet names survive intact — all five are checked on the same content.

Supported inputs

• XLSX. The Excel 2007+ default, and the format most exports and downloads use.
• XLSM. A macro-enabled workbook. The macros are ignored; the data converts identically.
• XLSB. Excel's binary format, common for very large workbooks because it opens faster.
• XLS. The legacy Excel 97–2003 format, still produced by older accounting and lab software.
• ODS. OpenDocument, from LibreOffice, OpenOffice and Google Sheets exports.

What is refused, and where to go instead

• CSV and TSV. Refused here with a link to the CSV to JSON converter, which is built for delimited text.
• Anything that is not a workbook. A file with a spreadsheet extension over other content is refused before it is read, rather than half-parsed into a grid of fragments that looks like data and is not.
• Empty files. A zero-byte file gets a message, never a spinner that never finishes.

JSON is the format APIs, web applications and data pipelines speak. A spreadsheet is where the data is written and maintained by people. Converting between them is the join between how data is produced and how it is consumed.

Where the output goes

• API payloads and fixtures. Post the array straight to an endpoint, or commit it as seed data for a test suite.
• Front-end data. Import the file directly into an app for a price list, a lookup table or a set of translations.
• Databases and ETL. Most loaders and document stores accept JSON natively; a keyed object drops into a key-value store as it stands.
• Configuration maintained by non-developers. The people who own the content keep working in a spreadsheet, and the build reads JSON.
• Migrations. A one-off export becomes a structured file you can inspect, diff and re-run.

The whole conversion happens on your device. The workbook is opened in the page, the JSON is produced there, and neither the file nor the result is sent anywhere — which is the reason it is fast as well as the reason it is private.

Measured on a 50,000-row workbook

• Read once: about 0.6 seconds. The 12 MB file is opened a single time and held as data, off the main thread.
• Re-shape: 15 to 45 milliseconds. Changing any setting rebuilds the JSON from that data — the file is never re-read.
• Nothing uploaded. No file data crosses the network at any point, so there is nothing to delete afterwards and nothing to trust us about.
• Works offline. Once the page has loaded, conversions keep working with no connection at all.

A 50,000-row workbook is read in about 0.6 seconds on your device, and every setting you change after that re-shapes the JSON in 15 to 45 milliseconds — the file is read once, never again.

• Excel to CSV
• CSV to Excel
• Excel Viewer
• Excel tools
• Turn the JSON back into a table

  Take an API response into a spreadsheet the same way you took one out

• Start from a CSV instead

  Delimited text rather than a workbook, with the same key and type controls