Flatten JSON Object

The Flatten JSON Object tool transforms deeply nested JSON structures into a single-level object using dot notation for keys. Whether your JSON has two levels of nesting or ten, this tool recursively traverses every branch and produces a clean, flat representation where each key encodes the full path to its value. For example, a nested structure like `{"user":{"address":{"city":"London"}}}` becomes `{"user.address.city":"London"}` — instantly readable, queryable, and portable. This tool is invaluable for developers, data engineers, and analysts who work across systems that don't natively support nested data. Many relational databases, CSV exports, environment variable systems, and configuration frameworks require flat key-value pairs. Rather than manually unwinding nested objects — a tedious and error-prone process — you can paste your JSON and get a flattened result in seconds. Arrays are handled gracefully using index notation, so `{"items":["a","b"]}` becomes `{"items.0":"a","items.1":"b"}`. All original values are preserved exactly, including strings, numbers, booleans, and nulls. The output is always valid JSON, ready to copy into your codebase, database insert, config file, or downstream pipeline. Whether you're debugging a deeply nested API response, preparing data for Elasticsearch, or standardizing configs across environments, this tool saves meaningful time.

Input (JSON Object)
Options
Object Flattening Depth
Enter "*" to flatten objects at all levels
Key Join Symbol
JSON Indentation
Output (Flattened Object)

Related Tools

Convert Properties to JSON

Convert Java properties file format to JSON with support for nested objects, arrays, and custom separators.

Json

Convert JSON to Text

Convert JSON into readable plain text with hierarchy preservation.

Json

Convert JSON to Properties

Convert JSON objects to .properties format with dot notation.

Json

Unstringify JSON

Convert stringified JSON into proper JSON object.

Json

What It Does

The Flatten JSON Object tool transforms deeply nested JSON structures into a single-level object using dot notation for keys. Whether your JSON has two levels of nesting or ten, this tool recursively traverses every branch and produces a clean, flat representation where each key encodes the full path to its value. For example, a nested structure like `{"user":{"address":{"city":"London"}}}` becomes `{"user.address.city":"London"}` — instantly readable, queryable, and portable. This tool is invaluable for developers, data engineers, and analysts who work across systems that don't natively support nested data. Many relational databases, CSV exports, environment variable systems, and configuration frameworks require flat key-value pairs. Rather than manually unwinding nested objects — a tedious and error-prone process — you can paste your JSON and get a flattened result in seconds. Arrays are handled gracefully using index notation, so `{"items":["a","b"]}` becomes `{"items.0":"a","items.1":"b"}`. All original values are preserved exactly, including strings, numbers, booleans, and nulls. The output is always valid JSON, ready to copy into your codebase, database insert, config file, or downstream pipeline. Whether you're debugging a deeply nested API response, preparing data for Elasticsearch, or standardizing configs across environments, this tool saves meaningful time.

How It Works

Flatten JSON Object simplifies a more nested structure into something flatter and easier to inspect or move between systems. The tradeoff is that flatter outputs are often easier to scan but may carry less structural nuance than the original.

Unexpected output usually comes from one of three places: the wrong unit of transformation, hidden formatting in the source, or an option that changes the rule being applied.

All processing happens in your browser, so your input stays on your device during the transformation.

Common Use Cases

  • Flattening nested API response payloads before inserting records into a relational database that expects flat column structures.
  • Converting deeply nested configuration objects into flat key-value pairs for use in environment variable systems like dotenv or AWS Parameter Store.
  • Preparing complex JSON documents for indexing in Elasticsearch or OpenSearch, which benefits from flattened field paths for efficient querying.
  • Simplifying nested Redux state or application config objects during debugging to quickly inspect all values at a glance.
  • Transforming nested JSON exported from MongoDB or Firebase into flat rows compatible with spreadsheet tools like Excel or Google Sheets.
  • Normalizing inconsistently nested third-party API responses before feeding them into a data pipeline or ETL process.
  • Converting nested i18n translation files into flat dot-notation keys for compatibility with certain localization libraries or platforms.

How to Use

  1. Paste your nested JSON object into the input field — this can be any valid JSON including deeply nested objects, mixed arrays, and varied value types.
  2. Click the Flatten button (or the tool will process automatically) to recursively traverse the entire object tree and generate the flattened output.
  3. Review the result, where each key is now a dot-notation path representing the full hierarchy from root to leaf, such as 'config.database.host'.
  4. For arrays in your input, note that each element is represented by its numeric index in the key path, for example 'users.0.name' and 'users.1.name'.
  5. Copy the flattened JSON output using the Copy button and paste it directly into your database query, config system, or downstream application.
  6. If the output is larger than expected, use it as a diagnostic tool — the flattened keys give you a complete inventory of every value stored in your original structure.

