Go to Sign up
Note: Your files never leave your device. We don't upload, transfer, or store your data.
|
|
|
|
|---|---|---|
|
|
|
JSON (JavaScript Object Notation) is a lightweight, text-based data interchange format defined by ECMA-404 and described in RFC 8259. It uses human-readable structures — objects (key-value pairs enclosed in curly braces) and arrays (ordered lists enclosed in square brackets) — to represent data. JSON is language-independent and supported by virtually every programming language, making it the de facto standard for APIs, configuration files, and data exchange.
Excel files (.xlsx, .xls) use a proprietary format optimized for spreadsheets. While ideal for human editing, they are poorly suited for programmatic consumption. Converting Excel to JSON transforms tabular data into structured, hierarchical objects that applications can parse directly — without intermediate libraries.
Populating a web application or mobile app with spreadsheet data
Importing data into a NoSQL database (MongoDB, CouchDB, DynamoDB)
Generating seed data for REST APIs or GraphQL resolvers
Preparing configuration files or translation/localization data from spreadsheets
Feeding data to JavaScript frameworks (React, Vue, Angular) or data visualization libraries (D3.js, Chart.js)
Migrating data between systems that only share Excel as a common format
This tool runs entirely in your web browser and parse Excel files locally. Your files are never uploaded to any server. No data is transmitted, logged, or stored. The conversion happens on your device, making it safe for sensitive data including financial records, personally identifiable information (PII), and proprietary datasets.
Beyond basic conversion, the tool provides an interactive table editor for cleaning and transforming data before export, plus four distinct JSON output formats to match different application requirements.
Selecting the right format depends on how your application consumes the data.
Each row becomes a JSON object where the header row values serve as keys. This is the most common format for API responses and application data.
Example input (with headers: Name, Age, City):
[
{ "Name": "Alice", "Age": "30", "City": "New York" },
{ "Name": "Bob", "Age": "25", "City": "London" }
]
Data is represented as a nested array — an array of rows, where each row is an array of cell values. Headers are included as the first row. Useful when you need positional (index-based) access rather than key-based access.
[
["Name", "Age", "City"],
["Alice", "30", "New York"],
["Bob", "25", "London"]
]
Each column becomes a key-value pair where the key is the column header and the value is an array of all values in that column. Useful for statistical analysis or when processing data column-by-column.
{
"Name": ["Alice", "Bob"],
"Age": ["30", "25"],
"City": ["New York", "London"]
}
Rows are grouped into an object keyed by the value of a specified column. Useful for lookup tables where you need O(1) access to a row by its key.
{
"Alice": { "Age": "30", "City": "New York" },
"Bob": { "Age": "25", "City": "London" }
}
Files are parsed using JavaScript directly in the browser. SheetJS handles .xlsx (Office Open XML), .xls (BIFF), and .xlsm (macro-enabled) formats. Multi-sheet workbooks display a sheet selector dropdown. No internet connection is required after the page loads.
After loading a file, you get a fully editable grid where you can:
Edit any cell value inline
Add or delete rows and columns (via toolbar or right-click context menu)
Undo and redo changes
Toggle the first row as a header row
Transpose — Swap rows and columns
Deduplicate — Remove duplicate rows
Delete Empty — Remove rows and columns that contain no data
Case Transformation — Convert text to UPPERCASE, lowercase, or Capitalize Each Word
Find & Replace — Search and replace values with optional regex and case-sensitivity support
Data Format — Array of Objects, 2D Array, Column Array, or Keyed Array
Root Object Name — Wrap the entire output in a named parent object
Indent Size — 2 spaces, 4 spaces, 8 spaces, or tabs
Parse JSON — Detect and parse JSON strings embedded in cells into actual objects
Minify Output — Strip whitespace for compact, single-line JSON
Drag and drop an .xlsx, .xls, or .xlsm file onto the upload area, or click the area to open a file picker. The file is parsed instantly in your browser. If the workbook contains multiple sheets, use the sheet selector dropdown at the top of the editor.
Use the built-in table editor to modify your data. Click any cell to edit its value. Use the toolbar buttons to add/delete rows and columns, transpose the table, remove duplicates, clean empty rows, change text case, or find and replace values. Toggle "First Row as Header" if your first row contains column names (required for Array of Objects and Column Array formats).
In the Properties panel on the right, adjust the following:
Data Format — Select the JSON structure that matches your application's needs (see "JSON Output Formats Explained" above)
Root Object Name — Optionally wrap the output in a named object (e.g., entering "users" produces {"users": [...]})
Indent Size — Choose indentation for readability (2/4/8 spaces or tabs)
Parse JSON — Enable if your cells contain JSON strings that should be parsed into nested objects
Minify Output — Enable for production-ready compact JSON
Click the Convert button. The JSON output appears in the Output Data panel. Click Copy to Clipboard to copy the result, or click Download File (Premium) to save it as a .json file.
Some Excel files contain cells with JSON-formatted strings — for example, a cell might contain {"lat":40.7128,"lng":-74.0060} as text. With Parse JSON enabled, the tool detects these strings and converts them into actual nested JSON objects in the output, rather than leaving them as escaped string values. This is useful when exporting geolocation data, metadata, or any structured content stored as JSON text within spreadsheet cells.
Minified JSON removes all whitespace (spaces, tabs, newlines) to produce the smallest possible file. Use this when:
Sending JSON over a network (reduces payload size)
Embedding JSON in HTML or JavaScript files
Storing JSON in size-constrained environments
For development and debugging, use indented output for readability.
Many APIs and frameworks expect JSON data wrapped in a named root object. For example, a React application might expect {"employees": [...]} rather than a bare array. Entering "employees" as the Root Object Name wraps the output accordingly. Leave this field empty to output the raw array or object without a wrapper.
All processing happens locally in your browser using JavaScript. Your files are never uploaded, transferred, or stored on any server. The tool works the same whether you are online or offline after the page has loaded.
The tool supports .xlsx (Excel 2007+), .xls (Excel 97-2003), and .xlsm (macro-enabled Excel). Multi-sheet workbooks are supported.
Four formats: Array of Objects (default, each row is a JSON object with header keys), 2D Array (positional nested arrays), Column Array (columns as key-value pairs), and Keyed Array (rows indexed by a specified column value).
There is no server-side limit since processing happens in your browser. Practical limits depend on your device's available memory. Files up to 50 MB typically process without issue on modern hardware.
No. Formulas are evaluated by Excel before saving the file. The tool reads the calculated values (not the formula expressions) and exports them as plain values in JSON format.
This tool converts in one direction: Excel to JSON. For the reverse, use a spreadsheet application like Microsoft Excel (via Data > From JSON), Google Sheets (via an add-on), or the JSON To Excel tool if available on A.Tools.
When enabled, the tool scans each cell for valid JSON-formatted strings and parses them into actual JSON objects. For example, a cell containing the text {"key":"value"} becomes a real JSON object in the output instead of a plain string.
Array of Objects uses header names as keys ({"Name":"Alice","Age":"30"}), which is self-describing and robust to column reordering. 2D Array uses positional indexing (["Alice","30"]), which is more compact but requires knowing the column order.