⌘ K
json → properties · dot paths · spring · java config · live

Convert JSON to .properties

Flatten a JSON object into Java .properties syntax. Nested keys join with dots, arrays comma-join, and scalars stringify directly — perfect for Spring Boot and other JVM tools.

JSON → Properties
Input
179 B
7 lines
Output
137 B
4 lines
Status
ready
live
Ratio
0.77×
out/in
input · json
output · .properties
spring.application.name=my-service
spring.datasource.url=jdbc:postgresql://localhost/db
spring.datasource.username=admin
server.port=8080
Quick Start

How flattening works

The JSON tree is walked depth-first. Nested object keys are concatenated with dots, so spring.datasource.url is one line. Arrays collapse to a comma-joined string. Scalars stringify with Number/Boolean coercion.

  1. 01

    Paste JSON

    Top-level must be an object. Nested objects are flattened automatically.

    Parsing is strict-but-tolerant — comments and trailing commas are accepted on input where the source format historically permits them; output stays canonical.

    inputstricttolerantliveparse
    in · sourcejson · live
    { "server": { "port": 8080 } }
    loaded · parsedtarget · ready
  2. 02

    Dot-path keys

    Nested object keys join with dots — Spring Boot's preferred shape.

    Conversion preserves type information where the target supports it (numbers stay numeric, booleans stay boolean) so the destination parser never has to re-coerce.

    pathstype-preservinglosslesslivememoised
    key · optionsdot · live
    server.port
    options applied · liveround-trip
  3. 03

    Arrays comma-joined

    ["a", "b", "c"] becomes a,b,c — load it with @Value("${tags:}") split.

    Re-encoding is idempotent: running output back through the same converter produces the same bytes, which keeps round-trips git-friendly.

    arraysidempotentround-tripdiff-cleandeterministic
    [] · convertedcsv · ready
    tags=web,api,prod
    converted · livediff-clean
  4. 04

    Copy or download

    Drop into application.properties or any java.util.Properties consumer.

    Copy writes via navigator.clipboard.writeText; downloads use the target’s native MIME so editors apply the right syntax highlighting on open.

    exportclipboardtarget MIMEblobclient-side
    ✓ · copiedready · done
    ✓ Copied
    shipped · ready to shipsuccess
Pro tips

Converting between formats, safely

Pick the strictest source format

Lossy formats hide bugs. Choose JSON or YAML as your source-of-truth, convert downstream as needed.

Round-trip in CI

If your converter is idempotent, your CI can verify A → B → A equals the original. Catches subtle data loss.

Numbers vs strings differ

YAML/TOML have a number type; CSV doesn’t. Quote IDs in CSV to keep leading-zero values intact.

Watch character encoding

Source format may be Latin-1 / Windows-1252; target should be UTF-8. Convert encoding before structure.

Preserve comments where you can

YAML and TOML support comments. Don’t silently drop them — they often encode intent.

Schema-aware beats blind

Use a schema to guide conversion. Field types, required-ness, and defaults survive better with structure.

Related toolsProperties to JSONJSON to ENVJSON to INIJSON to TOMLYAML to JSONENV to JSON
Use Cases

When to convert JSON to Properties

Spring Boot, Java apps, JVM config.

Spring Boot

Generate application.properties from a JSON config snapshot. Type information survives: numbers stay numeric, booleans stay boolean, strings stay strings. The destination parser doesn't have to re-coerce, which avoids the "'true' becomes "true"" bug class.

round-trip safe

Servlet apps

Materialise JSON config into web.xml-adjacent properties files. Run output back through the inverse converter to verify idempotent round-trips in CI. A → B → A should produce byte-identical input — if it doesn't, you've found data loss.

type-preserving

Build tools

Hand JSON config to Gradle or Maven that prefer Properties. Comments and metadata survive where the target format supports them (YAML, TOML, HCL). The tool doesn't silently drop intent-encoded annotations, which keeps your config self-documenting.

schema-aware

Localisation

Bootstrap i18n .properties bundles from a JSON dictionary. Pair with a schema (JSON Schema, OpenAPI, Zod, Pydantic) to catch shape drift on either side. Catch breaking changes at conversion time rather than at runtime in production.

i18n

Legacy migrations

Move a JSON config layer back into a JVM-only deployment. Output respects target-format conventions: quoting in CSV, indent in YAML, brackets in JSON. Existing parsers don't need patches, and the result drops into legacy pipelines unchanged.

diff-clean

Docs

Show .properties form next to JSON for clarity. Encoding-aware: handles UTF-8 vs UTF-16 vs Latin-1 / Windows-1252 transparently. The character-set surprise that breaks "works on my machine" doesn't apply here.

spec-grade
FAQ

Frequently asked questions

Comma-joined strings. Use the Properties to JSON tool to round-trip — splits restore the list shape.
Values pass through verbatim. The standard java.util.Properties writer escapes : = and # — drop the output into Properties.store() if you need that.
Existing dots in keys keep their literal meaning. The flattener concatenates with new dots between levels.
Not flattened — the entire JSON encoding becomes the value. Restructure first if you need indexed access.
No. Flattening runs entirely in your browser.
Suggest a tool

Something missing?

Tell us what you need. We ship the top requests every two weeks.

Sent straight to the maintainers · no account needed
47 in queue·8 shipped this month
Request queued. Thanks!