How are arrays flattened?

By default array items use the delimiter and a numeric index (roles.0, roles.1). Enable bracket notation to get roles[0], roles[1] instead, which round-trips cleanly with most unflatten tools.

What happens to empty objects and arrays?

An empty object or empty array is kept as a leaf value at its path rather than being dropped, so the structure can be reconstructed faithfully.

Which delimiter should I use?

A dot is the default and the most common, but you can choose another character if your keys themselves contain dots. Whatever delimiter you pick is the one the matching unflatten tool needs to rebuild the structure.

Can I reverse a flattened object back to nested JSON?

Yes. Use the JSON Unflatten tool with the same delimiter and array style. Bracket array notation round-trips most reliably.

Are primitive values left unchanged?

Yes. Strings, numbers, booleans and null are copied as-is and become leaf values at their path. Only the nesting is collapsed; the values themselves are untouched.

Why would I flatten JSON?

A single-level object is easier to diff in version control, map onto a .env file or environment variables, store in a flat key/value database, or render as a table of path/value pairs.

Is my JSON uploaded anywhere?

No. Flattening runs entirely in your browser as JavaScript. Your JSON is never sent to a server.

JSON Flattener — Gera Tools

JSON flattener

Deeply nested JSON is awkward to diff, map onto environment variables or store in a flat key/value system. This tool collapses a nested JSON object or array into a single-level object where every leaf value is keyed by its full path, so the whole structure becomes a tidy list of path/value pairs.

How it works

The flattener walks the JSON recursively, building up a path as it descends:

Object keys are appended using your chosen delimiter (a dot by default), so a then b becomes a.b.
Array items append their index — roles.0 in dot mode, or roles[0] if you enable bracket notation.
Empty objects and arrays are kept as leaf values ({} / []) at their path so nothing is lost and the structure can be rebuilt exactly.

Each leaf value (string, number, boolean or null) is copied unchanged.

Example

This nested input:

{ "user": { "name": "Sam" }, "roles": ["admin", "editor"] }

flattens (with dot indices) to:

{
  "user.name": "Sam",
  "roles.0": "admin",
  "roles.1": "editor"
}

Switch on bracket notation and the array keys become roles[0] and roles[1], which round-trips cleanly through the unflatten tool. Everything runs in your browser — your JSON never leaves your device.