Deep-Merge Multiple JSON Configuration Files

The classic reason to deep-merge instead of spreading: the production override only changes the DB host, but a shallow spread would wipe out port and pool. Deep merge folds the db object key-by-key.

Input 1 (config.base.json):
{ "db": { "host": "localhost", "port": 5432, "pool": 10 }, "debug": true }

Input 2 (config.production.json):
{ "db": { "host": "prod.internal" }, "debug": false }

Strategy: Deep merge

Output (merged.json):
{
  "db": {
    "host": "prod.internal",
    "port": 5432,
    "pool": 10
  },
  "debug": false
}

Same two inputs as above, but with the Shallow strategy. Shallow replaces the whole db object with the override's version, so port and pool vanish. This is the bug deep merge exists to prevent — useful to see side by side.

Input 1: { "db": { "host": "localhost", "port": 5432, "pool": 10 }, "debug": true }
Input 2: { "db": { "host": "prod.internal" }, "debug": false }

Strategy: Shallow

Output:
{
  "db": { "host": "prod.internal" },
  "debug": false
}
→ port and pool are GONE. Use Deep merge to keep them.

Add a third input for a developer's local override. Inputs fold left-to-right, so the local file (Input 3) wins, then env (Input 2), then base (Input 1). Requires Pro for >2 inputs, or the orchestrator path.

Input 1 (base):  { "log": { "level": "info" }, "port": 3000 }
Input 2 (env):   { "log": { "level": "warn" } }
Input 3 (local): { "log": { "json": true }, "port": 8080 }

Strategy: Deep merge

Output:
{
  "log": { "level": "warn", "json": true },
  "port": 8080
}
→ level from env, json from local, port from local.

When a config section is a list that should grow across layers — enabled plugins, IP allowlists — Deep merge would replace the array. Array append concatenates instead.

Input 1: { "plugins": ["core", "auth"] }
Input 2: { "plugins": ["metrics"] }

Strategy: Deep merge → { "plugins": ["metrics"] }  (replaced)
Strategy: Array append → { "plugins": ["core", "auth", "metrics"] }

Note: array-append does NOT deep-merge nested objects —
objects are replaced last-wins in this mode.

Sometimes you want the base to be authoritative and a secondary file only to supply keys the base is missing. First wins keeps every key already present and only adds new ones.

Input 1 (authoritative): { "region": "us-east-1", "retries": 3 }
Input 2 (fallback):      { "region": "eu-west-1", "timeout": 30 }

Strategy: First wins

Output:
{
  "region": "us-east-1",
  "retries": 3,
  "timeout": 30
}
→ region NOT overridden; timeout added.

In the default deep strategy, when both sides have an array at the same key, the later array replaces the earlier one — they are not concatenated or merged element-by-element. If you expected ["a"] + ["b"] to become ["a","b"], switch to the Array append strategy. This is the single most common surprise with config merges, so verify array-valued keys after merging.

Each input is parsed with JSON.parse after trimming. A trailing comma, a comment, a single-quoted string, or an unquoted key throws and the merge stops with the parser's message. JSON has no comments, so strip // lines from any config.jsonc-style file first. To repair common syntax slips automatically, run the source through the json-format-fixer before merging.

The tool needs at least 2 inputs that contain text after trimming. Empty textareas are ignored. If you only have one config object and just want to pretty-print or validate it, use the json-prettifier or json-validator instead.

The free tier merges 2 inputs; Pro raises the cap to 10. Adding a third input on free shows an upgrade prompt rather than merging. For a base/env/local three-layer merge you need Pro, or you can merge base+env first, copy the result, and paste it back as Input 1 with local as Input 2.

Each input is limited to 2 MB on the free tier; an oversized input triggers an upgrade prompt before merging. Config files are usually far smaller than this, so hitting the limit often means you pasted an entire data dump rather than a config object — double-check the input.

The merger treats every input as an object and iterates its keys. A top-level JSON array ([1,2,3]) has numeric keys 0,1,2, so two arrays merge by index (position 0 with position 0, etc.) rather than concatenating. For combining JSON arrays as data records, this tool is the wrong fit — config files are objects. Confirm your top level is { ... }.

null is a primitive here. If the base has { "proxy": { "url": "..." } } and the override has { "proxy": null }, the override's null replaces the whole object (object-vs-null is a type mismatch, so it takes the last-wins branch). To strip nulls from the result afterward, use the json-null-stripper.

If one input object literally contains the same key twice, JSON.parse keeps the last occurrence (standard JS behaviour) before merging even begins. This happens before any strategy applies, so the merger never sees the earlier value. Clean duplicate keys in the source file if both mattered.

The web tool pretty-prints the merged result at 2-space indentation with no UI control to change it. If you need tabs, 4-space indent, or minified output, run the merged JSON through the json-prettifier or json-minifier afterward.