When working with APIs, JSON responses can change as an application evolves. A field might be added, a value might change, or a property might disappear, and spotting those differences manually isn’t always easy.

DevScribe’s JSON Editor lets you place two JSON payloads side by side and compare them using Diff Mode. You can also format, organize, and inspect JSON directly in the same workspace.

In this guide, we’ll compare two API-style responses and see how DevScribe helps you quickly identify what changed.

Working With JSON Responses

Open the JSON tool in DevScribe and create or open a JSON resource.

The editor provides two panels:

• Original JSON: the first version of the payload
• Modified JSON: the version you want to compare it with

Having both versions visible at the same time makes it easier to work with changes without switching between files, windows, or tools.

For our example, we’ll start with a user response:

{
  "user": {
    "id": 101,
    "name": "Aarav Mehta",
    "email": "aarav@example.com",
    "role": "developer",
    "active": true
  },
  "preferences": {
    "theme": "dark",
    "notifications": true
  }
}

Now we’ll use a modified version of the same response:

{
  "user": {
    "id": 101,
    "name": "Aarav Mehta",
    "email": "aarav.mehta@example.com",
    "role": "developer",
    "active": true,
    "verified": true
  },
  "preferences": {
    "theme": "light",
    "notifications": true
  }
}

The modified response contains three changes: the email address has been updated, a verified field has been added, and the preferred theme has changed.

Formatting JSON

JSON isn’t always returned in a format that’s easy to read. API responses can be minified, inconsistently formatted, or difficult to scan when they’re deeply nested.

DevScribe provides Beautify to format JSON with readable indentation.

You can also use Minify when you need a compact version of a payload, or Sort Keys to organize object keys consistently.

These are small utilities, but they make a difference when you’re working with large JSON responses or preparing two payloads for comparison.

Comparing JSON with Diff Mode

Once both versions are ready, select Diff Mode.

DevScribe compares the Original JSON and Modified JSON and highlights the differences between them.

In our example, we can immediately identify:

• The email value changed from aarav@example.com to aarav.mehta@example.com.
• A new verified property was added.
• The theme value changed from dark to light.

Instead of manually scanning both responses line by line, the comparison makes the changes visible in context.

Why Compare JSON Responses?

Comparing JSON is particularly useful when an API response changes over time.

For example, you might want to compare:

• An API response before and after a backend change
• Two versions of the same endpoint
• An expected response against an actual response
• Responses from development and production environments
• Payloads captured while debugging an integration

For a small response, manually checking the differences might be manageable. As the payload grows, however, even a few changed fields can be difficult to spot.

A visual diff gives you a much faster way to identify those changes.

From API Testing to JSON Comparison

The JSON Editor also fits naturally into the API workflow in DevScribe.

You can use the API Doc Tool to test an endpoint and inspect its response. If you need to investigate how that response differs from another version, you can bring the JSON into the JSON Editor and compare the two payloads.

The workflow becomes:

Test API

Get Response

Compare JSON

Identify Changes

The tools don’t have to exist as separate steps in your development process. You can move from testing an API to inspecting its response without leaving your DevScribe workspace.

More Than Just Comparison

Diff Mode may be the focus of this workflow, but the JSON Editor also gives you tools for working with JSON before and after the comparison.

Beautify

Format JSON into a readable, structured layout.

Minify

Convert formatted JSON into a compact representation.

Sort Keys

Arrange object keys consistently, which can make large payloads easier to inspect and compare.

Together, these tools cover some of the small but repetitive tasks that come up when working with JSON.

When Would You Use It?

The JSON Editor is useful whenever you’re dealing with JSON that needs to be checked, cleaned up, or compared.

Common examples include:

• Debugging API responses
• Reviewing changes to an API payload
• Comparing responses across environments
• Checking whether a backend change affected the response structure
• Working with large or deeply nested JSON
• Preparing JSON for technical documentation

Spot the Change, Not the Entire Payload

You don’t always need to understand every line of a JSON response.

Sometimes you just need to answer one question:

What changed?

With DevScribe’s JSON Editor and Diff Mode, you can put the two responses side by side and let the differences stand out.

Less time comparing payloads. More time figuring out what the change actually means.