Staaarter Tools

YAML to Properties Converter

Paste YAML and get back a flat Java `.properties` file, every nested key collapsed into dot-notation and written as `key=value`, with the same escaping rules `.properties` loaders expect. A free online tool from Staaarter, right in your browser.

Runs locallyUpdated 2026-07-22
conversionjavaconfiguration

Overview

Introduction

Java configuration has historically leaned on flat `.properties` files, while modern config, especially for Spring Boot and CI tooling, is often written in YAML for readability. When you need the flat form, converting nested YAML into dot-notation properties by hand is tedious and easy to get wrong around escaping.

This tool automates that conversion: it parses YAML and flattens every nested key into the dot-notation `.properties` format already used by Spring's own relaxed binding.

What Is YAML to Properties Converter?

A YAML-to-properties converter walks a parsed YAML document and, for every leaf scalar value, builds a dot-notation key from the path that reached it, then writes it as a `key=value` line.

It follows the same conventions the Java `Properties` class and Spring Boot's config binder use: dots for nested object keys, numeric indices for list items, and backslash escaping for characters that are special in `.properties` syntax.

How YAML to Properties Converter Works

The input is parsed with a full YAML 1.2 parser. The resulting value is walked recursively, mapping keys extend the current path with a dot, array items extend it with a dot and their index, and each leaf scalar is written as one `key=value` line.

Keys escape `=`, `:`, whitespace, `#`, `!`, and backslash; values escape backslashes and the newline, carriage return, and tab characters, matching the same escaping this site's JSON-to-properties tool uses, since both formats target the same `.properties` file spec.

When To Use YAML to Properties Converter

Use it when migrating a YAML-based config into a Java project that still reads `.properties` files, or when a build tool requires properties-format input.

It's also useful for Spring Boot projects that want to see how a `application.yml` file would look as the equivalent `application.properties`.

Often used alongside Properties to YAML Converter, YAML Flattener and YAML to JSON Converter.

Features

Advantages

  • Follows the same dot-notation and indexing conventions Spring Boot's own config binder expects.
  • Handles arbitrarily nested mappings and arrays.
  • Escapes keys and values correctly per the `.properties` file format, avoiding subtle load-time bugs.
  • Runs entirely client-side, so configuration values never leave your browser.

Limitations

  • The conversion is lossy for comments and YAML-specific type information (a quoted `"3"` and a bare `3` both stringify the same way in the output).
  • Deeply nested structures produce long, hard-to-scan keys, a known tradeoff of the flat `.properties` format itself.
  • Only the first document in a multi-document (`---`-separated) YAML stream is converted.

Examples

Nested config to dot-notation properties

Input

config:
  debug: false
  retries: 3

Output

config.debug=false
config.retries=3

Each nested key becomes a single flat key joined by dots.

A list becomes indexed keys

Input

roles:
  - admin
  - editor

Output

roles.0=admin
roles.1=editor

List items get a numeric suffix, matching Spring's own list-binding convention.

Best Practices & Notes

Best Practices

  • Review the generated key names against your framework's binding conventions before relying on them, most Java tooling expects exactly this dot/index format, but confirm for anything unusual.
  • Run YAML Statistics first on very large configs to gauge how many properties lines you'll end up with.
  • Keep the original YAML as the source of truth; treat the properties output as a generated artifact, not something to hand-edit and convert back.

Developer Notes

The flattening and escaping logic is a direct adaptation of this site's JSON-to-properties converter, with `JSON.parse` swapped for `parseYaml`. Keeping the two converters' escaping logic identical means a document round-tripped through YAML-to-JSON-to-properties produces the same output as going through this tool directly.

YAML to Properties Converter Use Cases

  • Migrating a YAML config into a Java project that reads `.properties` files
  • Previewing what a Spring Boot `application.yml` looks like as `application.properties`
  • Feeding flattened config into build tools or CI systems that expect properties-format input
  • Generating `.properties` fixtures for tests from a more readable YAML source

Common Mistakes

  • Assuming type information survives the conversion, `.properties` values are always plain text, so a boolean and its string equivalent look identical in the output.
  • Forgetting that list items are indexed from 0, not 1, when cross-referencing keys with the original YAML.
  • Hand-editing the generated properties file and expecting changes to propagate back to the original YAML, they won't; this is a one-way conversion.

Tips

  • If your framework supports comma-separated lists in a single property instead of indexed keys, you may need to post-process the array-derived lines.
  • Use Flatten YAML first if you want to inspect the dot-notation structure as YAML before converting to `.properties`.
  • Pair with Properties to YAML to verify a round trip if you need to confirm no information was lost for a specific document.

References

Frequently Asked Questions