Compare two JSON objects side by side and export JSON Patch (RFC 6902) with JSON Pointer paths for add, replace, remove, move, copy, and test operations.
Paste the original JSON into the left editor panel.
Paste the modified JSON into the right editor panel.
Click Compare to see all differences highlighted by type — added (green), removed (red), and changed (yellow).
Enable Sort Keys to ignore key order differences.
Click Export JSON Patch to download an RFC 6902 patch file.
Recursively compares nested objects and arrays, showing differences at every depth level with collapsible sections.
Added values in green, removed in red, changed in yellow with old and new values shown side by side.
Export differences as a standards-compliant JSON Patch document for automated patching workflows.
Normalize key order before comparison to focus on value changes and ignore harmless reordering.
API responses, configuration files, and database exports often contain tokens, credentials, or personal data. Because this diff tool runs entirely in your browser, neither JSON document is ever transmitted to a server. There is zero risk of data interception, logging, or third-party retention. Compare production configs and API secrets with confidence.
Unlike text-based diff tools that compare line by line, this tool understands JSON structure. It recursively walks nested objects and arrays, reporting exactly which keys were added, removed, or changed at every depth level. This structural awareness means reordering keys or reformatting whitespace does not produce false positives.
Export differences as an RFC 6902 JSON Patch array — the industry standard for describing JSON mutations. JSON Patch documents can be applied programmatically in any language, making them ideal for CI/CD pipelines, database migrations, and configuration management systems where changes need to be replayed automatically.
Start comparing JSON the moment you open the page. There are no sign-up forms, no usage caps, and no file size restrictions. Whether you are diffing a 10-line config or a 50,000-line API response, the tool processes everything locally in your browser without pagination or truncation.
Comparing JSON documents is a fundamental task in modern software development. Every API change, configuration update, and database migration involves understanding what changed between two versions of a JSON structure. While simple text diffs can show line-level changes, they fail to capture the semantic meaning of modifications in structured data.
Traditional line-based diff tools (like Unix diff or Git's built-in diff) treat JSON as plain text. This creates several problems: reordering keys produces massive false-positive diffs, reformatting whitespace shows as changes, and structural modifications (adding a nested object vs. changing a value) are indistinguishable. A dedicated JSON diff tool parses both documents into their object representations and compares them structurally.
A proper JSON diff recursively walks both structures simultaneously. For objects, it identifies the union of all keys and classifies each as added (exists only in the new document), removed (exists only in the old), changed (exists in both but with different values), or unchanged. For arrays, comparison is performed by index — element 0 is compared to element 0, element 1 to element 1, and so on. Extra elements in either array are flagged as additions or removals.
JSON Patch (RFC 6902) is an IETF standard that defines a JSON format for expressing a sequence of operations to apply to a target JSON document. Operations include add, remove, replace, move, copy, and test. Paths use JSON Pointer syntax (RFC 6901), such as /users/0/name. JSON Patch is widely supported across programming languages and is used in REST APIs (via the PATCH HTTP method), configuration management, and database migration systems.
JSON objects are unordered by specification (RFC 8259). Two objects with identical key-value pairs but different key ordering are semantically equal. When comparing configs generated by different tools or serializers, key order differences produce noise in text diffs. Sorting keys before comparison eliminates this noise and focuses the diff on actual value changes. This is especially important for generated configuration files where key order depends on the serialization library.
Comparing arrays in JSON documents presents unique challenges because arrays are ordered collections. A simple index-based comparison works well for fixed-length arrays where each position has a defined meaning. However, when arrays represent sets of items (e.g., a list of users), an insertion at the beginning shifts every subsequent index, causing the diff to report every element as changed. More sophisticated algorithms address this by matching array elements using identity keys (such as an id field), similar to how React uses key props for list reconciliation. When using this tool, consider whether your arrays are positional (compare by index) or identity-based (where sorting or normalization before comparison produces cleaner results).
JSON diffing is most valuable when integrated into automated workflows. In code review, comparing the before-and-after state of JSON fixture files or configuration snapshots helps reviewers understand the impact of changes without reading raw file diffs. In CI/CD pipelines, generating a JSON Patch between environment configurations can serve as an audit log of deployment changes. Monitoring systems can diff periodic API response snapshots to detect schema drift or unexpected data changes in production. Some teams use JSON diff as part of contract testing — comparing actual API responses against expected baselines to catch regressions before they reach users.
In addition to RFC 6902 JSON Patch, there is a simpler alternative: RFC 7396 JSON Merge Patch. A merge patch is itself a JSON document where each key represents a change — present keys with non-null values indicate additions or modifications, and keys with null values indicate deletions. Merge patches are easier to read and construct but cannot express array modifications, moves, or tests. They are best suited for simple object-level changes where array manipulation is not needed. Understanding the difference between JSON Patch and JSON Merge Patch helps you choose the right format for your specific use case.
A structural diff answers the question, what changed? A JSON Patch document answers a different question: how do I replay the same change? During debugging, incident response, or code review, the human-readable diff view is usually the right first step because it groups changes visually and lets you inspect added, removed, and updated branches side by side. During automation, deployments, or contract testing, JSON Patch is often more useful because it turns those differences into a machine-readable instruction list that another system can apply or validate.
Consider a configuration update where one service endpoint is renamed, a timeout value is raised, and an obsolete feature flag is removed. The diff view helps a reviewer verify intent quickly. The RFC 6902 export then turns the same change into operations such as replace /services/api/baseUrl, replace /services/api/timeout, and remove /features/legacyFlag. In other words, the diff is for understanding, while the patch is for execution. Treating them as interchangeable is a common mistake that leads teams to pick the wrong artifact for the job.
Array handling is the hardest part of any JSON comparison workflow. If an array is purely positional, an index-based diff is correct: changing element 2 really does mean a change at index 2. But many production JSON documents use arrays to hold records identified by an internal key like id, name, or slug. In that case, reordering the array may produce a large noisy diff even when the logical set of records is the same. A practical mitigation is to normalize those arrays before comparison by sorting them on a stable field. If you cannot normalize upstream, at least interpret large array diffs carefully before concluding that dozens of records changed.
A JSON diff is a structural comparison between two JSON documents that identifies exactly which keys and values were added, removed, or changed. Unlike a text-based diff that compares lines, a JSON diff understands the hierarchical structure of objects and arrays, producing meaningful results even when keys are reordered or whitespace is reformatted.
Yes. Both JSON documents are processed entirely in your browser using JavaScript. No data is transmitted to any server, logged, or stored. This makes the tool safe for comparing API responses, configuration files, tokens, and any other sensitive JSON data.
JSON Patch is an IETF standard (RFC 6902) that defines a JSON format for describing changes to a JSON document. It uses operations like add, remove, and replace with JSON Pointer paths. The exported patch file can be applied programmatically in any language to reproduce the exact same changes.
Arrays are compared by index position. Element 0 in the original is compared to element 0 in the modified document, element 1 to element 1, and so on. If one array is longer, the extra elements are reported as additions or removals. This index-based approach works well for ordered data like API response arrays.
When enabled, Sort Keys normalizes the key order in both JSON documents before comparison. This eliminates false positives caused by different serialization orders. Two objects with identical key-value pairs but different key ordering will show no differences when Sort Keys is enabled.
Yes. There is no file size limit. Because processing runs entirely in your browser, the practical limit depends on your device's available memory. Most modern devices handle JSON documents of several megabytes without issues.
Green rows indicate values that were added in the modified document. Red rows indicate values that were removed from the original. Yellow rows show values that changed, displaying both the old and new values. Gray rows are unchanged. Nested objects and arrays can be expanded or collapsed to focus on specific sections.
Yes. The diff algorithm recursively compares objects and arrays at every nesting level. Differences in deeply nested structures are reported with their full path (e.g., $.users[0].address.city), making it easy to locate the exact change in complex documents.
Arrays are compared by index, so reordering elements will usually appear as a series of changes even if the same items are still present. If your array represents records with stable IDs rather than true ordered positions, sort or normalize the array first to reduce noise in the diff output.
A structural diff compares the tree shape and values that appear in the JSON document. A semantic diff adds domain-specific meaning on top, such as treating arrays as sets keyed by ID or ignoring fields like timestamps. This tool performs structural diffing, which is the most portable and standards-friendly baseline.
Yes. JSON object key order is not semantically significant. If you enable Sort Keys, the tool normalizes object ordering before comparison so two documents with the same values but different serialization order will compare cleanly.
Learn how to filter JSON arrays with JSONPath using equality, numeric comparisons, nested fields, existence checks, and real API examples.
Read more →Learn how to compare JSON objects effectively for API debugging, config management, and CI/CD pipelines. Covers deep diff, JSON Patch, and best practices.
Read more →Understand JSON Patch RFC 6902 fast: add inserts before array indexes, replace requires the target path to exist, and paths use JSON Pointer RFC 6901.
Read more →Practical JSON API best practices: response envelopes, naming conventions, error formats, pagination, versioning, security, and performance for REST APIs.
Read more →Complete guide to JSON syntax, data types, common parsing errors, and how JSON compares to YAML, XML, and other formats. With code examples.
Read more →