Skip to main content
JSON Processing

JSON Unflattener

JSON Unflattener rebuilds nested objects and arrays from path-like keys and reports invalid input instead of silently guessing at malformed JSON. Useful for reversing flat key-value exports, reconstructing hierarchical data from spreadsheet imports, and restoring structured JSON from dot-notation paths.

JSON shape tools

In brief

JSON Unflattener rebuilds nested objects and arrays from path-like keys and reports invalid input instead of silently guessing at malformed JSON.

Reviewed: 2026-09-18

What this tool supports

  • Reconstructs nested JSON from flat dot notation
  • Supports bracket notation for arrays
  • Correctly recreates array structures
  • Handles mixed objects and arrays
  • Validates flat JSON input format
  • Preserves all data types and values
  • One-click copy to clipboard
  • Download as .json file
  • Produces valid nested JSON specification
  • Works offline after initial load in your browser

How to Use JSON Unflattener

Reconstruct nested JSON structures from flat, dot-notation representations for data restoration and API preparation.

  • Step 1

    Open the JSON Unflattener tool

    Navigate to the JSON Unflattener from the tool registry. The interface presents an input area for your flat JSON data and displays the reconstructed nested output.

  • Step 2

    Paste your flat JSON

    Copy your flat, dot-notation JSON content and paste it into the input area. The tool validates the input format and prepares it for the reconstruction process.

  • Step 3

    Review the input format

    Verify that your flat JSON contains dot-notation keys like "user.name" or bracket notation like "items[0].id". The tool will parse these to rebuild the nested structure.

  • Step 4

    Click Unflatten

    Press the Unflatten button to execute the reconstruction. The tool parses the dot-separated keys, creates parent objects as needed, and builds the full nested hierarchy.

  • Step 5

    Review the nested output

    Examine the reconstructed nested JSON in the output area. Verify that all objects, arrays, and data types are correctly restored and match the intended structure.

  • Step 6

    Copy or download the result

    Use the copy button to place the nested JSON on your clipboard, or click the download button to save the file as a .json document for use in your applications.

Common mistakes

Unflattening dot-notation keys that contain actual dots

Consequence: Keys like 'a.b' are ambiguous — is it one key with a dot or two nested levels?

Fix: Use bracket notation ['a.b'] for keys that literally contain dots to avoid nesting confusion.

Expecting unflattening to restore original array structure

Consequence: Flat representations may lose array index information, making perfect reconstruction impossible.

Fix: Use indexed bracket notation (arr[0].field) when flattening to preserve array positions.

Unflattening already-nested JSON

Consequence: Applying unflatten to nested data produces unexpected double-nesting.

Fix: Verify your input is actually flat before applying unflatten.

Best practices

  • Use the same delimiter that produced the flat document; rebuilding with a different delimiter silently merges or splits keys incorrectly.
  • Verify key names do not contain the delimiter as literal text — such keys produce unintended nesting on rebuild.
  • Check index notation on array keys before rebuilding; mismatched bracket or dot conventions create wrong array positions.
  • Round-trip a sample: flatten the rebuilt document and compare keys with the source to confirm lossless reconstruction.

Connected workflows

Prepare and process

JSON Unflattener

JSON Unflattener rebuilds nested objects and arrays from path-like keys and reports invalid input instead of silently guessing at malformed JSON.

  1. Use supported input
  2. Choose relevant options
  3. Run locally
  4. Review diagnostics

Verify before integration

JSON Unflattener

Compare the rebuilt structure against the original flat keys before persisting the nested object.

  1. Run locally
  2. Verify the result
  3. Copy, download, or continue

Continue through the tool family

JSON Unflattener

Round-trip the rebuilt object through JSON Formatter, or export it with the JSON to CSV converter.

  1. Verify the result
  2. Copy, download, or continue

Browser limitations

  • Rebuilding very deep structures from large flat documents allocates nested copies; extremely deep targets are bounded by available memory.
  • Clipboard access and file downloads require browser permission and may be blocked in private browsing, iframes, or restricted security contexts.
  • Key order in the rebuilt document follows the flat input order; the rebuild does not infer an original authoring order.

Authoritative resources

JSON.orgPublisher: json.org · Reviewed: 2026-09-18JSONPathPublisher: goessner.net · Reviewed: 2026-09-18Underscore.jsPublisher: underscorejs.org · Reviewed: 2026-09-18RFC 8259: JSONPublisher: rfc-editor.org · Reviewed: 2026-09-18

Concrete examples

Input
valid input
Result
reviewed local output

This example verifies JSON Unflattener's primary behavior without uploading data.

Frequently asked questions

What is JSON Unflattener?

JSON Unflattener reverses the flattening process by taking a flat, dot-notation JSON object and reconstructing the original nested structure. It parses dot-separated keys like "user.address.city" and rebuilds the hierarchy into proper nested objects and arrays.

Does JSON Unflattener upload my data?

No. All reconstruction processing happens locally within your browser sandbox. Your JSON data never leaves your device, ensuring complete privacy and confidentiality of your information during the entire unflattening process.

How do I unflatten JSON?

Paste your flat, dot-notation JSON into the input area and click Unflatten. The tool parses the dot-separated keys, creates the appropriate parent objects, and reconstructs the full nested hierarchy as output.

What dot notation does it support?

The tool supports standard dot notation with periods as separators, as well as bracket notation for array indices such as "items[0].name". It correctly parses both formats and reconstructs the appropriate data structures.

Does it recreate arrays?

Yes. When the unflattener encounters bracket notation like "items[0]" or sequential numeric keys, it correctly reconstructs them as proper JSON arrays with elements in the correct order and indices.

Can I handle mixed structures?

Yes. The tool handles mixed structures containing both objects and arrays at different levels, correctly reconstructing the complex hierarchy. It preserves the original data types and relationships between all elements.

Can I copy the unflattened output?

Yes. After reconstruction, you can copy the nested JSON to your clipboard using the copy button. You can also download the result as a .json file for use in APIs, configuration files, or data processing.

Does it validate the input?

Yes. The tool validates the flat JSON input to ensure it contains properly formatted dot-notation keys and valid values. Any formatting issues are reported with clear error messages for easy correction.

Is the output valid nested JSON?

Yes. The unflattener produces valid, properly nested JSON that follows the JSON specification. The output can be used directly in any JSON parser, API, or configuration system without further modification.

How does the tool handle ambiguous dot-notation keys?

Keys containing literal dots are ambiguous. Use bracket notation (parent["a.b"]) for keys with dots, or the tool assumes dots represent nesting levels.

Privacy and offline behavior

JSON Unflattener processes input and produces output inside this browser. The tool does not upload tool data. Browser capabilities such as files, clipboard, camera, Canvas, Web Crypto, workers, or downloads are used only after the workflow or an explicit user action requires them.