Properties Converter
{{ metrics.totalKeys.toLocaleString() }} keys parsed
{{ outputFormatsLine }}
{{ metrics.documentCount }} {{ metrics.documentCount === 1 ? 'file' : 'files' }} {{ metrics.totalScalars.toLocaleString() }} values Depth {{ metrics.maxDepth }} {{ flatten_style === 'slash' ? 'Slash paths' : 'Dot paths' }} Preview trimmed
{{ warn }}
Use key=value, key:value, or whitespace-separated lines; one PROPERTIES, CONF, or TXT file is accepted.
Drop PROPERTIES, CONF, or TXT onto the textarea.
Choose 2 or 4 spaces for review, or Minified for single-line JSON.
Enter 1-8 spaces; 2 is the usual YAML style.
Use 80 for readable diffs, 0 for no wrapping, or up to 240 columns.
Keep on for deterministic review output; off preserves parsed order where possible.
{{ yaml_sort_keys ? 'On' : 'Off' }}
Turn on when IDs such as 00127 or true must stay visibly string-like.
{{ yaml_force_quotes ? 'On' : 'Off' }}
Double quotes handle escapes clearly; single quotes keep most text literal.
Keep on for handoff files that must paste cleanly into tools without anchor support.
{{ yaml_no_refs ? 'On' : 'Off' }}
Dot keeps keys like server.port; slash writes server/port style audit paths.
Enter 50-2000 rows; CSV and DOCX still include every flattened path.
Example: APP turns server.port into APP_SERVER_PORT.
Keep on for POSIX-style exports; turn off only when the target expects lowercase names.
{{ uppercase_env ? 'On' : 'Off' }}
Field Value Copy
{{ row.label }} {{ row.value }} 
{{ normalizedYaml }}
{{ iniText }}
{{ envText }}
{{ propertiesText }}
Document Path Type Preview Copy
Doc {{ row.docIndex }} {{ row.path || '(root)' }} {{ formatTypeLabel(row.type) }} {{ row.preview }}
Path Types Docs Example Copy
{{ row.path }} {{ row.types }} {{ row.docs }} {{ row.example }}
Tags: Data Format, Devops, Devtools
ENV Converter Convert .env files into YAML, JSON, runtime env, INI, and properties output while checking parsed lines, expansion gaps, and secret-like values.
HCL Converter Convert HCL or Terraform config in your browser into YAML, JSON, and flat key-value views with path ledgers and schema drift checks.
INI Converter Convert INI or CFG text in your browser into JSON, YAML, properties, environment-variable text, and normalized INI with parser checks.
TOML Converter Turn TOML into target config formats with parse checks, key-path ledgers, type previews, and schema sketches for safer migrations.
Customize
Advanced
:

Configuration often travels farther than the application it first belonged to. A small .properties file may start as a Java service default, then get copied into deployment notes, compared during a release review, translated into environment variables, or inspected by someone who does not run the original application. The hard part is not only changing the syntax. It is preserving the meaning of names and values while making hidden assumptions visible.

Java-style properties text is built from one key and one value per logical line. The format accepts =, :, or whitespace as the separator, ignores blank lines and comment lines, and lets long values continue onto the next physical line with a trailing backslash. That compactness is useful for human-edited settings, but it also leaves room for mistakes: a missing escape can split a key early, a duplicate key can silently replace an earlier value, and a value that looks numeric may be treated differently after conversion.

Properties conversion review path A properties text block is parsed into key value records, checked for escapes and duplicate keys, then emitted as JSON, YAML, INI, env text, paths, and schema rows. properties server.port=8443 feature.alpha=true message=Hello\u0020team parse and decode lines, comments, escapes review checks duplicates, types, paths output views JSON and YAML INI and env text normalized properties path preview and schema map

Several names in properties files look hierarchical even when the format treats them as plain strings. server.port is one key, not a nested object with server above port. That distinction matters when the same settings are rewritten into JSON, YAML, INI, or environment-variable names, because those formats carry their own ideas about nesting, sections, quoting, and scalar types.

Review output should be read as a careful translation aid, not as a guaranteed replacement for the original file. Comments, original spacing, separator choice, and some escape style can be lost when key-value text is normalized. The safer habit is to use converted output for inspection and handoff, then test the chosen result with the parser that will actually consume it.

