JSON diff tool for Mac: compare API responses locally

The short answer: use a local JSON diff to inspect two copied API responses, config objects, or token files before writing a review note. Label the old and new inputs, confirm both roots, inspect object paths and arrays separately, then verify the result with the contract that owns the data.

TeenyTool includes JSON Diff in its Mac menu bar toolbox. It parses pasted JSON locally and compares object or array roots. It is useful for a small manual review. It is not a schema validator, token resolver, API client, or automated test.

This distinction matters because a clean diff can still hide the wrong baseline, a semantically irrelevant array reorder, an unresolved token alias, or a payload that violates its destination contract.

Quick decision table

01Freeze the A and B identities before comparing

Write down what each side represents before you paste it: endpoint or file, environment, revision, capture time, and any normalization already applied. A precise diff against the wrong baseline is still the wrong result.

TeenyTool parses both sides with Apple's JSONSerialization. The parser accepts JSON fragments, but the comparison UI deliberately requires each root to be an object or array. An invalid side shows a parse error; a valid string, number, boolean, or null root shows a root-type error.

If the issue is syntax or presentation, use the offline JSON formatter for Mac first. Pretty mode sorts object keys, so do not describe that order change as a payload change. Keep the unformatted source beside the comparison when exact text or provenance matters.

02Read object paths before reading the summary

For two objects, TeenyTool takes the union of their keys, sorts those keys, and recurses only when both values at a key are dictionaries or both are arrays. Other values are serialized and compared as whole values. Rows are marked added, removed, changed, unchanged, or nested.

The header is deliberately shallow. Its added, removed, and changed numbers count only results at the current root. A changed value several levels down sits inside a nested result and does not increase the top-level changed count. The unchanged total is recursive, so the two totals do not describe scope in the same way.

Use the header as a navigation hint, not an acceptance metric. Open every relevant nested branch and record the full path, old value, and new value. Leave unchanged rows hidden until you need nearby context.

03Interpret array rows as sequence evidence

TeenyTool serializes each complete array element and runs a longest common subsequence comparison over those strings. Exact matching elements remain unchanged. Other elements appear as additions or removals at sequence positions.

This means an edited object inside an array is not opened into a field-level change. It can appear as one removed object plus one added object. A moved record can look similar, and duplicate values can make pairing ambiguous. The tool does not know which field is the record ID or whether order has meaning in your API.

For array-heavy responses, pair the visual result with a stable identifier such as ID, slug, or name. Decide separately whether a reorder is a contract change, a display change, or harmless output variance. Use a keyed script when that distinction must be repeatable.

04Treat design-token JSON as source evidence

The Design Tokens Format Module 2025.10 uses $value for token values and $type for explicit or inherited types. It also defines aliases and chained references. Those rules are not ordinary JSON syntax rules.

TeenyTool shows ordinary object, array, and scalar differences. It does not identify token groups, inherit $type, resolve aliases, catch circular references, or prove that generated CSS, Swift, or platform resources match the source. A changed alias string may affect many resolved tokens even when the source diff looks small.

Use the Mac design token QA checklist to compare authored source, resolved values, consumer output, and rendered state. For color tokens, the TeenyColor guide explains how to capture a stable sRGB rendered sample without treating the sample as the source token.

05Close the review with the owning contract

A JSON diff establishes that two parsed values differ. It does not establish that the new payload follows a JSON Schema, satisfies an API contract, preserves client compatibility, resolves design tokens correctly, or produces the intended behavior.

Finish with the authority that can answer the real question: schema validation for structure, tests for behavior, a token resolver and build for generated assets, source control for committed files, or an API client for response behavior. TeenyTool is the local inspection step between two copied values and that stronger proof.

Keep the result small and auditable. Record A and B identities, root types, important paths, array assumptions, expected and unexpected changes, and which contract check passed or remains open.

JSON diff acceptance record

1. Identify JSON A and JSON B by source, environment, revision, and capture time.
2. Fix parse errors and confirm that both roots are objects or arrays.
3. Review root keys, then open every relevant nested branch.
4. Write full paths for meaningful object changes.
5. Check array additions and removals against stable record identifiers.
6. State whether order and duplicate elements are meaningful.
7. Classify each important change as expected, unexpected, or unresolved.
8. Run the schema, test, resolver, build, or destination check that owns acceptance.

Common questions

When should I use a JSON diff tool on Mac?

Use a local JSON diff for a manual comparison of two copied object or array roots, especially when the payload should stay on your Mac. Use source control, tests, or automated assertions for repeatable checks.

Can TeenyTool compare JSON arrays?

Yes. TeenyTool compares whole serialized array elements with a longest common subsequence pass. An edited or moved object can therefore appear as a removal and an addition rather than a field-level change.

Is a JSON diff the same as schema validation?

No. A JSON diff shows that two parsed values differ. It does not validate an API contract, JSON Schema, Design Tokens format, alias resolution, required fields, or business rules.

Sources checked

• TeenyTool feature claims were checked against the local homepage and JSONDiffView.swift for parsing, root restrictions, dictionary recursion, top-level summary counts, array matching, and unchanged-row filtering.
• Apple JSONSerialization documentation for JSON parsing behavior.
• RFC 8259 for the JSON data interchange format.
• Design Tokens Format Module 2025.10 for $value, $type, groups, aliases, and references. This is a Design Tokens Community Group Final Report, not a W3C Recommendation.