What does a flattened key look like for an array item?

Array items get a bracketed index appended to the path, so the second item of a `roles` list becomes `roles[1]`. Objects inside arrays combine both: the `name` field of the first item in a `servers` list becomes `servers[0].name`.

What happens to an empty mapping or empty array?

An empty object (`{}`) or empty array (`[]`) is kept as-is at its own path rather than being dropped, since there's nothing beneath it to flatten and discarding it would lose information about the key's existence.

Can I flatten a top-level list instead of a mapping?

Yes. A top-level sequence flattens using purely bracketed indices, like `[0].name` and `[1].name`, since there's no top-level key to prefix them with.

Is flattening reversible?

Not with this tool directly, flattening is one-directional. If you need to go the other way, the dot-notation keys are structured the same way `properties-to-yaml`'s parser expects, so you can often round-trip through that tool by treating the flattened output as key=value pairs.

Does this tool send my YAML anywhere?

No, flattening happens entirely in your browser using the same `yaml` parser used by every other tool in this category. Nothing you paste is uploaded.

Flatten YAML - Convert Nested YAML to Dot Notation

Overview

Introduction

Nested YAML is great for humans to read but awkward for systems that expect flat key-value pairs, environment variable injectors, search indexes, and some config loaders all want one level of keys, not arbitrarily deep nesting.

This tool bridges that gap: it walks a YAML document and re-expresses every leaf value as a single flat key built from the path that led to it, then re-serializes the result as YAML.

What Is YAML Flattener?

A YAML flattener converts a nested document into a single-level mapping where each key encodes the original path using dot notation for object keys and bracket notation for array indices.

The output is still valid YAML, just structurally flat: every value that used to be several levels deep now lives directly under a compound key at the top level.

How YAML Flattener Works

The input is parsed into its underlying value, then walked recursively. At each mapping key or array index, the current path is extended (`a` becomes `a.b` for a nested key, or `a[0]` for an array item) until a scalar leaf, or an empty object/array, is reached, which is then written to the result under its full path.

The resulting flat object is re-serialized with the same block-style YAML stringifier used by the formatter, so indentation and quoting follow the same conventions as the rest of this site's YAML tools.

When To Use YAML Flattener

Use it when preparing YAML-derived data for a system that expects flat keys, like environment variable files or certain feature-flag services.

It's also useful for quickly scanning every leaf value in a deeply nested document without manually tracking indentation levels.

Often used alongside YAML to Properties Converter, YAML Formatter & Prettifier and YAML Key Extractor.

Features

Advantages

Turns deep nesting into a single, scannable list of paths and values.
Preserves every value exactly, nothing is dropped or summarized.
Handles arbitrarily deep mixes of mappings and sequences.
Runs entirely client-side, so nested config with real values never leaves your browser.

Limitations

The transformation is one-directional; this tool doesn't reconstruct nested YAML from flattened output.
Very wide or deep documents produce very long compound keys, which can be harder to skim than the original nesting for some use cases.
A top-level scalar (a document that's just a single value) can't be flattened, since there's no structure to flatten.

Examples

Nested mapping to dot-notation

Input

config:
  limits:
    cpu: 2
    memory: 512Mi

Output

config.limits.cpu: 2
config.limits.memory: 512Mi

Each nested key is joined with a dot to form a single flat path.

A list of objects

Input

servers:
  - name: web-1
  - name: web-2

Output

servers[0].name: web-1
servers[1].name: web-2

Array indices are wrapped in brackets and combined with the nested object's own keys.

Best Practices & Notes

Best Practices

Flatten before feeding YAML-derived values into systems that only understand flat key-value pairs.
Use the bracketed array indices to spot exactly how many items were in a list without counting dashes.
Run YAML Statistics first on very large documents so you know what to expect before flattening.

Developer Notes

The flatten routine mirrors this site's JSON object flattener, adapted to parse through `parseYaml` and re-serialize through `toBlockYaml` instead of `JSON.stringify`. Empty objects and arrays are preserved at their own path rather than silently dropped, matching the JSON flattener's behavior.

YAML Flattener Use Cases

Converting a nested config into environment-variable-style keys
Preparing YAML data for ingestion into a flat key-value store
Quickly scanning every leaf value in a deeply nested Helm chart or manifest
Feeding flattened paths into a search index that doesn't support nested fields

Common Mistakes

Expecting the flattened output to be reversible with this tool alone, it isn't; use Properties to YAML for the closest reverse path.
Flattening a document that's mostly large arrays and being surprised by how many bracketed keys result.
Assuming an empty object or array is dropped during flattening, it's kept as a single key with an empty value instead.

Tips

Use the flattened output's key paths directly as a checklist when auditing which config values are actually set.
Combine with Extract Keys from YAML if you only need the key names, not the values.
For very deep configs, flatten first and then search the output text for the value you're looking for.

YAML Flattener