Does Spring Boot support both application.properties and application.yml?

Yes. Spring Boot loads application.properties and application.yml interchangeably from the same locations. If both files exist in the same directory, properties are loaded first and YAML entries override them, but most projects pick one format and stick with it. YAML is usually preferred when configuration is deeply nested.

How are indexed properties like list[0] converted?

Spring-style indexed keys such as management.endpoints.web.exposure.include[0] and include[1] are collected into a YAML list under the parent key. The reverse direction flattens YAML lists back into indexed properties, preserving order.

Spring Properties to YAML Converter

.propertiesYAML

.properties

YAML

What does this converter do?

It converts Spring Boot configuration between the two formats Spring supports natively: the flat key=value .properties format and the nested, indentation-based .yml (YAML) format. Dotted keys become nested mappings, indexed keys become YAML lists, and the reverse direction flattens them back to properties.

How do I convert application.properties to application.yml?

Paste your application.properties content into the left panel. The YAML equivalent is generated instantly on the right. Each dot in a key becomes a new level of indentation, so spring.datasource.url turns into a spring mapping containing a datasource mapping containing url.

How do I convert application.yml back to properties?

Click the swap button in the toolbar to switch direction. The left panel then accepts YAML and produces a flattened .properties file on the right. Nested maps become dot-joined keys and YAML lists become indexed keys like servers[0], servers[1].

How are lists and arrays handled?

Spring Boot reads indexed keys such as management.endpoints.web.exposure.include[0]=health as YAML lists. This converter groups consecutive indexed keys under the parent key and writes a list in YAML. Going the other way, YAML lists are expanded into parent[0], parent[1], and so on.

Are comments preserved?

Comments in .properties (lines starting with # or !) are ignored during conversion, and YAML comments are discarded when parsing. Both .properties and YAML represent the same structured data, but comments are not part of that data. Re-add any documentation you need after conversion.

How are values typed?

In .properties, every value is a string. When converting to YAML, this tool detects obvious primitives so the output reads naturally: true and false become booleans, integers and decimals become numbers, and null or ~ becomes null. Everything else stays a string. Spring Boot coerces these values back to the target type at bind time, so the behavior is equivalent.

Is my configuration sent to a server?

No. Conversion runs entirely in your browser with JavaScript. Your configuration is never uploaded or stored, so it is safe to paste configs that contain database URLs, internal hostnames, or other sensitive defaults.

Does it support Spring profiles?

Single-document conversion is fully supported. Multi-document YAML (separated by ---) that uses spring.config.activate.on-profile is read when converting to properties, but the profile separator itself cannot be represented in the flat .properties format. Split your profiles into application-dev.yml, application-prod.yml, etc. and convert each file independently.

What is the .properties format?

Java .properties files are flat text files of key=value pairs, one per line. The format is defined by java.util.Properties and has been the default configuration format for JVM applications since the 1990s.

Comments start with # or !. Keys can be separated from values by =, :, or whitespace. A trailing backslash continues a value onto the next line. Unicode escapes like é and common escapes like \n and \t are supported inside values.

What is YAML?

YAML (YAML Ain't Markup Language) is a human-friendly data serialization format. It uses indentation instead of braces to represent structure and natively supports nested maps, lists, and scalars.

Spring Boot added first-class support for application.yml because configuration trees like spring.datasource.hikari.* collapse neatly into nested blocks, reducing the amount of repeated prefix text compared to flat properties.