Flatten JSON Online — Free Tool for Nested JSON to Dot-Notation Keys

The fastest way to flatten nested JSON is to paste it into our JSON Flattener, click Flatten, and copy the result. You get a single-level object where every key is a dot-notation path from the root — {"user":{"name":"Alice"}} becomes {"user.name":"Alice"}. No signup, no upload, and nothing leaves your browser.

Flattening is useful when you are exporting data to a format that does not support nesting (CSV, flat form fields, simple key-value stores), normalizing payloads before comparing two API responses, or debugging a deeply nested response where the path to a value is hard to read. This guide walks through exactly how the tool works and the edge cases worth knowing before you hit Flatten.

What "Flatten JSON" Means in This Tool

Flattening collapses a nested object into a single level. Each original path becomes a single key separated by a delimiter. The default delimiter is a period, but you can change it to an underscore, slash, or any character.

Before:

{
  "user": {
    "name": "Alice",
    "address": { "city": "NY", "zip": "10001" }
  },
  "active": true
}

After Flatten:

{
  "user.name": "Alice",
  "user.address.city": "NY",
  "user.address.zip": "10001",
  "active": true
}

The leaf values — strings, numbers, booleans, null, and arrays — are preserved exactly. Only the object nesting is collapsed. An array is treated as a single leaf value; the tool does not turn array indexes into numeric path segments.

How to Flatten Your JSON in Five Steps

Step 1. Open the JSON Flattener in any browser.

Step 2. Paste your JSON into the Input panel, or click "Load sample" to see how a typical nested object transforms.

Step 3. Pick a delimiter. Stick with . for most work. Use _ if your downstream system treats dots as object accessors (some databases, some form libraries). Use / if you are building URL-like paths.

Step 4. Click the green Flatten button. The output panel fills instantly — processing happens locally, so even large payloads come back in under a second.

Step 5. Click Copy to put the flattened JSON on your clipboard, or paste it directly into your next tool (spreadsheet, database import, form field mapper).

If you made a mistake or need to reverse the operation, paste the flat object back in and click Unflatten — the original nesting is rebuilt from the delimiter. Full details in our unflatten JSON guide.

Sell Custom Apparel — We Handle Printing & Free Shipping

Three Real Scenarios Where Flattening Saves Time

Scenario 1 — Exporting API data to a CSV. You pulled a JSON response from a REST API. The response has nested address objects and nested customer metadata. Your analyst needs it in Excel. A flat key-value structure converts cleanly to CSV. Flatten first, then run it through our JSON to CSV converter.

Scenario 2 — Comparing two API responses. Your staging API and production API are drifting. You want to diff them. Pretty-printed nested JSON produces noisy diffs because key order can shift between environments. Flatten both payloads, sort the keys with our JSON Key Sorter, and the diff shows only the values that actually differ.

Scenario 3 — Debugging a deeply nested object. A webhook arrives with seven levels of nesting. You need to find every field that mentions "email". Flat dot-notation keys are searchable in one pass — Ctrl+F finds every path at once instead of scrolling a 200-line nested tree.

How the Tool Handles Arrays, Nulls, and Empty Objects

The tool is opinionated about arrays on purpose: they are preserved as leaf values rather than exploded into numeric indexes. An input of {"tags":["a","b","c"]} flattens to {"tags":["a","b","c"]}, not {"tags.0":"a","tags.1":"b","tags.2":"c"}. Most downstream consumers (CSV exporters, spreadsheet importers, form libraries) handle arrays as a single cell with a comma-separated string anyway.

If you specifically need indexed array paths (like items.0.name, items.1.name), you will need a dedicated library like Python's pandas or JavaScript's flat npm package — those use indexed notation by default. For the 95 percent case, leaf-array behavior is what you want.

Nulls are preserved ({"foo":null} stays {"foo":null}). Empty objects ({"foo":{}}) collapse to nothing — the key disappears, because there are no leaves. If you need empty objects preserved, flatten them manually first or use a code-based library.

The input must be a JSON object at the root. If you paste a root-level array, the tool shows an error. Wrap it in an object first: {"data":[...]}.

Why Running Locally Matters for JSON Payloads

Most "online JSON flatteners" upload your payload to a remote server for processing. That is fine for test data, but a problem when the JSON contains API keys, customer emails, Stripe webhook payloads, session tokens, or anything you would not want sitting in a third party's logs.

Our tool does every byte of work in your browser using JavaScript. There is no network call after the page loads. You can disconnect from the internet and the tool still runs. For sanity checks, open Chrome DevTools (F12), switch to the Network tab, paste your JSON, and click Flatten — you will see zero requests fired.

This matters most for developers handling production data. The difference between "free" and "free and private" is the difference between "I can use this at work" and "I have to ask our security team first." For more on the privacy model, see JSON Formatter That Never Uploads Your Data.

Frequently Asked Questions

What delimiter should I use for flattened JSON?

A period (.) is the default and works best for most downstream tools — it is the convention in JSONPath, lodash get/set, and most template languages. Switch to an underscore (_) if your target system treats dots as property accessors and breaks on them. Use a slash (/) if you are building URL-like paths or JSON Pointer-style keys.

Can I flatten a JSON array at the root?

Not directly — the tool requires a root-level object. Wrap your array in a wrapper object first: change [...] to {"data": [...]}. Then flatten. The array will be preserved as a leaf value under the "data" key.

What happens to arrays inside my object?

Arrays are kept as leaf values, not exploded into indexed paths. An object with {"tags":["a","b"]} flattens to {"tags":["a","b"]}, which is usually what spreadsheets and CSV exporters expect. If you need indexed array paths like tags.0, tags.1, use a code library — that convention is less common in flat-file workflows.

Does this work for huge JSON payloads?

Yes, within browser memory limits. Flattening is a single pass over the object tree, so a 10MB payload finishes in well under a second on any modern laptop. The limiting factor is how much JSON you can paste into a browser textarea, which is usually tens of megabytes before things slow down.

Is it the same as minifying JSON?

No. Minifying removes whitespace and newlines while keeping the original nested structure. Flattening restructures the object itself into single-level dot-notation keys. Our JSON Formatter handles minifying; the JSON Flattener handles structural flattening. They solve different problems.