Key
The name before the first unescaped separator, after leading whitespace is ignored.
Value
The text after the separator, with supported escape sequences decoded before conversion output is built.
Logical line
A complete key-value record after continued physical lines have been joined.

How to Use This Tool:

Use the tool when you need to inspect Java-style properties text, compare the parsed keys, or hand the same settings to a system that expects a different configuration format.

  1. Paste the text into .properties content, choose a supported text file with Browse file, drop a file on the editor, or load the built-in Sample.
  2. Check the summary before copying anything. It reports parsed keys, scalar values, path style, available output formats, and any warning badges.
  3. Open Advanced when the destination requires different JSON spacing, YAML indentation, YAML line width, sorted YAML keys, scalar quoting, anchor handling, path style, path preview size, env prefix, or env key casing.
  4. Use Conversion Ledger to review top-level keys, total nested keys, scalar counts, sample keys, sample values, and maximum depth.
  5. Compare Path Preview and Schema Map when dotted keys, bracketed paths, duplicate keys, or inferred types could affect the handoff.
  6. Copy or download the specific result that matches the destination format. CSV and DOCX exports are available for the ledger, path preview, and schema map when those review tables need to travel with the change.

If the page reports No properties detected or warns about an empty key, fix the first non-comment line, separator, or escape sequence before using the output tabs.

Interpreting Results:

The first result to trust is the review data, not the prettiest converted text. A JSON or YAML block can look valid while still carrying a replaced duplicate value, a quoted string that lost its quotes, or an environment-variable name that became too broad after punctuation was collapsed.

  • Duplicate key warnings mean the same decoded key appeared more than once, and the later value is the one used in all final output views.
  • Path Preview shows flattened paths for review and export. Dot style uses bracket notation for keys that are not simple identifiers, so a key containing a period may not display exactly as it appeared in the original text.
  • Schema Map groups each observed path with its inferred type, document count, and example value. Use it to find values that became numbers or booleans unexpectedly.
  • Preview trimmed means the on-page path table stopped at the selected preview limit. The full flattened path set is still used for copy and export actions.
  • Properties Output is normalized from parsed paths. It is useful for review, but it does not restore comments, spacing, the original separator, or every original key spelling choice.

A clean result means the converter could parse and serialize the text under the selected settings. It does not prove that Spring, a shell, a YAML reader, an INI reader, or another application will accept the rewritten form without its own validation.

Technical Details:

The Java properties format is a line-oriented key-value format. A natural line is one physical line from the text stream, while a logical line may span several natural lines when the line terminator is escaped with an odd number of trailing backslashes. Blank lines and comment lines are ignored, and a comment begins when the first non-whitespace character is # or !.

Key parsing stops at the first unescaped =, :, space, tab, or form-feed character. Whitespace around the separator is skipped, and the remaining text becomes the value. Escapes are then decoded for keys and values, including tab, newline, carriage return, form feed, escaped separators, escaped spaces, and four-hex-digit Unicode escapes.

Transformation Core:

The conversion begins with one parsed key-value map. The key strings remain flat, while review paths and destination formats provide different ways to display or reshape those parsed values.

Rule How it works Review cue
Line continuation An odd number of trailing backslashes joins the next physical line after leading whitespace is removed. A long value should appear as one value, not as separate keys.
Separator detection The first unescaped equals sign, colon, or whitespace separator divides the key and value. Keys that contain spaces, colons, or equals signs need escaping in the original text.
Escape decoding Common Java-style escapes and valid \uXXXX sequences are decoded before output is built. Unicode and whitespace escapes should be checked in the path and preview rows.
Type inference Quoted values stay strings, unquoted true and false become booleans, and simple decimal numbers become numbers. Codes such as 00127 should be quoted if leading zeroes must remain visible.
Duplicate keys A later decoded key replaces an earlier value for the same key. Treat every duplicate-key badge as a merge-review item.

Output Semantics:

Each output format answers a different handoff question. JSON and YAML keep typed scalar values, INI groups paths into sections when possible, env output creates shell-style names, and review tables expose the parsed shape without requiring the reader to scan a large text block.

