JSON Sorter Online - Alphabetize JSON Keys for stable Git Diffs
Updated
Alphabetize JSON keys to make Git diffs stable and meaningful. Fix unstable diffs in package.json and locale files—100% client-side, your code never leaves your browser.
Key Features
- ✅ Alphabetical key sorting
- ✅ Recursive sorting
- ✅ Stable Git diffs
- ✅ Data integrity preservation
- ✅ Client-side only
How to Use
- Accept JSON input via textarea or file upload
- Parse JSON using JSON.parse()
- Recursively traverse and sort object keys alphabetically at every nesting level
- By default, preserve array order; an optional "sort by value" mode can reorder arrays by a chosen key path
- Preserve value types and data integrity
- Output sorted JSON with consistent indentation
- All logic is client-side; no data leaves the browser
- Support case-sensitive vs locale-aware sort modes
Expert FAQ
- Does this actually change the meaning of my JSON, given that JSON object key order isn't guaranteed anyway?
No — the JSON spec doesn't define object key order as meaningful, so any conforming consumer treats {"a":1,"b":2} and {"b":2,"a":1} identically. Sorting is purely for the humans and diff tools reading the source text, not for anything a JSON parser cares about; the practical exception is code relying on JS engines' de-facto insertion-order iteration, which sorting will change the iteration order of even though it doesn't change the data's meaning. - Why leave arrays unsorted specifically?
By default, sorting only reorders object keys and leaves array element order untouched, since array order is often semantically meaningful. However, this tool also offers a "sort by value" mode with a key path — when enabled, it WILL reorder array elements by the value at that path, so if you turn that mode on, be aware you're making a real data change to any arrays involved, not just a cosmetic one. - Does it sort case-sensitively — does "Zebra" come before or after "apple"?
By default it sorts case-insensitively (both keys are lowercased before comparing), so "apple" sorts before "Zebra" — matching human alphabetical order out of the box. A case-sensitive mode is available if you specifically want strict ASCII byte-value ordering instead. - Will this break a JSON Schema or API contract that depends on key order?
It shouldn't, if the schema/contract is spec-compliant — object key order isn't part of JSON Schema's validation model. If some downstream system does depend on literal key order (a genuinely non-compliant but real-world scenario, sometimes seen in hand-rolled parsers or certain legacy XML-derived JSON), sorting would break that dependency, since it's relying on behavior the JSON spec never guaranteed in the first place.
Technical Details
Unsorted, inconsistently-ordered JSON keys in package.json, locale/translation files, or generated configuration create noisy Git diffs: two developers adding keys in different orders produce a diff dominated by reordering rather than the actual content change, and merges become harder to review than they should be. Since the JSON specification never defines object key order as semantically meaningful — any conforming parser treats differently-ordered-but-otherwise-identical objects as equal — alphabetizing keys is a purely cosmetic, meaning-preserving transformation from the spec's point of view, even though it does change iteration order for code that happens to rely on JavaScript engines' de-facto insertion-order behavior. By default, array contents are not reordered, because array element order is part of JSON's actual data model and is very often meaningful. This is only the default, though: a "sort by value" mode with a key path is also offered, and when it's used, arrays ARE reordered by the value found at that path — so this boundary can be crossed deliberately, not just respected automatically. String comparison for sorting defaults to case-insensitive comparison (both sides are lowercased before comparing), which already matches intuitive human alphabetical order for translation keys and similar files; a case-sensitive, strict-ASCII-order mode is available as an option if byte-order sorting is specifically what you need. After sorting, the JSON Compare tool produces a genuinely clean diff against a previous version, since key-order noise is eliminated before comparison, and JSON Pretty Print can improve on-screen readability further.