JSON Diff
Compare JSON by ID, ignore noisy paths and export a strict JSON Patch when the comparison permits.
This tool runs entirely in your browser. Your data is never uploaded, never stored, and never leaves your device.
Compares two JSON documents semantically, with array matching by stable key, numeric tolerance and wildcard ignore paths so reorder, timestamps and harmless measurement noise do not bury the changes that matter.
How to use it
- 1Paste or load the original and changed .json documents, up to 2,000,000 characters each; parse errors identify the broken side.
- 2Choose arrays by position or by a key such as id, set a non-negative number tolerance, and enter exact or wildcard ignore paths where * matches one level and ** matches any depth.
- 3Compare, then filter by path/search text and added, removed or changed type; keyed-array fallbacks and truncation are reported rather than hidden.
- 4Copy or download the complete human diff report; switch to positional arrays, zero tolerance and no ignored paths when a machine-applicable RFC 6902 patch is required.
Example
- Input
- The built-in release examples, arrays matched by id, tolerance 0.01 and ignored path generatedAt
- Output
- 3 changes: added $.region = "ap-south-1"; changed $.release from "2026.09" to "2026.10"; changed $.services[id="worker"].replicas from 1 to 3
Reordering api and worker is ignored, generatedAt is excluded, and worker timeout 30 versus 30.001 is within tolerance. If array values do not all have unique usable keys, that array is compared by position and the fallback count makes this visible.
What happens to your data
This tool runs entirely in your browser. Your input is never uploaded to a server, never stored, and never logged. Documents are parsed with the native JSON engine and are not stored after navigation. Native parsing discards whitespace and key order, collapses duplicate object keys to the last value, and loses the original spelling of numbers. Each side is capped at 2,000,000 characters, 100,000 values and keys, and 200 nesting levels. Comparisons stop at 5,000 changes or 4 MB of report data, the screen renders the first 500 matches, and the downloaded report carries an explicit truncation flag.
Last updated September 2026
Compare JSON as parsed objects and arrays rather than as formatted text. The report lists added, removed, and changed paths, supports numeric tolerance and ignored paths, and can match object arrays by a stable key so simple reordering does not become a wall of false changes.
Both documents stay in your browser. Search and filter the findings, download the complete JSON report, or copy RFC 6902 JSON Patch when the selected comparison can be represented safely.
How it works
Each side is parsed with strict JSON rules, then walked structurally. Arrays can be compared by position or, by default, by an editable key such as id. Keyed matching is used only when every item is an object and the chosen key is present and unique; otherwise the tool reports a positional fallback. Each document is capped at 100,000 values and keys and 200 nesting levels so adversarial input cannot exhaust the tab.
Ignore patterns accept comma- or newline-separated paths. * matches one path segment and ** matches any depth; a leading $ is optional. An exact JSON Pointer beginning with / handles keys that themselves contain dots, brackets or slashes. Numeric tolerance treats two finite numbers as equal when their absolute difference is within the entered value.
A comparison records up to 5,000 changes or 4 MB of report data and renders the first 500 matching the current filters. RFC 6902 patch is available only for exact positional comparison with zero tolerance and no ignored paths; keyed array paths, tolerance, and ignored data cannot be expressed by that patch without changing meaning.
Common use cases
- Review API responses without formatting noise
- Compare configuration files while ignoring volatile fields
- Match reordered object arrays by a unique ID
- Apply a small tolerance to floating-point results
- Download a machine-readable change report
- Create an RFC 6902 patch for an exact positional diff
Frequently asked questions
How does array matching by key work?＋
Enter a field such as id. Keyed matching runs only when both arrays contain objects with a present, unique value for that field. If those conditions fail, the tool reports that it compared the array by position.
How do ignored JSON paths work?＋
List paths separated by commas or new lines. * matches one segment and ** matches any number of segments; you may include or omit the leading $. Review ignored patterns carefully because excluded changes will not appear.
What does numeric tolerance change?＋
Two finite numbers are treated as equal when their absolute difference is no greater than the entered tolerance. Types are still significant, so a JSON string containing a number is not equal to a numeric value.
Why is JSON Patch sometimes unavailable?＋
A standard array-index patch is emitted only for exact positional comparison with zero tolerance and no ignored paths. Key-based array paths and intentionally hidden or tolerated changes cannot be translated into an equivalent RFC 6902 patch honestly.
What happens with very large comparisons?＋
Each input is limited to 2,000,000 characters, 100,000 values and keys, and 200 nesting levels. The engine stops at 5,000 changes or 4 MB of report data, and the screen renders the first 500 matching changes. The truncation warning is explicit when either report limit is reached.
Will very large JSON integers compare exactly?＋
JavaScript parses JSON numbers using IEEE-754 number precision. Values beyond the safe integer range may already be rounded during parsing, so encode precision-critical identifiers or integers as strings.
Does the JSON comparison leave my browser?＋
No. Parsing, matching, filtering, patch creation, and report download run locally on the device.
Used in these workflows
Related tools
File Type Checker
Inspect recognized file signatures, extensions and browser MIME without opening or uploading the file.
Sitemap Validator
Inspect sitemap XML fields, dates, URLs and duplicates locally, without a live crawl.
UTM Builder
Build campaign URLs locally, preserve ordinary parameters and review UTM replacements before export.
Robots.txt Tester
Test pasted robots.txt rules locally against crawler tokens and paths, with winning lines and CSV export.