How to Convert and Clean JSON Data Without a Server

JSON (JavaScript Object Notation) is the backbone of modern web APIs. Every time an application fetches data from an external service — a weather API, a payment gateway, a user database, a content management system — it almost certainly receives JSON in return. But raw JSON from an API or data export is rarely in the exact shape your application, analysis tool, or database needs. Cleaning, validating, and transforming it is a nearly universal developer and data task — one that should be done locally, especially when the data contains sensitive information.

Understanding JSON Structure

Before cleaning or transforming JSON, you must understand its structure. JSON supports six data types:

1. String: Text enclosed in double quotes: `"hello world"`
2. Number: Integer or floating point: `42`, `3.14`, `-7`
3. Boolean: Literal `true` or `false`
4. Null: Literal `null` — represents absence of value
5. Object: Unordered collection of key-value pairs in curly braces: `{"name": "Alice", "age": 30}`
6. Array: Ordered list of values in square brackets: `[1, 2, 3]` or `[{"id": 1}, {"id": 2}]`

JSON objects can be nested arbitrarily deep — an object can contain arrays, arrays can contain objects, and so on. Understanding the depth and nesting of a specific JSON payload is the first step in any cleaning or transformation task.

Step 1: Validate the JSON

JSON syntax is unforgiving. A single misplaced comma, an unescaped special character in a string, or a trailing comma after the last array element (valid in JavaScript, invalid in JSON) makes the entire document unparseable. Before doing anything else, validate the JSON.

Common JSON syntax errors:

• Trailing commas: `[1, 2, 3,]` — the final comma is invalid
• Single quotes instead of double quotes: `{'key': 'value'}` — JSON requires double quotes
• Unescaped special characters in strings: A literal newline or tab inside a string value breaks parsing; use `

` and ` ` escape sequences

• Missing quotes around keys: `{key: "value"}` — valid JavaScript object notation but invalid JSON; keys must be quoted
• Comments: JSON does not support comments (`//` or `/* */`); they must be removed before parsing

Imgira's JSON Validator parses the JSON in your browser and reports the exact line and character position of any syntax errors. This is dramatically faster than debugging a parse error in application code.

Step 2: Inspect the Structure

Once valid, understand what you are working with. Load the JSON into a tree viewer — a hierarchical, collapsible representation of the data structure. Key questions to answer:

• Top-level type: Is the root element an object or an array?
• Array element uniformity: If the root is an array, do all elements have the same keys? Mixed schemas in API responses are common and create problems when converting to tabular formats.
• Nesting depth: How many levels deep is the data? Deep nesting requires "flattening" for use in CSV or databases.
• Data types: Are numeric values stored as strings? (e.g., `"count": "42"` instead of `"count": 42`) — type coercion issues are common in poorly designed APIs.
• Null handling: Which fields contain null values, and what do they represent — missing data, zero, or an explicit "not applicable" status?
• Identifier fields: Which field uniquely identifies each record? This is needed for deduplication and joining with other datasets.

Step 3: Clean the Data

Common JSON cleaning tasks:

Type normalisation: If numeric values are stored as strings, convert them to actual numbers. If booleans are stored as "yes"/"no" strings, convert to `true`/`false`. Consistent types are essential for downstream processing.

Key normalisation: APIs sometimes use inconsistent naming conventions — camelCase in some endpoints, snake_case in others. Normalise to a single convention. For databases and CSV exports, snake_case is often preferable; for JavaScript applications, camelCase.

Remove unwanted fields: API responses often include pagination metadata, internal IDs, deprecated fields, and audit timestamps that are irrelevant for your use case. Stripping unused keys reduces file size and processing complexity.

Flatten nested structures: If your target is a CSV or a relational database table, nested objects need to be flattened. An address object `{"street": "123 Main St", "city": "London"}` inside a user object might become `user_street` and `user_city` columns in the flat output.

Handle null values consistently: Decide on a null representation strategy — keep them as `null`, replace with `0` for numerics, or replace with empty strings for text fields — and apply it consistently across the dataset.

Step 4: Reshape for the Target Destination

After cleaning, reshape the data for its destination:

JSON to CSV: Convert an array of uniform objects into rows and columns. This is only straightforward when all objects share the same keys. Non-uniform arrays require a normalisation step first — either adding missing keys with null values, or splitting records by type into separate CSV files.

JSON to XML: Some enterprise systems require XML input. XML has stricter element naming rules than JSON (no spaces, must start with a letter) — key normalisation is usually required before conversion.

JSON to YAML: YAML is a superset of JSON and is preferred for configuration files (Kubernetes, Docker Compose, GitHub Actions). The structural equivalence makes this conversion lossless.

JSON filtering: Extract a subset of records matching specific criteria. For example, from a JSON array of products, extract only those with `stock > 0` and `category = "electronics"`.

JSON Security: What to Watch For

JSON files frequently contain sensitive information:

• API keys and authentication tokens
• User personal data (names, emails, addresses)
• Financial transaction details
• Internal system identifiers and database structure
• Proprietary business logic in configuration files

Pasting JSON containing any of these into an upload-based browser tool means that information — even if it is "just sample data" — travels to an external server. That server may log inputs for debugging, retain data for model training, or be breached by attackers.

Browser-based JSON tools eliminate this risk entirely. The JSON is loaded into the browser's JavaScript runtime and processed on your device. No network request is made with the payload.

This is particularly important for:

• OAuth tokens in API response payloads
• Webhook payload inspection
• Database export files containing user records
• Configuration files with database connection strings

Pretty-Printing vs Minification

JSON can be formatted in two ways:

Pretty-printed: Indented with newlines and spaces for human readability. Use for documentation, code review, debugging, and sharing with colleagues.

Minified: All whitespace removed, everything on a single line. Use for API responses and file storage — minified JSON is smaller and faster to parse by machines.

Imgira's JSON Formatter converts between the two in the browser. Minified API responses can be instantly pretty-printed for inspection; human-readable configuration files can be minified before embedding in code.

Practical Workflow for JSON Cleaning

Here is a complete workflow for cleaning a raw API response JSON:

1. Validate — confirm valid JSON syntax
2. Inspect — understand structure, depth, types
3. Back up — save the original before any modification
4. Normalize types — convert string-encoded numbers to numbers, etc.
5. Normalize keys — consistent naming convention
6. Remove unused fields — strip pagination metadata, deprecated fields
7. Flatten (if needed) — for CSV/database targets
8. Handle nulls — decide and apply consistent null strategy
9. Convert — to target format (CSV, YAML, XML, etc.)
10. Validate output — ensure the output is correct before using

All of these steps can be completed in Imgira's suite of JSON tools — locally in your browser, without any data leaving your device.