View Basis Main limit
JSON Serializes the parsed map with the selected spacing. Inferred numbers and booleans are no longer string values.
YAML Output Serializes the parsed map with selected indentation, wrapping, sorting, quoting, and anchor options. Plain scalars may be interpreted by YAML readers, so quoting can be safer for string-like codes.
INI Output Uses the first normalized path segment as a section when a path has multiple segments. Deep or unusual keys may be flattened more than a hand-written INI file would be.
Env Output Turns scalar paths into environment-style names with optional prefix and casing control. Punctuation collapses to underscores, so similar paths can become similar names.
Path Preview and Schema Map List flattened paths, inferred types, examples, and document counts for review. They describe the converter's parsed view, not a runtime-specific configuration model.

Repeat comparisons are most reliable when the same settings stay fixed: JSON spacing, YAML indent and line width, YAML sorting, YAML quoting, anchor handling, path style, env prefix, env casing, and preview limit. If those settings change between runs, a visible diff may come from formatting rather than a real configuration change.

Limitations and Privacy Notes:

The converter is meant for inspection, cleanup, and handoff. It is not a complete compatibility test for every framework, shell, JSON parser, YAML parser, or INI reader.

  • Java's native Properties API treats keys and values as strings; typed JSON and YAML output is a conversion choice for review and downstream formats.
  • Comments, blank lines, original separator style, original order assumptions, and most formatting choices do not survive normalized output.
  • Only one selected text file is read at a time, and empty/comment-only input produces No properties detected.
  • Pasted text and selected files are parsed in the browser. Still handle configuration with secrets carefully while it is visible, copied, downloaded, or shared.
  • Test the copied output in the destination parser before replacing a working configuration file.

Worked Examples:

Service settings for release review

With server.port=8443, logging.level=INFO, and feature.alpha=true, the ledger should show three top-level keys and three scalar values. JSON and YAML output will treat 8443 as a number and true as a boolean, while env output can create names such as SERVER_PORT and FEATURE_ALPHA.

Duplicate values after a merge

If timeout=30 appears near the top and timeout=60 appears later, the duplicate-key warning is the important result. The final output views use 60. Review the original lines before deciding whether that replacement was intentional.

A key that contains punctuation

A key such as path.with\ spaces=/srv/example app decodes the escaped space before path output is built. In dot path style, punctuation may produce bracketed notation; in env output, punctuation collapses toward underscores. Check the path row before using the generated name in a deployment environment.

A numeric-looking identifier

build.code=00127 is inferred as a number unless it is quoted for conversion review. If leading zeroes matter, use quotes in the properties text and check Schema Map before copying JSON or YAML.

A file with only comments

Blank lines and lines that start with # or ! after whitespace are ignored. A file made only from those lines produces No properties detected; add a real key-value line before expecting output tabs to fill.

FAQ:

Does server.port become nested JSON?

No. The properties text is parsed as a flat key-value map, so server.port remains one key. Path Preview and env output may display a flattened review name, but that does not mean the original key was nested.

Why did a value become a number or boolean?

Unquoted true, false, and simple decimal numbers are inferred as typed values for converted output. Quote values that must remain string-like, especially identifiers with leading zeroes.

What does a duplicate-key warning mean?

The same decoded key appeared more than once. The later value replaced the earlier value in the final JSON, YAML, INI, env, properties, path, and schema output.

Why is the visible path table shorter than my file?

The on-page table respects Path preview limit so large inputs stay readable. Increase the limit up to the allowed maximum when you need more rows on screen, or use the table export for the full path set.

Can I replace my original file with Properties Output?

Treat it as normalized review text, not a guaranteed round trip. It can change comments, spacing, separators, and path spelling, so test it in the destination application before replacing a working file.

Is pasted configuration sent to a server?

The parsing and conversion run in the browser for pasted text and selected files. Secrets still need care because they may remain visible on screen, in the clipboard, or in downloaded files.

Glossary:

Natural line
One physical line in the text stream.
Logical line
The complete key-value line after any continued lines have been joined.
Scalar value
A single non-object value such as text, a number, a boolean, null, or an empty string.
Path Preview
The flattened list of paths, inferred types, and shortened value previews.
Schema Map
A grouped view of paths, observed types, document counts, and example values.
Env prefix
Optional text added before generated environment-style names.

References: