What does 'sort keys deep' do?

Recursively sorts every object's keys alphabetically. {"b": 1, "a": {"d": 4, "c": 3}} becomes {"a": {"c": 3, "d": 4}, "b": 1}. Arrays keep their original order — sorting array items requires the separate Sort arrays option.

Why isn't sort-arrays on by default?

Array order in JSON is meaningful — [1, 2, 3] is not the same value as [3, 1, 2] for many use cases (event logs, ordered preferences, render order). Sort arrays only when you know order is incidental to the value, not part of it.

How are arrays of objects sorted?

Specify a key path in the 'Object array sort key' field — e.g. id, name, createdAt. The tool sorts the array by that field's value. Missing fields sort as empty strings; mixed types compare via stringified JSON.

Is sorted JSON useful for diffs and hashes?

Yes — that's a primary use case. Two semantically identical JSON documents can have different key orders and produce different SHA-256 hashes or noisy line-by-line diffs. Sort both first to get a canonical form: identical hashes for identical values, clean structural diffs.

May 2, 20267 min read

JSON Sort Online: Sort Keys + Arrays (Free Guide)

Q: Is my JSON sent to a server?

No. Sorting runs entirely in your browser — safe for production payloads, internal exports, and anything containing PII or secrets.

Need a JSON sort online tool that handles deep keys and arrays? Here's how. Two JSON files contain the same data but the keys are in different orders. git diffshows the entire file as a change. The SHA-256 hashes differ. Snapshot tests fail. The data is identical — the serialization isn't. Sorting is how you fix this once and forever.

In this guide you'll learn how to sort JSON deeply with PDFFlare's JSON Sort tool — recursive key sort, optional array sort, case-insensitive comparisons, and how a canonical form makes diffs and hashes stable.

How to Use a JSON Sort Online Tool Effectively

The interactive tool above does most of the work. The rest of this guide covers patterns, edge cases, and production tips you'll want to keep in mind.

Why Sort JSON?

JSON keys aren't ordered semantically — most parsers preserve insertion order but the spec doesn't require it. Two semantically identical JSON values can have completely different key orders. Sorted JSON is a canonical form: identical values produce identical bytes, identical bytes produce identical hashes, and clean diffs only show real changes.

How to Sort JSON (Step by Step)

Open PDFFlare's JSON Sort tool.
Paste your JSON. Could be a config, a fixture, an export, or any document where you want predictable order.
Pick what to sort: keys (deep, recursive, default on); arrays of primitives (off by default — array order is data); arrays of objects by a key path (id, name, etc.).
Pick options: case-insensitive, asc/desc, indent.
Click Sort JSON. The result is deterministic: same input + same options → same output bytes.

Real Use Cases

Reproducible content hashes

Caching by JSON-content-hash requires a canonical form. Sort first, then hash — identical values produce identical keys.

Cleaner git diffs

Two JSON files with the same data but different orders show as full-file changes in git diff. Sort both first and only the real changes show up.

Snapshot tests

Jest, Vitest, and Insta-style snapshot tests get noisy when serialization order is non-deterministic. Sort before snapshotting for stable tests.

Reviewing config files

Sorted keys are easier to scan in a 100-key config. Especially for new contributors: alphabetical order means they don't have to know the project's convention.

Common Mistakes (and How to Avoid Them)

Sorting arrays where order is data.Event logs, ordered preferences, and render order all rely on array order. Don't turn on Sort arrays unless you're sure order is incidental.
Forgetting to sort both sides of a diff. Sort both files before comparing — sorting only one creates more noise than it removes.
Mixing sort orders across teams.If everyone on the team uses sorted JSON, the canonical form sticks. If half the team doesn't, you get the worst of both worlds. Document the convention in CONTRIBUTING.md.
Using sorted JSON as a security measure. Sorted JSON is a canonical-form trick, not a hashing protocol. For HMAC over JSON, follow a real spec (e.g. JCS — RFC 8785) or use a binary serialization.

Privacy: Your JSON Stays Local

Sorting runs in your browser. Safe for production payloads, internal exports, anything containing PII or secrets.

Related Workflows in the JSON Suite

Adjacent tools you might find useful while working on the same JSON document: the JSON Diff and JSON Formatter both pair well with the conversion above. The first handles a different output format that consumers of your data may prefer; the second covers the validation side of the same workflow.

Related Tools

JSON Diff — pair with sort for clean structural diffs.
JSON Formatter — consistent indent on top of sorted keys.
JSON Stats — count keys, depth, and types of the sorted document.
JSON Duplicate Keys — catch silent dupes before sorting hides them.

Sort Order and Reproducibility in Practice

Deterministic sort matters most where reproducibility matters most: tests, hashes, signatures, and any artifact that downstream systems will compare for equality. In all of these contexts, two semantically identical JSON documents must produce identical bytes, or comparison fails for spurious reasons. Sort gives you that determinism for free, but only if you use it consistently and sort by a rule that everyone agrees on.

