JSON Flatten

Related

Use Cases

• MongoDB queries and aggregations: convert nested JSON into dot-notation flat structures and use the keys directly in find queries, update statements, and aggregation pipelines—without hand-writing paths
• CSV/Excel export: flatten multi-level nested objects and use the dot-notation keys as column headers when importing into a Pandas DataFrame or Excel, with one record per row
• Elasticsearch indexing: flat documents are easier for search engines to store and query—expand nested array fields into single-level key-value pairs
• API debugging: compare the nested structures of requests and responses side by side; flattened field names are more intuitive and make it easier to spot missing or mis-typed fields
• Config preprocessing: turn nested configuration files like package.json or settings.json into flat environment-variable form for Docker containers or CI pipelines
• Logs and monitoring: flatten complex nested log events before writing them into a data warehouse so they can be aggregated and visualized by field

How to Use

1. Paste the JSON you need to process into the left input box, or click the upload button to pick a local .json file. You can also click the Sample button to load a pre-built nested example
2. Switch between Flatten and Unflatten mode in the toolbar, then set the separator, array-handling option, and max expansion depth in the options panel below
3. The tool processes automatically in real time. The right panel instantly shows the result together with key-count and max-depth statistics
4. Click Copy to put the result on your clipboard, or click Download to save it as a .json file on your device

Features

• Bidirectional conversion: supports both JSON flatten and unflatten, so you can switch between nested and flat structures losslessly at any time
• Custom separators: defaults to a dot, but you can switch to underscore, slash, double underscore, or any character to fit different downstream systems
• Configurable array handling: expand arrays into indexed keys (e.g. items.0, items.1) or keep them as single values to cover both tabular and config-style workflows
• Max-depth limit: cap the expansion depth to avoid extremely long keys caused by deeply nested structures
• Real-time statistics: after processing, instantly see the total number of keys and the maximum depth to evaluate output size
• Local privacy processing: all parsing and conversion happens in the browser, no JSON data is uploaded—ideal for sensitive APIs and production configuration
• File upload and sample data: upload a .json file or load the built-in sample with one click to quickly verify the conversion
• Copy and download: copy the result to your clipboard or download it as a standard .json file with a single click for downstream processing

Code Examples

function flatten(obj, prefix = '', sep = '.') {
  return Object.entries(obj).reduce((acc, [key, value]) => {
    const newKey = prefix ? `${prefix}${sep}${key}` : key;
    if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
      Object.assign(acc, flatten(value, newKey, sep));
    } else {
      acc[newKey] = value;
    }
    return acc;
  }, {});
}

flatten({ user: { name: 'Alice', contact: { email: 'a@x.com' } } });
// => { 'user.name': 'Alice', 'user.contact.email': 'a@x.com' }

def flatten(obj, parent_key='', sep='.'):
    items = {}
    for key, value in obj.items():
        new_key = f"{parent_key}{sep}{key}" if parent_key else key
        if isinstance(value, dict):
            items.update(flatten(value, new_key, sep))
        else:
            items[new_key] = value
    return items

import json
print(json.dumps(flatten({'user': {'name': 'Alice'}}), indent=2))
# => {"user.name": "Alice"}

# Convert nested JSON to dot-notation flat structure
jq '[paths(scalars) as $p | {"key": $p | join("."), "value": getpath($p)}] | from_entries' data.json

# Reverse a flat JSON back to nested
# Use a third-party filter with jq 1.7+, or simply use the Unflatten mode in this tool.

FAQ

Troubleshooting