JSON, CSV & XML Tools: Format, Convert & Validate Data Online

1// Pretty-print with JSON.stringify
2const data = { name: "Alice", scores: [95, 87, 92], active: true };
3 
4// Compact (default API response format)
5JSON.stringify(data);
6// → {"name":"Alice","scores":[95,87,92],"active":true}
7 
8// Indented (human-readable)
9JSON.stringify(data, null, 2);
10// → {
11//   "name": "Alice",
12//   "scores": [95, 87, 92],
13//   "active": true
14// }
15 
16// Sorted keys (for stable diffs and comparisons)
17function sortedStringify(obj: unknown, indent = 2): string {
18  return JSON.stringify(obj, (_, value) => {
19    if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
20      return Object.fromEntries(
21        Object.entries(value as Record<string, unknown>).sort()
22      );
23    }
24    return value;
25  }, indent);
26}
27 
28sortedStringify({ z: 3, a: 1, m: 2 });
29// → {"a":1,"m":2,"z":3}  (alphabetical key order)

1import Ajv from 'ajv';
2 
3const ajv = new Ajv({ allErrors: true }); // Report all errors, not just the first
4 
5// Define the schema
6const userSchema = {
7  type: 'object',
8  required: ['id', 'email', 'role'],
9  properties: {
10    id: { type: 'integer', minimum: 1 },
11    email: { type: 'string', format: 'email' },
12    name: { type: 'string', maxLength: 100 },
13    role: { type: 'string', enum: ['admin', 'editor', 'viewer'] },
14    createdAt: { type: 'string', format: 'date-time' },
15  },
16  additionalProperties: false, // Reject unknown fields
17};
18 
19const validate = ajv.compile(userSchema);
20 
21// Valid data
22const user = { id: 1, email: 'alice@example.com', role: 'admin' };
23validate(user); // → true
24 
25// Invalid data
26const bad = { id: 'not-a-number', email: 'not-an-email' };
27validate(bad);  // → false
28validate.errors;
29// → [
30//   { instancePath: '/id', message: 'must be integer' },
31//   { instancePath: '/email', message: 'must match format "email"' },
32//   { instancePath: '', message: 'must have required property "role"' }
33// ]

1# Input: a JSON API response
2# {"users": [{"id": 1, "name": "Alice", "active": true}, {"id": 2, "name": "Bob", "active": false}]}
3 
4# Extract all names
5cat data.json | jq '.users[].name'
6# → "Alice"
7#   "Bob"
8 
9# Filter only active users and extract their IDs
10cat data.json | jq '[.users[] | select(.active == true) | .id]'
11# → [1]
12 
13# Transform structure: create an id→name map
14cat data.json | jq '.users | map({(.id|tostring): .name}) | add'
15# → {"1":"Alice","2":"Bob"}
16 
17# Count users per status
18cat data.json | jq '.users | group_by(.active) | map({active: .[0].active, count: length})'
19 
20# Prettify a minified JSON file
21cat minified.json | jq '.'
22 
23# In Node.js — jq-style querying with jsonpath-plus
24import { JSONPath } from 'jsonpath-plus';
25const names = JSONPath({ path: '$.users[*].name', json: data });
26// → ['Alice', 'Bob']

1// Flat JSON array → CSV string
2function jsonToCSV(rows: Record<string, unknown>[]): string {
3  if (rows.length === 0) return '';
4 
5  // Use the keys from the first row as headers
6  const headers = Object.keys(rows[0]);
7 
8  const csvRows = rows.map(row =>
9    headers.map(header => {
10      const value = row[header];
11      if (value === null || value === undefined) return '';
12 
13      const str = String(value);
14      // Quote if contains comma, newline, or double quote
15      if (/[,"
16
]/.test(str)) {
17        return '"' + str.replace(/"/g, '""') + '"';
18      }
19      return str;
20    }).join(',')
21  );
22 
23  // UTF-8 BOM for Excel compatibility
24  return '' + [headers.join(','), ...csvRows].join('
25');
26}
27 
28// Download as CSV file
29function downloadCSV(json: Record<string, unknown>[], filename: string): void {
30  const csv = jsonToCSV(json);
31  const blob = new Blob([csv], { type: 'text/csv;charset=utf-8;' });
32  const url = URL.createObjectURL(blob);
33  const link = document.createElement('a');
34  link.href = url;
35  link.download = filename;
36  link.click();
37  URL.revokeObjectURL(url);
38}

1// The dangerous behaviour
2const response = '{"id": 9007199254740993}'; // 64-bit integer ID from PostgreSQL
3const parsed = JSON.parse(response);
4parsed.id; // → 9007199254740992  (WRONG! Lost the last digit)
5 
6// Fix 1: return IDs as strings from your API (simplest)
7const safeResponse = '{"id": "9007199254740993"}';
8const safe = JSON.parse(safeResponse);
9safe.id; // → "9007199254740993" (correct, keep as string)
10 
11// Fix 2: use a BigInt-aware JSON parser
12// npm install json-bigint
13import JSONbig from 'json-bigint';
14const withBigInt = JSONbig.parse(response);
15withBigInt.id; // → 9007199254740993n (BigInt — correct)

1// Undefined values are silently dropped by JSON.stringify
2const obj = { name: 'Alice', score: undefined, active: true };
3JSON.stringify(obj);
4// → {"name":"Alice","active":true}  ← score is gone!
5 
6// Null is preserved — use null for "no value"
7const safe = { name: 'Alice', score: null, active: true };
8JSON.stringify(safe);
9// → {"name":"Alice","score":null,"active":true}
10 
11// undefined in arrays becomes null
12JSON.stringify([1, undefined, 3]);
13// → "[1,null,3]"  ← undefined → null in array positions

1// Date objects are serialised to ISO strings
2JSON.stringify(new Date('2026-07-02'));
3// → '"2026-07-02T00:00:00.000Z"'
4 
5// But JSON.parse gives you a STRING back, not a Date
6const parsed = JSON.parse('"2026-07-02T00:00:00.000Z"');
7typeof parsed; // → "string"  (NOT a Date!)
8 
9// You must convert back manually
10const date = new Date(parsed); // → Date object
11 
12// Or use a reviver function in JSON.parse
13const dateReviver = (_key: string, value: unknown) => {
14  if (typeof value === 'string' && /^d{4}-d{2}-d{2}T/.test(value)) {
15    return new Date(value);
16  }
17  return value;
18};
19const data = JSON.parse(jsonString, dateReviver);
20// Now date fields are automatically converted back to Date objects