Generate JSON Patch
from JSON Diff

RFC 6902 patch operations in four steps

No account. No upload. No nonsense.

Related JSON tools

Common questions answered

What is JSON Patch (RFC 6902)?

JSON Patch is a standard (RFC 6902) for describing changes to a JSON document as a sequence of operations. Each operation specifies an action (add, remove, replace, move, copy, or test) and a JSON Pointer path. Patches are compact, explicit, and can be applied atomically — ideal for partial updates in REST APIs and synchronization protocols.

This tool generates a JSON Patch by comparing two inputs: original and modified. The output is an array of operations that, when applied to the original, produce the modified version. This is useful for APIs accepting PATCH requests, building audit logs of changes, and implementing optimistic concurrency control.

// Before
{"name":"Alice","age":30}

// After
{"name":"Alice","age":31,
 "title":"Senior"}

[
  {"op":"replace",
   "path":"/age",
   "value":31},
  {"op":"add",
   "path":"/title",
   "value":"Senior"}
]

Get the most out of this tool

• Use JSON Patch for API endpoints that update partial resources — it is more efficient than sending the entire object.
• The "test" operation verifies a field value before applying changes — use it for optimistic concurrency control.
• JSON Patch operations are applied in order — the sequence matters when operations depend on previous changes.

RFC 6902 JSON Patch explained

JSON Patch (RFC 6902) is a format for expressing a sequence of operations to be applied to a JSON document to transform it from one state to another. Rather than sending a complete replacement document, a JSON Patch contains only the changes — making it ideal for REST API PATCH operations, collaborative editing systems, and change auditing. The format is widely supported by HTTP clients, JSON processing libraries, and API gateways.

A JSON Patch document is a JSON array of operation objects. Each operation object has an "op" field specifying the operation type and a "path" field specifying the target location using JSON Pointer (RFC 6901) syntax. The six operations are: "add" (adds a value at a path), "remove" (removes a value at a path), "replace" (replaces a value), "move" (moves a value from one path to another), "copy" (copies a value from one path to another), and "test" (tests that a value equals an expected value).

JSON Pointer is the addressing syntax used by JSON Patch. A JSON Pointer is a string starting with "/" and then listing path segments separated by slashes. For example, "/address/city" refers to the "city" field inside the "address" object. For arrays, the index is used: "/items/0" refers to the first element. The special token "-" refers to the element after the last element of an array, used with "add" to append. Slashes and tildes in key names are encoded as "~1" and "~0".

The JSON Patch generator compares two JSON documents and produces the minimal set of patch operations that transforms the first (original) into the second (target). "Minimal" means using "move" instead of "remove" + "add" when a value moves between paths, and "replace" instead of "remove" + "add" when only the value changes. A minimal patch is smaller and more semantically meaningful — it communicates intent, not just mechanics.

The "test" operation is unique among JSON Patch operations — it does not modify the document but asserts that a value at a given path equals an expected value. If the test fails, the entire patch operation fails and no changes are applied. This enables optimistic concurrency control: include test operations at the beginning of a patch to verify the document has not changed since you last read it. If another client modified the same field concurrently, your patch fails safely rather than silently overwriting their changes.

JSON Patch is more precise than JSON Merge Patch (RFC 7396) but more complex. Merge Patch is simpler — you send a partial document where null values delete keys. JSON Patch supports operations that Merge Patch cannot express: moving values, copying values, testing preconditions, and appending to arrays. For REST APIs, Merge Patch is easier to implement and use for simple updates; JSON Patch is better for complex operations and when you need atomic test-then-modify semantics.

When developers use this tool

Additional frequently asked questions