.properties to JSON Converter
Convert Java .properties files to JSON and back, in your browser.
.pdf · up to 2 GB
What it's for
.properties to JSON and JSON to .properties
Compatible with the entire Java ecosystem
Works with Spring Boot, Quarkus, Micronaut, Hibernate, Log4j2, and any Java framework that uses .properties files.
100% private
Your configuration (which may include passwords and API keys) is processed only in your browser. Never sent to any server.
Correct nesting
Dot notation converted to nested JSON objects. a.b.c becomes {a: {b: {c: value}}} correctly.
Instant
Bidirectional conversion in real time. No signup, no waiting, no limits.
How it works
Three steps, no hassle
Paste your .properties or JSON
Paste the content of your Java .properties file or your JSON object. The tool automatically detects the format.
Bidirectional conversion
From .properties to JSON: dot notation (a.b.c) creates nested objects. From JSON to .properties: nested objects are flattened using dots.
Copy the result
Copy the result with one click and use it in your Spring Boot, Quarkus, or any Java application.
FAQ
Got questions?
The .properties format is Java's standard configuration mechanism since version 1.0 (1996). It is a plain text file with key=value pairs, one per line. It has been used for nearly 30 years in frameworks like Spring, Hibernate, Log4j, and virtually any enterprise Java application. The JDK's java.util.Properties class supports it natively without external dependencies.
In the .properties format, nesting is simulated via dots in the key name: database.host=localhost, database.port=5432, database.name=mydb. When converting to JSON, this convention is interpreted as nested objects: {"database": {"host": "localhost", "port": "5432", "name": "mydb"}}. Spring Boot uses exactly this convention for its configuration system (application.properties).
Lines beginning with # are comments in the .properties format and are omitted when converting to JSON (JSON has no native comment support). The ! symbol is also used as a comment in some implementations. When converting from JSON to .properties, no comments are generated since there is no JSON equivalent. If you need to preserve comments, add them manually to the resulting .properties file.
Spring Boot supports both application.properties and application.yml for externalized configuration. Spring Boot profiles (application-dev.properties, application-prod.properties) allow different configurations per environment. Conversion to JSON is useful for migrating configurations to systems expecting JSON, integrating with config management tools like Spring Cloud Config Server, or when you need to inspect the resulting configuration as a structured object.
Many modern Java projects migrate from .properties to YAML (application.yml) because YAML supports native nesting without dots, is more readable for complex configurations, and naturally supports lists. Conversion to JSON is a useful intermediate step in this migration: convert .properties to JSON to understand the structure, then convert that JSON to YAML. It is also useful for modern frameworks like Quarkus and Micronaut that support multiple configuration formats.
Java .properties file history, Spring Boot externalized configuration, and cloud-native config management
The Java .properties format has nearly 30 years of history. Introduced in Java 1.0 (1996) through the java.util.Properties class, it became the de facto standard for Java application configuration. Frameworks like Spring (2003), Hibernate (2001), and Log4j (2001) adopted this format for their configuration. Today, decades later, it remains ubiquitous in Java legacy projects and in Spring Boot, which uses it as one of its two main configuration formats alongside YAML.
Spring Boot introduced in 2014 the concept of externalized configuration, based on the third factor of the 12-factor app methodology. application.properties (and application.yml) are the primary mechanism for configuring a Spring Boot application without modifying code. Spring Boot supports multiple configuration sources with a defined precedence order: environment variables, command-line arguments, application.properties, etc. Profiles (spring.profiles.active) allow having application-dev.properties, application-staging.properties, and application-prod.properties.
In the cloud-native paradigm, configuration management evolves toward centralized systems. Spring Cloud Config Server serves configuration from a centralized Git repository to multiple microservices. HashiCorp Vault manages secrets securely. Kubernetes ConfigMaps and Secrets replace .properties files in containers. Modern frameworks like Quarkus (Red Hat) and Micronaut (Object Computing) support multiple configuration formats (properties, yaml, json) and are optimized for cloud-native environments with millisecond startup times. Converting between formats is fundamental when migrating traditional Java applications to cloud architectures.