.json files. Supports deep merge (nested objects recursed level by level), shallow merge and array concatenation. When keys collide you pick which side wins, and the page lists every single field that got overwritten. Everything runs locally in your browser; no data is uploaded.You can also click this area to pick files — each file becomes one input block below
Shallow merge only looks at top-level keys: when both documents have the same top-level key, the later one replaces the earlier one wholesale, even if its value is an object twenty levels deep. Deep merge keeps descending as long as both sides are objects, and only overwrites the leaf that genuinely conflicts. Config files almost always want a deep merge — take a set of defaults plus a three-line environment override, and a shallow merge wipes out every other key in that same group, which is exactly where "I changed one line and the whole block disappeared" comes from. Conversely, if the two documents are peer records to begin with, shallow merge is faster and easier to predict.
Because merging by index is almost always wrong. An array index is not an identity: merging ["a","b","c"] and ["x"] by position gives you ["x","b","c"], which is essentially never what anyone wanted — whoever supplied ["x"] probably meant "this one item is the whole list." JSON Merge Patch (RFC 7386) says the same thing: an array is handled as one whole value, never merged element by element. So this page defaults to "later one wins" while still offering "concatenate" and "concatenate, then dedupe", because stitching a few lists together really is another common need — it just is not the same job as overriding config, so you have to pick once.
This is where merging goes wrong most often. {"a": null} could mean "set a to empty" or "leave a alone", and JSON itself never says which. RFC 7386 treats null as a delete instruction, while most "deep merge" libraries treat it as an ordinary value and overwrite as usual. Both are defensible; the mistake is leaving the default unstated. This page defaults to not letting null overwrite an existing value, because in config merging that is closer to what people mean. When you do want null to clear a field explicitly, tick "Let null overwrite an existing value".
The error a merge tool reports is often not a merge problem at all — one of the inputs simply does not parse: a trailing comma, single quotes, comments carried over from source code. This page marks the parse result and error position under each input block separately, so fix the red one before merging. If an input is long and you need to see its structure or jump to a specific line, opening it in JSON Formatter Online and expanding the tree beats counting brackets in a textarea.
Drop both .json files into the dashed box above; each becomes its own input block, then click "Merge". You can also paste the contents straight into two textareas. Merging goes top to bottom, so whichever block sits lower has the final say on a conflict.
Yes, as many as you like. Click "Add a JSON block" for another textarea, or drop several files at once. Merging happens pairwise in order: the result of block 1 and block 2 is then merged with block 3, and so on — equivalent to layering overrides in sequence.
By default "later overwrites earlier", so the block further down wins — which matches the usual "defaults plus environment override" pattern. You can switch to "earlier one is kept", in which case only keys that had not appeared before get filled in. Either way, every overwritten field is listed one by one above the result.
Not if you pick "deep merge". Deep merge keeps recursing while both sides are objects and only overwrites the leaf fields that actually conflict, leaving everything else intact. "Shallow merge" compares top-level keys only, so a top-level key with the same name is replaced wholesale — both behaviours are useful; see "How deep merge differs from shallow merge" above.
Overwritten by default; change it under "Array fields" to "concatenate" or "concatenate, then dedupe". Deduplication compares by value, and objects and arrays are deduplicated too (identical content counts as a duplicate), not just strings and numbers. To join several JSON documents straight into one big array, the "array concat" mode at the top is more direct.
Not by default — this page treats null as "this item is not supplied" and skips it. It only overwrites once you tick "Let null overwrite an existing value". Both behaviours exist in different libraries, so this page makes it an explicit switch instead of picking one for you.
Each input block shows its own parse status and error position, so first see which one turned red. The usual causes are a trailing comma, single quotes, a // comment, or True, None, undefined and other literals that JSON does not accept, copied over from source code.
No. Reading files, parsing, merging and output all happen locally in the browser with JavaScript — this site has no backend that could receive the content. Merging live config, API responses or environment files containing secrets carries no risk of leaking them, and the page keeps working with the network disconnected.