How to Sort JSON: Object Keys and Arrays of Objects

Programs often write keys in whatever order they were created, so two runs of the same code can produce files that differ only in key order. Sorting the keys makes the output predictable, which keeps version-control diffs small and makes two files easy to compare.

{ "zip": "411001", "name": "Asha", "city": "Pune" }

{ "city": "Pune", "name": "Asha", "zip": "411001" }

jq -S . data.json                 # sorts keys at every level
python -c "import json,sys; print(json.dumps(json.load(sys.stdin), indent=2, sort_keys=True))" < data.json

// JSON.stringify has no built-in key sorting, so sort recursively
function sortKeys(value) {
  if (Array.isArray(value)) return value.map(sortKeys);
  if (value && typeof value === "object") {
    return Object.fromEntries(
      Object.keys(value).sort().map((key) => [key, sortKeys(value[key])])
    );
  }
  return value;
}

console.log(JSON.stringify(sortKeys(data), null, 2));

Take a list of people:

[
  { "first": "Rohan", "last": "Mehta", "age": 41 },
  { "first": "Asha",  "last": "Rao",   "age": 29 },
  { "first": "Meera", "last": "Mehta", "age": 35 }
]

jq 'sort_by(.age)' people.json                 # youngest first
jq 'sort_by(.age) | reverse' people.json       # oldest first
jq 'sort_by(.last, .first)' people.json        # by last name, then first name

const byAge = [...people].sort((a, b) => a.age - b.age);

// Text fields: localeCompare handles accents and case sensibly
const byName = [...people].sort(
  (a, b) => a.last.localeCompare(b.last) || a.first.localeCompare(b.first)
);

by_age = sorted(people, key=lambda p: p["age"], reverse=True)
by_name = sorted(people, key=lambda p: (p["last"], p["first"]))

Both JavaScript's Array.prototype.sort (since ES2019) and Python's sorted are stable: items that compare equal keep their original relative order. That is what makes multi-step sorting reliable. To sort by last name and then by age, you can sort by age first and then by last name.

• Numbers stored as strings sort as text. "10" comes before "9", because "1" is less than "9". Convert to numbers before comparing, or use localeCompare with the numeric: true option.
• Mixed types. Comparing a number with a string, or null with either, gives inconsistent results in some languages and an error in Python 3. Normalize the field first.
• Missing fields. Decide whether items without the field go first or last, and write the comparison for it explicitly.
• Case and accents. A plain string comparison puts all capital letters before lowercase ones, so "Zoe" comes before "adam". Use a locale-aware comparison for names.
• Dates. ISO 8601 strings in the same format and time zone sort correctly as plain text. Strings in other formats, such as 12/10/2026, do not. Parse them first.
• Order-sensitive arrays. Never sort an array whose order carries meaning, such as steps in a workflow, coordinates of a polygon or a priority list.

If you need the exact same bytes for the same data, for example to compute a hash or a signature, key sorting is part of the answer but not all of it. Whitespace, number formatting and string escaping can also differ between libraries. RFC 8785, the JSON Canonicalization Scheme (JCS), defines a precise, deterministic form for this purpose, and libraries implement it for most languages.

1. Format both files the same way.
2. Sort the object keys in both.
3. Leave arrays alone unless you know their order does not matter.
4. Then compare them with a text diff or a structural tool.

That sequence removes the noise that does not matter and leaves the real differences. See our guide to comparing two JSON files for more.