Features

  • Recursive dot-notation flattening that handles unlimited nesting depth without losing any values or structural information.
  • Array support with zero-based numeric index notation, so every array element is individually accessible as its own flat key.
  • Preserves all JSON value types including strings, numbers, booleans, nulls, and even empty strings without coercion or transformation.
  • Produces strictly valid JSON output that can be immediately parsed, stored, or transmitted without any additional processing.
  • Instant in-browser processing with no server upload required, keeping your sensitive configuration and data completely private.
  • Clean, readable key format that makes the full path to any nested value immediately understandable at a glance.
  • Handles mixed structures containing both objects and arrays at any level of nesting within the same input document.

Examples

Below is a representative input and output so you can see the transformation clearly.

Input
{
  "user": {"name": "Ada", "role": "admin"}
}
Output
{
  "user.name": "Ada",
  "user.role": "admin"
}

Edge Cases

  • Very large inputs can still stress the browser, especially when the tool is working across many objects. Split huge jobs into smaller batches if the page becomes sluggish.
  • Empty or whitespace-only input is technically valid but may produce unchanged output, which can look like a failure at first glance.
  • If the output looks wrong, compare the exact input and option values first, because Flatten JSON Object should be repeatable with the same settings.

Troubleshooting

  • Unexpected output often means the input is being split or interpreted at the wrong unit. For Flatten JSON Object, that unit is usually objects.
  • If a previous run looked different, check for hidden whitespace, changed separators, or a setting that was toggled accidentally.
  • If nothing changes, confirm that the input actually contains the pattern or structure this tool operates on.
  • If the page feels slow, reduce the input size and test a smaller sample first.

Tips

When working with very large or deeply nested JSON, scan the flattened keys first to understand the full shape of your data — it acts as an instant schema map. If you plan to store flattened keys in a database column, be aware that deeply nested paths can generate long key strings; consider whether your schema has column name length limits. For round-tripping data, pair this tool with an unflatten utility so you can restore the original nested structure after processing. When flattening JSON that contains dot characters in its original keys (e.g., domain names or version strings), be cautious — the dot separator can cause ambiguity when unflattening later.

JSON flattening is the process of converting a hierarchical, multi-level JSON object into a single-level dictionary where every key encodes the full path to its corresponding value. The concept is straightforward, but its applications are wide-ranging and the technique is essential knowledge for anyone who works seriously with JSON data. **Why Nested JSON Exists — and Why It's Sometimes a Problem** JSON's nested structure mirrors how we naturally think about data. A user has an address; an address has a city; a city has a postal code. Nesting lets you group related fields logically and avoid redundant key prefixes on every property. This is excellent for human readability and for object-oriented programming, where you traverse properties naturally with dot notation in code. However, this hierarchical beauty breaks down when you need to work with systems that expect flat data. Relational databases store data in rows and columns — they have no native concept of a nested field. CSV files are inherently two-dimensional. Many analytics and BI tools, environment variable systems, and message queue payloads require flat key-value pairs. When you receive a nested JSON response from an API and need to load it into a PostgreSQL table or an Excel sheet, you have a structural mismatch that must be resolved. **How Dot Notation Flattening Works** The most common and interoperable approach to flattening is dot notation, where the key `"user.address.city"` represents a value three levels deep: inside `user`, then `address`, then `city`. This mirrors the property access syntax of JavaScript and many other languages, making it intuitive for developers. Arrays are typically handled by substituting the element index for a key name: `"users.0.email"` and `"users.1.email"` represent the email fields of the first and second elements in a `users` array. This preserves array ordering and makes every individual element directly addressable. **Flattening vs. Serialization vs. Stringification** It's worth distinguishing JSON flattening from related operations. JSON stringification (e.g., `JSON.stringify`) converts a JavaScript object into a JSON-formatted string — the structure remains nested, it's just text now. JSON serialization similarly encodes the full structure for transport. Flattening is different: it changes the shape of the data itself, collapsing hierarchy into a single level. A flattened object is still valid JSON, but its structure is fundamentally different from the original. Another related concept is JSON normalization, used in tools like Redux and database design, which splits nested data across multiple related tables or slices. Flattening is simpler and lossless — no data is split or referenced; it's all in one object with longer keys. **Real-World Applications** In Elasticsearch, flat field paths map directly to document fields, and flattening your JSON before indexing can simplify mapping definitions and query syntax. In serverless and cloud environments, tools like AWS Lambda and Google Cloud Functions often pass configuration via environment variables, which are inherently flat — flattening your config JSON makes this translation trivial. Data engineers building ETL pipelines frequently flatten semi-structured JSON from APIs before loading it into columnar data warehouses like BigQuery or Redshift, where every field needs to be a discrete column. Developers debugging complex Redux stores or nested GraphQL responses also benefit from a flattened view — it gives an instant, scannable inventory of every piece of state or data in the system, without needing to manually expand nested nodes in a JSON viewer.

