Compare

How to Compare JSON Files and Detect Changes

Find meaningful differences between JSON files, API responses, and config versions with a reusable Forge Json workflow.

2026-04-014 min read

JSON changes are easy to miss when files are large, nested, or reordered.

A small field update, removed key, or changed API value can break a workflow, but manually scanning two JSON files is slow and error-prone.

This guide shows how to compare JSON files and detect meaningful changes with a reusable Forge Json workflow.

This is a common pattern when you need to review API changes, compare config versions, audit payload updates, or understand what changed between two JSON snapshots.

💡 Tip

Paste both JSON versions into Forge Json and use a compare workflow to highlight added, removed, and changed fields.

This guide is for developers, API teams, and operators working with JSON configs, webhook payloads, exported data, or API responses.

When to Use This

This approach is a good fit if:

your JSON files look similar but may contain hidden changes
you need to review API response changes before deploying
you want a reusable way to compare configs, payloads, or snapshots

Before and After

Before: two JSON files look almost the same, but important values changed.

{
  "plan": "starter",
  "features": {
    "aiDraft": false,
    "history": true,
    "legacyExport": true
  },
  "limits": {
    "documents": 10
  }
}

{
  "plan": "pro",
  "features": {
    "aiDraft": true,
    "history": true,
    "apiAccess": true
  },
  "limits": {
    "documents": 100
  }
}

After: the changes are easier to review.

{
  "changed": [
    {
      "kind": "changed",
      "path": "plan",
      "before": "starter",
      "after": "pro"
    },
    {
      "kind": "changed",
      "path": "features.aiDraft",
      "before": false,
      "after": true
    },
    {
      "kind": "changed",
      "path": "limits.documents",
      "before": 10,
      "after": 100
    }
  ],
  "added": [
    {
      "kind": "added",
      "path": "features.apiAccess",
      "value": true
    }
  ],
  "removed": [
    {
      "kind": "removed",
      "path": "features.legacyExport",
      "value": true
    }
  ]
}

If you also need to merge JSON configs or clean messy API responses, the same pipeline approach can help you turn unreliable input into reusable output.

Why JSON Change Detection Gets Messy

JSON often comes from systems that change over time: APIs, internal tools, config files, webhook events, exports, and AI-generated output.

That becomes painful when you need:

a clear list of changed fields
a safe way to review config updates
before-and-after values for debugging
a predictable diff report you can share or reuse

Without a repeatable workflow, this often becomes manual inspection or one-off scripts that are hard to trust.

The raw JSON example below should show the same shape described in this article.

How to Fix It with Forge Json

Forge Json's JSON Diff / Change Report utility can compare two JSON inputs and produce a practical change report.

You can copy this directly:

{
  "mode": "report"
}

For this example, the workflow produces a short set of useful steps:

Read the old JSON and new JSON.
Compare fields by path instead of visual formatting.
Return added, removed, and changed entries in a reviewable report.

Result

You end up with:

changed
added
removed
dot paths such as features.aiDraft
before/after values for changed fields

If the report is too broad, switch to a narrower mode such as changed-only, added-only, or removed-only. Smaller reports are usually easier to review, explain, and reuse.

The support material below shows the new JSON, old JSON, report config, and final output.

This pattern works well for API reviews, config changes, webhook debugging, and JSON version checks.

Related JSON workflows:

Use the example panel below to open this sample input and generated workflow directly in the editor.

Support material

Practical example and product context

Use these examples to understand the transformation and apply the same workflow in your own JSON tasks.

Example Transformation

New JSON

1{
2  "plan": "pro",
3  "features": {
4    "aiDraft": true,
5    "history": true,
6    "apiAccess": true
7  },
8  "limits": {
9    "documents": 100
10  }
11}

Old JSON

1{
2  "plan": "starter",
3  "features": {
4    "aiDraft": false,
5    "history": true,
6    "legacyExport": true
7  },
8  "limits": {
9    "documents": 10
10  }
11}

Config

1{
2  "mode": "report"
3}

↓

Output

1{
2  "changed": [
3    {
4      "kind": "changed",
5      "path": "plan",
6      "before": "starter",
7      "after": "pro"
8    },
9    {
10      "kind": "changed",
11      "path": "features.aiDraft",
12      "before": false,
13      "after": true
14    },
15    {
16      "kind": "changed",
17      "path": "limits.documents",
18      "before": 10,
19      "after": 100
20    }
21  ],
22  "added": [
23    {
24      "kind": "added",
25      "path": "features.apiAccess",
26      "value": true
27    }
28  ],
29  "removed": [
30    {
31      "kind": "removed",
32      "path": "features.legacyExport",
33      "value": true
34    }
35  ]
36}