How to merge 2 JSON objects from 2 files using jq?

Use jq -s add:

$ echo '{"a":"foo","b":"bar"} {"c":"baz","a":0}' | jq -s add { "a": 0, "b": "bar", "c": "baz" } 

This reads all JSON texts from stdin into an array (jq -s does that) then it "reduces" them.

(add is defined as def add: reduce .[] as $x (null; . + $x);, which iterates over the input array's/object's values and adds them. Object addition == merge.)

Here's a version that works recursively (using *) on an arbitrary number of objects:

echo '{"A": {"a": 1}}' '{"A": {"b": 2}}' '{"B": 3}' |\ jq --slurp 'reduce .[] as $item ({}; . * $item)' { "A": { "a": 1, "b": 2 }, "B": 3 } 

Who knows if you still need it, but here is the solution.

Once you get to the --slurp option, it's easy!

--slurp/-s: Instead of running the filter for each JSON object in the input, read the entire input stream into a large array and run the filter just once. 

Then the + operator will do what you want:

jq -s '.[0] + .[1]' config.json config-user.json 

(Note: if you want to merge inner objects instead of just overwriting the left file ones with the right file ones, you will need to do it manually)

No solution or comment given so far considers using input to access the second file. Employing it would render unnecessary the buildup of an additional structure to extract from, such as the all-embracing array when using the --slurp (or -s) option, which features in almost all of the other approaches.

To merge two files on top level, simply add the second file from input to the first in . using +:

jq '. + input' file1.json file2.json 

To merge two files recursively on all levels, do the same using * as operator instead:

jq '. * input' file1.json file2.json 

That said, to recursively merge your two files, with both objects reduced to their value field, filter them first using {value}:

jq '{value} * (input | {value})' file1.json file2.json 

{ "value": { "aaa": { "value1": "v1", "value2": "v2", "value3": "v3", "value4": 4 }, "bbb": { "value1": "v1", "value2": "v2", "value3": "v3" }, "ccc": { "value1": "v1", "value2": "v2" }, "ddd": { "value3": "v3", "value4": 4 } } } 

Demo

Note that a solution which reduces only after the merge, like . * input | {value} would, is shorter in code but resurrects the "buildup of an additional structure to extract from" futility again, which may produce a lot of overhead if the parts eventually cut off get big.

In order to operate on more than two files, either accordingly use input multiple times, or programmatically iterate over all of them using inputs instead, as in

jq 'reduce inputs as $i (.; . * $i)' file*.json 

Note that in either case the first file is always accessed via the input context . while input(s) only addresses the remaining files, i.e. starting from the second (unless, of course, the --null-input or -n option is given).

This can be used to merge any number of files specified on the command:

jq -rs 'reduce .[] as $item ({}; . * $item)' file1.json file2.json file3.json ... file10.json

or this for any number of files

jq -rs 'reduce .[] as $item ({}; . * $item)' ./*.json

First, {"value": .value} can be abbreviated to just {value}.

Second, the --argfile option (available in jq 1.4 and jq 1.5) may be of interest as it avoids having to use the --slurp option.

Putting these together, the two objects in the two files can be combined in the specified way as follows:

$ jq -n --argfile o1 file1 --argfile o2 file2 '$o1 * $o2 | {value}' 

The '-n' flag tells jq not to read from stdin, since inputs are coming from the --argfile options here.

Note on --argfile

The jq manual deprecates --argfile because its semantics are non-trivial: if the specified input file contains exactly one JSON entity, then that entity is read as is; otherwise, the items in the stream are wrapped in an array.

If you are uncomfortable using --argfile, there are several alternatives you may wish to consider. In doing so, be assured that using --slurpfile does not incur the inefficiencies of the -s command-line option when the latter is used with multiple files.

I didn't want to discard previous non-unique key in my objects

jq -n '{a:1, c:2}, {b:3, d:4}, {a:5,d:6}' | jq -s 'map(to_entries)|flatten|group_by(.key)|map({(.[0].key):map(.value)|add})|add' { "a": 6, "b": 3, "c": 2, "d": 10 } 

or alternatively if you wanted to just keep an array of the values, remove the add after the extraction of the value map(.value)|̶a̶d̶d̶

jq -n '{a:1, c:2}, {b:3, d:4}, {a:5,d:6}' | jq -s 'map(to_entries)|flatten|group_by(.key)|map({(.[0].key):map(.value)})|add' { "a": [1, 5], "b": [3], "c": [2], "d": [4, 6] } 

Try removing each part of the command and see how each step modifies the array of objects... aka run these steps and see how the output changes

map(to_entries) map(to_entries)|flatten map(to_entries)|flatten|group_by(.key) map(to_entries)|flatten|group_by(.key)|map({(.[0].key):map(.value)}) map(to_entries)|flatten|group_by(.key)|map({(.[0].key):map(.value)})|add 

Merging two JSONL files line by line

I came across this closely related use case which may be of interest to Googlers, suppose you have:

in1.jsonl

{"a":1, "b":2} {"a":3, "b":4} 

in2.jsonl

{"c":5, "d":6} {"c":7, "d":8} 

and you want:

{"a":1, "b":2, "c":5, "d":6} {"a":3, "b":4, "c":7, "d":8} 

I've managed to do that with:

paste in1.jsonl in2.jsonl | jq '. * input' 

The way this works is that first it pastes the two JSONL into a weird JSONL-like format:

{"a":1,"b":2} {"c":5,"d":6} {"a":3,"b":4} {"c":7,"d":8} 

but jq doesn't care and treats that like JSONL. Then input pulls the next JSON out ahead of time, and then we merge the current one . with the next one from input with *.

Unfortunately I couldn't get rid of the paste and do it in pure jq, but it's not too bad.

Tested on jq 1.7, Ubuntu 25.04.