Frequently Asked Questions

What is JSON flattening and what does it produce?

JSON flattening is the process of taking a multi-level nested JSON object and converting it into a single-level object where each key represents the full path to a value using dot notation. For example, `{"a":{"b":1}}` becomes `{"a.b":1}`. The output is a standard, valid JSON object — it just has no nested objects or arrays inside it. All the original values are preserved; only the structure changes.

How are arrays handled when flattening JSON?

Arrays are flattened using zero-based numeric index notation. Each element in an array gets its own key with the element's index as part of the path. For example, `{"colors":["red","blue"]}` becomes `{"colors.0":"red","colors.1":"blue"}`. If array elements are themselves objects, their properties are also flattened: `{"users":[{"name":"Alice"}]}` becomes `{"users.0.name":"Alice"}`. The ordering of array elements is preserved through the index numbering.

Can I reverse a flattened JSON object back to its original nested structure?

Yes, this is called "unflattening" and it's the inverse operation. By parsing the dot-notation keys and reconstructing the nested hierarchy, you can restore the original structure. Many libraries (such as the `flat` npm package) support both flatten and unflatten operations. However, if your original JSON keys contained literal dots (e.g., a domain name or version string like `"1.0.0"`), unflattening can produce incorrect results since the dot is ambiguous as both a separator and a literal character.

Why would I need to flatten JSON for a database?

Relational databases organize data in flat tables with fixed columns, so they cannot natively store a nested JSON object as-is without using a JSON column type. When you want to map each nested property to its own database column — for easier querying, indexing, and filtering — you need to flatten the object first. The flattened key names can map directly to column names, and the values map to the row's cell values. This is especially common when loading API response data into PostgreSQL, MySQL, or data warehouses like BigQuery.

Does flattening work on JSON with mixed arrays and objects?

Yes, the flattening algorithm handles any combination of nested objects and arrays at any depth. A JSON structure that alternates between objects and arrays across multiple levels will be fully traversed, and every leaf value will appear in the flattened output with a complete dot-and-index-notation key. The tool handles real-world JSON from APIs, which rarely has a perfectly uniform structure, without any configuration needed.

What's the difference between flattening JSON and using JSON Pointer or JSONPath?

JSON Pointer (RFC 6901) and JSONPath are query syntaxes for accessing values within a nested JSON structure — they let you reference a specific value by path without changing the document. JSON flattening is a transformation: it restructures the entire document into a new flat format. Flattening is best when you need to change the shape of the data for storage or processing; JSON Pointer and JSONPath are best when you need to extract or reference specific values from an existing nested document.

Are there any limitations to JSON flattening?

The main limitation is that flattening is not always perfectly reversible if your original keys contain dots. Additionally, very large JSON documents with thousands of keys may produce a flattened object that is harder to navigate visually, though it remains fully valid and machine-readable. Flattening also increases the total character count of all keys, which slightly increases the size of the JSON. For documents where deep nesting and large arrays combine, the number of keys in the output can grow significantly compared to the input.

How does JSON flattening compare to YAML flattening or TOML?

YAML and TOML both support nested structures, and the concept of flattening applies similarly — collapsing hierarchy into dot-notation keys. TOML is interesting because it already uses dot-notation in its table and key naming conventions, so a flat TOML file looks similar to a flattened JSON object. For JSON specifically, the advantage is that the output remains a valid JSON file, which means it's compatible with every JSON parser and tool without requiring a new format. If you're working in a JSON-centric stack, flattening within JSON is simpler than converting to another format.