User Rating 0.0 ★★★★★

Total Usage 0 times

Category Document Converters

Drop your Excel file here or click to browse .xlsx and .xls supported · Max 50 MB · 100% client-side

Is this tool helpful?

Your feedback helps us improve.

★ ★ ★ ★ ★

About

Excel spreadsheets encode data in opaque binary (BIFF8 for .xls) or compressed XML archives (OOXML for .xlsx). Extracting structured data requires decompressing ZIP containers, resolving shared string tables, mapping cell references like A1 to row-column indices, and interpreting number format codes. A manual copy-paste approach corrupts date serials (Excel stores dates as floats offset from 1900-01-01), drops merged cell values, and silently truncates strings exceeding clipboard limits. This converter parses the full workbook structure client-side. No file leaves your machine. No server processes your data.

The tool handles multi-sheet workbooks, preserving sheet names as JSON keys. It resolves shared string indices, converts Excel date serial numbers to ISO 8601 strings, and correctly interprets boolean and error cells. Output modes include array-of-objects (first row as keys) and array-of-arrays (raw grid). Note: this tool approximates formatting-dependent values. Cells using conditional formatting or formula-driven display may differ from visual appearance. Files with VBA macros are parsed for data only. Macro code is discarded.

Formulas

Excel stores dates as floating-point serial numbers. Converting serial s to a calendar date requires correcting for the Lotus 1-2-3 leap year bug (serial 60 maps to the nonexistent date 1900-02-29):

date = Date(1899, 11, 30) + s × 86400000 ms

Where s is the Excel serial number. If s > 60, subtract 1 to compensate for the phantom Feb 29, 1900. The multiplier 86400000 converts days to milliseconds (24 × 60 × 60 × 1000).

Cell reference decoding converts column letters to zero-based indices:

col = n∑i=0 (charCode(letter_i) − 64) × 26^{(n − i)} − 1

Where n is the number of letters minus 1. Column A = 0, Z = 25, AA = 26, XFD = 16383.

JSON output in "Objects" mode maps header cells to keys. For row r and column c:

output[r − 1][headers[c]] = cell(r, c).value

Where headers is the array of first-row values, and row indexing starts from the second data row.

Reference Data

Feature	.xlsx (OOXML)	.xls (BIFF8)
Format Type	ZIP + XML archive	Binary compound file
Max Rows	1,048,576	65,536
Max Columns	16,384 (XFD)	256 (IV)
Max File Size (practical)	~50 MB	~20 MB
String Storage	Shared Strings Table (XML)	SST Record (binary)
Date Encoding	Serial number (float)	Serial number (float)
Date Epoch	1900-01-00 (with Lotus bug)	1900-01-00 (with Lotus bug)
Number Precision	IEEE 754 double (64-bit)	IEEE 754 double (64-bit)
Boolean Cell Value	TRUE → 1, FALSE → 0	Same
Error Cell Values	#DIV/0!, #N/A, #VALUE!	Same
Compression	DEFLATE (ZIP)	None (raw binary)
Multi-Sheet	Yes (separate XML per sheet)	Yes (BOUNDSHEET records)
Formula Cells	Cached result extracted	Cached result extracted
Merged Cells	Top-left cell value preserved	Top-left cell value preserved
Unicode Support	Full UTF-8	UTF-16LE
Introduced	Office 2007	Excel 97
MIME Type	application/vnd.openxmlformats-officedocument.spreadsheetml.sheet	application/vnd.ms-excel
Magic Bytes	50 4B 03 04 (PK ZIP)	D0 CF 11 E0 (OLE2)
JSON Key Mapping	Header row cell values → object keys	Same
Empty Cell Handling	Omitted from sparse arrays	Omitted from sparse arrays
Max Sheet Name Length	31 characters	31 characters

Frequently Asked Questions

Excel encodes dates as floating-point numbers counting days since January 0, 1900 (a non-existent date inherited from Lotus 1-2-3). Serial 1 = January 1, 1900. Serial 44927 = January 1, 2023. The converter detects cells with date number formats and outputs ISO 8601 strings (e.g., "2023-01-01"). If the "Raw Values" option is selected, the original serial number is preserved. Note: serials 1-60 include the Lotus leap year bug where February 29, 1900 (serial 60) is treated as valid despite 1900 not being a leap year.

The converter extracts cached results, not formulas. When a cell contains =SUM(A1:A10), the output is the last-computed numeric value stored in the file. External references (e.g., =[Budget.xlsx]Sheet1!A1) also use cached values. However, if the file was saved without recalculating (common in large workbooks with manual calculation mode), cached values may be stale. Volatile functions like NOW() or RAND() reflect the value at last save, not the current time.

In Excel's internal structure, a merged region like A1:C3 stores data only in the top-left cell (A1). The remaining 8 cells are empty placeholders. The converter outputs the value at the top-left position. In "Array of Arrays" mode, the other cells appear as null. In "Array of Objects" mode, only the top-left column key receives the value. If you need the merged value replicated across all cells in the region, post-process the JSON by forward-filling nulls.

The practical limit depends on available browser memory. A typical 10,000-row, 20-column spreadsheet (≈2 MB XLSX) converts in under 1 second. Files up to 50 MB are accepted. Beyond approximately 200,000 rows, memory consumption may exceed 500 MB due to JSON string construction. Chrome's V8 engine handles this better than Safari's JavaScriptCore. For very large files, the converter uses a Web Worker to avoid freezing the UI and reports progress incrementally.

No. The entire conversion runs client-side in your browser using the FileReader API. No network requests are made. No data is uploaded to any server. You can verify this by disconnecting from the internet before converting - the tool works fully offline. The source file bytes never leave the JavaScript execution context of your browser tab.

Boolean cells output true or false (JSON boolean type, not strings). Error cells (#DIV/0!, #N/A, #VALUE!, #REF!, #NAME?, #NUM!, #NULL!) output the error string. Rich text cells (containing mixed formatting like bold + italic within one cell) are flattened to plain text - all formatting is stripped, only the concatenated string value is preserved. Hyperlink cells output the display text, not the URL, unless the cell value itself is the URL.

XLSX files use UTF-8 encoding in their XML components, so Chinese, Japanese, Korean, Arabic, and Cyrillic characters convert without issues. Older XLS (BIFF8) files use UTF-16LE for string records, which the parser handles natively. The only edge case is XLS files created by very old applications (pre-Excel 97) that use codepage-specific single-byte encodings. These may produce garbled output for non-ASCII characters. The converter defaults to UTF-8 for JSON output.