← Back to all guides

How to Clean Up, Validate, and Trust a Messy Data Handoff Between Systems

Published October 20, 2026

A practical workflow for dealing with minified JSON, inconsistent CSV exports, and config drift between two systems — formatting, validating against a schema, cross-converting formats, and diffing two versions to see exactly what changed.

Every data handoff between two systems eventually produces a moment where someone stares at a wall of unformatted text and says "what is this." A vendor sends a minified JSON blob with no whitespace. A CSV export from one tool has a column your importing tool doesn't recognize. A config file that used to work now causes errors and nobody changed anything — except someone obviously did. None of these are exotic problems, and none of them require writing a script to solve. Here's a practical path through the most common versions of this.

Step 1: Make unreadable JSON readable again

APIs and export tools frequently return JSON with all whitespace stripped, because it's smaller to transmit. That's reasonable for a machine, and useless for a human trying to figure out why a field is missing. A minified blob like {"id":"ord_4471","status":"pending","items":[{"sku":"A1","qty":2},{"sku":"B7","qty":1}],"total":84.5} is technically readable if you squint, but anything larger than a toy example becomes an unreadable single line the moment it has more than a few fields or any nesting.

Paste it into JSON Formatter first, before doing anything else with it. It re-indents the structure, which does two things at once: it makes the data actually legible, and it immediately tells you if the JSON is malformed, because a formatter can't indent something it can't parse. That second part is an underrated debugging step on its own — "paste it into a formatter and see if it even parses" catches a surprising number of "the API is broken" tickets that are actually "the response got truncated" or "there's a stray trailing comma from string-templating the payload."

Once formatted, the same order example above becomes obviously readable — you can see at a glance that items is an array of two line items and that total is a flat number rather than, say, a nested object with currency info. That's often all you need to answer "does this response actually contain what I think it contains."

Step 2: Check that the data actually matches what you expect, not just that it parses

Valid JSON and correct JSON are different things. {"total": "84.5"} parses fine — it's syntactically valid — but if your system expects total to be a number and gets a string instead, downstream code can fail in confusing ways, especially in loosely-typed environments where "84.5" + 1 doesn't do what you'd want. This is the gap that JSON Schema exists to close.

A JSON Schema is itself a JSON document that describes the shape a payload should have: which fields are required, what type each field must be, allowed value ranges, string patterns, and so on. A minimal schema for the order example might look like:

{
  "type": "object",
  "required": ["id", "status", "items", "total"],
  "properties": {
    "id": { "type": "string" },
    "status": { "type": "string", "enum": ["pending", "shipped", "cancelled"] },
    "items": {
      "type": "array",
      "items": {
        "type": "object",
        "required": ["sku", "qty"],
        "properties": {
          "sku": { "type": "string" },
          "qty": { "type": "integer", "minimum": 1 }
        }
      }
    },
    "total": { "type": "number" }
  }
}

Paste both the schema and the actual payload into JSON Schema Validator and it will tell you exactly where they diverge — a missing required field, a status value that isn't one of the allowed enum options, a total that came through as a string instead of a number. This is the same mechanism API teams use to catch bad data at the boundary before it propagates into a database or a downstream service: instead of every consumer writing its own defensive type-checking code, the schema is the single source of truth for "what does a valid payload look like," and anyone can validate against it in seconds. If you're receiving data from a partner or vendor API and things keep breaking downstream in ways that are hard to trace, asking "can you share the schema" — or writing one yourself based on their docs — turns a vague recurring bug into a specific, checkable contract.

Step 3: Sanity-check a CSV before you trust it

CSV looks simple and is secretly one of the least standardized formats in common use — delimiter choice (comma vs. semicolon vs. tab), quoting rules around commas inside fields, header presence, and encoding all vary between export tools, and a file that opens fine in one spreadsheet app can import incorrectly somewhere else.

Before importing a CSV export into anything, open it in CSV Viewer rather than trusting a raw text preview or assuming the first few rows represent the whole file. A viewer that properly parses the file into a table will immediately surface two kinds of problems a text preview won't: rows with a different number of columns than the header (often from an unescaped comma inside a text field, like an address or product description that itself contains a comma), and encoding issues that turn accented characters or currency symbols into garbled text. Scrolling through the parsed table for a few seconds is a cheap way to catch "row 4,200 has an extra column" before that row corrupts an entire import.

Step 4: Convert between formats when two systems disagree

A common friction point: one system exports CSV, the next one only accepts JSON (or vice versa), and nobody wants to write a one-off script for a handoff that happens twice a year. Data Format Converter handles this directly — feed it CSV and get back JSON (each row becomes an object, headers become keys), or feed it JSON and get back CSV (provided the JSON is reasonably flat — an array of similarly-shaped objects converts cleanly; deeply nested structures will need some flattening decisions, either by the tool's own handling or by restructuring the source data first).

This is also a good moment to combine steps: convert a CSV to JSON, then run the result through the schema validator from Step 2 if you have (or can sketch) a schema for what the receiving system expects. Catching a type mismatch or missing field right after conversion, while the data is still in front of you, is a lot cheaper than catching it after a failed import three systems downstream.

Step 5: Diff two versions to see exactly what changed

The last common scenario: something that used to work stopped working, nobody admits to changing anything, and you have an old version of a config or API response plus a new one. Eyeballing two multi-hundred-line JSON files side by side to spot a single changed value is slow and error-prone — easy to stare right past the one field that actually moved.

JSON Diff solves this directly: paste the old version and the new version, and it highlights exactly which keys were added, removed, or changed in value, regardless of whether the overall key ordering shifted or whitespace changed. This is the fastest way to answer "what actually changed between these two config versions" or "what's different about this API response compared to yesterday's" without manually tracing through nested structures.

A practical habit worth adopting: whenever you're about to deploy a config change, or right after an API response unexpectedly changes shape, keep the "before" version around specifically so you can diff it against the "after" the moment something looks off. It turns a vague "something's different" into a precise, two-second answer.

Putting the pieces together

A realistic end-to-end scenario: a partner sends you a minified JSON webhook payload that your system rejects.

  1. Format it with JSON Formatter so you can actually read what's in it.
  2. Validate it against your expected schema with JSON Schema Validator to find the specific field that's wrong — maybe total is coming through as a string.
  3. If the partner's system only speaks CSV and yours needs JSON (or vice versa), bridge the gap with Data Format Converter.
  4. Spot-check any CSV involved in CSV Viewer before it goes anywhere near an import process.
  5. Once it's fixed, keep the before/after payloads and run them through JSON Diff so you have a precise record of exactly what changed — useful for your own notes and invaluable if you need to explain the fix to the partner's team.

None of these steps require writing a parser or a validation script by hand, and all of them run directly in your browser — handy when the data you're inspecting is a real customer order, a production config, or anything else you'd rather not paste into a third-party server you don't control.

← Back to all guides