For tests, sorting before snapshotting eliminates the single most common source of flaky test failures. A serialization library that emits keys in a hash-table order might produce different orderings on different versions of the runtime. Tests that compare snapshots start failing on environment changes that have nothing to do with the code. Sort the actual output and the expected snapshot before comparing, and the test becomes robust to any ordering changes upstream. This single discipline eliminates whole classes of CI flakiness.

For cryptographic hashes and signatures, the requirement is even stronger: hashing or signing JSON requires a canonical form. Without canonicalization, the same data can hash to different values in different contexts, and signature verification fails. There is a formal specification for canonical JSON (JCS, RFC 8785) that defines exactly which sort order and which formatting to use; for less rigorous needs, a simple deep alphabetical sort with stable encoding works for most production applications. Pick a rule, document it, and apply it uniformly across writers and readers.

For human-facing artifacts like config files in version control, sorting also pays dividends. A config file with consistently-sorted keys produces clean diffs when someone makes a small change. A config file with unpredictable ordering can produce a diff that touches every line, masking the actual change inside cosmetic churn. Sort once at write time, and reviews become easy. This habit is small but compounds enormously over the life of a long-lived repository.

Production Patterns for Sorting JSON

A sorted JSON document is a different beast than the original — a few patterns matter:

Canonical Form for Diffs and Hashes

The killer use case for deep sorting: hash a document or diff two documents reliably. Two semantically equivalent JSON documents can differ in serialization ({a:1, b:2} vs {b:2, a:1}). Sort both first; identical inputs hash and diff identically.

Stable Sort for Mixed Types

Sorting an array of mixed-type values (numbers and strings) isn't universally defined. Pick a rule (numbers before strings, or string-coerce everything) and apply consistently. PDFFlare's tool puts numbers first, then strings — matches V8's default comparator.

Don't Sort What Has Semantic Order

A JSON array representing a queue, a sequence of events, or ordered steps SHOULDN'T be sorted. Only sort when element order is incidental (a list of users, a set of configs). Mistakenly sorting a sequence breaks the program that depends on it.

When to Use a Different Approach

Sorting isn't always what you want:

For comparing two JSONs structurally, use JSON Diff — smarter than a sort + textual diff.
For pretty-printing only, use JSON Formatter — preserves order, just adds whitespace.
For deduplicating arrays, sort + dedupe with downstream code (new Set(arr) in JS, etc.).

Common Mistakes to Avoid

Assuming JavaScript object iteration is sorted. Modern JS engines iterate object keys in insertion order, NOT alphabetical. Use the sort tool to normalize before relying on iteration order.
Using locale-dependent sort. Default string sort can be locale-sensitive in some environments. Stick with ASCII-bit-comparison sort for canonical forms; switch to Intl.Collator only when sorting human-readable content for display.
Mixing case-sensitive and case-insensitive sort in the same pipeline. Inconsistency causes spurious diffs. Pick one and document it.
Sorting deeply when you only need shallow. If you're sorting for pretty output, deep sort makes the document hard to read (related fields scattered). Use shallow sort for display, deep sort for hashing.
Re-sorting on every read. If you control the writer, sort once on write. Sorting on read is wasted CPU when the document is read more than written.

Real-World Use Cases

Git commits with stable JSON files. Sort keys before saving so the diff is meaningful even if the in-memory order shifted.
Cache keys. Hash a sorted version of the request body so two equivalent requests share a cache entry.
Snapshot tests. Sort the actual output and the expected snapshot before comparing — eliminates spurious test failures from non-deterministic output.
API response normalization. Some clients care about key order (XML-ish parsers, very old code). Sort before sending to a stable canonical form.

Polishing the Generator's Output

Sorting JSON deterministically is one of those operations that seems trivial until you encounter the edge cases. Whatever your specific use case, treat the generated output as a draft that deserves a careful read-through. Generators are excellent at producing the mechanical structure of an artifact and not at the editorial decisions that make the difference between something a colleague will tolerate and something a colleague will appreciate. Read every section of the output the way you would read a piece of writing you were proofreading for a friend. Look for inconsistent naming, missed opportunities to consolidate similar items, and places where the structure is mechanically correct but conceptually awkward. The five minutes spent on this review are the difference between an artifact that pays back over months and one that needs a second pass before it can be used. The generator handles the heavy lifting; you handle the polish that turns a draft into a deliverable. This division of labor is what makes generated code worthwhile in the first place. Without that final pass of human editorial judgment, the generator's output is merely fast rather than valuable, and the value matters more than the speed in nearly every real production setting.

Wrapping Up

Canonical JSON is one click away with PDFFlare's JSON Sort tool. Use it before hashing, diffing, or snapshotting — and never again chase a phantom diff caused by key order.