Sort JSON keys (when and why)

Sorting object keys alphabetically gives every JSON document a predictable shape. Two documents with the same data but keys in a different order become identical after sorting, which makes comparisons, code reviews and version-controlled files much easier to work with. This guide explains what sorting changes, how to do it, and when to avoid it.

What sorting changes, and what it doesn't

• Changes: the order of keys inside every object, at every nesting level.
• Doesn't change: values, strings, numbers, booleans, null, and the order of items in arrays.

According to the JSON specification, objects are unordered collections of name/value pairs, so a standards-compliant consumer treats the sorted and unsorted versions as the same data.

Example

Before:

json
{"z":1,"a":2,"b":{"y":1,"x":2}}

After sorting (formatted for readability):

json
{
  "a": 2,
  "b": {
    "x": 2,
    "y": 1
  },
  "z": 1
}

Notice that the nested object under "b" was sorted too.

How to sort keys

In the browser: paste the JSON into the JSON Formatter and use the Sort button in the editor toolbar. You can sort the whole document and choose ascending or descending order.

With jq: the -S flag sorts keys recursively.

bash
jq -S . input.json > sorted.json

In Python:

python
import json
print(json.dumps(data, indent=2, sort_keys=True))

In JavaScript, JSON.stringify has no built-in option, so sort recursively:

javascript
function sortKeys(value) {
  if (Array.isArray(value)) return value.map(sortKeys);
  if (value && typeof value === 'object') {
    return Object.fromEntries(
      Object.keys(value).sort().map(k => [k, sortKeys(value[k])])
    );
  }
  return value;
}
const sorted = JSON.stringify(sortKeys(data), null, 2);

The function maps over arrays instead of sorting them, so array order is preserved.

When sorting helps

• Comparing two responses. If one service returns {"id":1,"name":"a"} and another returns {"name":"a","id":1}, a text diff shows every line as changed. Sort both first, then compare the two JSON files.
• Configuration and fixture files in Git. When every file is sorted the same way, a pull request only shows real changes.
• Snapshot tests. Sorting keys before saving a snapshot avoids flaky failures caused by object key ordering.
• Finding a field quickly in a large object with dozens of keys.

When to be careful

• Signed or hashed payloads. Signatures such as webhook HMACs are computed over the exact bytes. Re-serializing the body, even without reordering, can break verification. Verify against the raw body you received.
• Consumers that rely on order. A few tools treat key order as meaningful even though the spec says otherwise. Examples include some schema generators, OpenAPI documents where field order controls how docs are rendered, and code that reads the "first" key.
• Human-friendly ordering. A hand-written config often groups related keys (host next to port). Alphabetical sorting can make it harder to read, so consider sorting only for comparison and keeping the original file as it is.
• Arrays. Don't sort arrays unless you are certain their order carries no meaning. In most data, such as steps, events and ranked results, it does.

Sorting and duplicate keys

If an object contains the same key twice, most parsers keep only the last value. Sorting after parsing will therefore silently drop the earlier one. Duplicate keys are a bug worth fixing at the source; validate the document first with Validate JSON.