All Tools
Categories
XML Tools 64 Email Marketing Tools 55 Import-Export Tools 50 JSON Tools 36 Text Tools 12 Shipping Freight Tools 5 Calculator 4 Marketing Tools 3
About Contact Privacy

Properties to JSON

Convert a Java .properties file to nested JSON in one click: comments, escapes, \uXXXX, line continuations and dotted keys with automatic arrays. Download ready. All client-side.

Properties Input
Waiting for input
JSON Output
Dotted keys are rebuilt as nested objects, numeric segments like items.0 become arrays, and standard escapes (\\uXXXX, \\t, \\n, \\r, \\=, \\:, \\ , \\#, \\!) are decoded.

About Properties to JSON

Thousands of legacy systems still keep their configuration in .properties files — and every modern one wants JSON. Migrating by hand means flattening and unflattening dotted paths, decoding \uXXXX escapes, joining continuation lines and deciding whether items.0 is a list or a map. It is mechanical work, and machines are good at it.

Convert Properties to JSON parses any standard properties file and rebuilds it as nested JSON. Comments, escapes, continuations and dotted keys are handled automatically, numeric segments become arrays, and values can be typed as booleans and numbers. One click, all client-side.

Features

  • Full format support: # and ! comments, = : and space separators, escaped separators, Unicode and control escapes.
  • Line continuations: Trailing-backslash continuation lines are joined before parsing.
  • Nested JSON rebuild: Dotted keys become nested objects; numeric segments become arrays automatically.
  • Optional type inference: true, false, null and numbers convert to native JSON types when enabled.
  • Duplicate handling: Later entries overwrite earlier ones, matching standard loaders.
  • Pretty output: The result is formatted, readable JSON.
  • Copy and download: Export the JSON document instantly.
  • Private: All processing happens in your browser; nothing is uploaded.

How to Use

  1. Paste your .properties file into the input pane.
  2. Toggle auto-type if booleans and numbers should become native JSON values.
  3. Review the live output — dotted keys, escapes and continuations are already resolved.
  4. Copy or download the resulting JSON.

Examples

Example 1 — Legacy migration. A team migrates an old Java service to a JSON-based config store. The converter turns application.properties into nested JSON with typed values, preserving every setting.

Example 2 — Kubernetes migration. A platform team converts properties into a ConfigMap JSON, using the array support so indexed keys like hosts.0.host become proper lists.

Example 3 — Audit and review. A consultant opens a thousand-line properties file and converts it to JSON to inspect the effective configuration as a tree instead of scrolling flat keys.

Example 4 — Round-trip tooling. A developer converts properties to JSON, edits it, and converts back with the companion JSON to Properties tool — using escapes and continuations correctly on both sides.

Benefits

  • Standard-compliant parsing: Matches how Java loaders read the format.
  • Structured output: Nested objects and arrays replace flat dotted keys.
  • Typed values: Booleans and numbers stay native when auto-type is on.
  • Zero data movement: The file is processed locally and never uploaded.
  • Instant results: Live output updates with every keystroke.

Frequently Asked Questions

What does this converter parse?
It follows the classic properties format: # and ! comment lines, key=value, key:value and key value separators, \uXXXX and control-character escapes, escaped \= \: \ \# \! sequences, and line continuations with a trailing backslash.
How are dotted keys converted?
Keys such as server.host are split on dots and rebuilt as nested objects: {"server":{"host":"db.example.com"}}. Numeric segments become arrays, so items.0.name produces {"items":[{"name":...}]} automatically.
How are values typed?
With the auto-type option on, the strings true, false, null, integers and decimals are converted to booleans, null and numbers. Turn the option off to keep every value as a plain string.
What about escaped characters?
All standard escapes are decoded: \uXXXX for Unicode, \t \r \n \f for control characters, and \= \: \ \# \! \\ for literal separator and comment characters in keys and values.
What happens with duplicate keys?
Later entries overwrite earlier ones for the same path, matching properties-loader behavior. Comment lines and blank lines are ignored entirely.
Is my data uploaded anywhere?
No. Conversion happens entirely in your browser. Nothing is uploaded, stored or logged.