Name: JSON Repair API: fix LLM JSON, validate, diff, convert
Brand: leadharbor
SKU: api-leadharbor-json-tool
Availability: InStock
Author: API Market

Mohammed Samaan

# JSON Tool API

## Overview

The JSON Tool API puts six JSON operations behind one `POST` endpoint, chosen with the `op` field. `repair` turns the broken JSON that language models and loose tools produce into valid JSON: it strips markdown code fences and surrounding prose, fixes trailing commas, comments, single or smart quotes, unquoted keys, Python literals (`True`, `False`, `None`), raw newlines inside strings and missing commas, and closes truncated output, listing every fix it made. `validate` reports whether a document is valid and, if not, the line and column of the first error. `format` pretty-prints with a chosen indent and optional key sorting, `minify` removes whitespace, `diff` compares two documents and returns JSON Pointer changes, and `convert` writes CSV or YAML. All six take the same request shape, so one client covers every operation.

It is built for developers who parse model output in production pipelines, teams building agents and extraction tools that need a clean object every time, data engineers who move JSON into spreadsheets or YAML configs, and anyone who needs to compare or tidy JSON from a backend. Every response echoes `op` and carries a `meta` object that you can ignore. The rest depends on the operation: `repair` returns `valid_before`, the `repaired` text, the parsed `value`, a `fixes` list with a count for each fix and a `truncated` flag; `validate` returns `valid`, the top-level `type` and an `error` with `message`, `line` and `column`; `format`, `minify` and `convert` return the result as an `output` string; and `diff` returns `equal`, `change_count` and a `changes` list.

## Features

*   **1 endpoint, 6 operations**: `POST /v1/market/json` with `op` set to `validate`, `format`, `minify`, `diff`, `repair` or `convert`.
*   **LLM JSON repair**: Removes code fences and prose, fixes quotes, unquoted keys, trailing commas, comments, Python literals, raw newlines and missing commas, and closes cut-off structures.
*   **No invented data**: When output was cut off mid-value, such as an unfinished string or a number at the very end, that value is dropped and reported rather than kept as if complete.
*   **Every fix listed**: The `fixes` array names each repair and how many times it was applied.
*   **Precise validation**: The first error comes back with a message, line and column.
*   **Structured diff**: Changes are returned as JSON Pointer paths with `add`, `remove` or `replace` and the old and new values.
*   **CSV and YAML output**: CSV from an array of objects with RFC 4180 quoting and formula-safe cells, or YAML from any value.
*   **Inputs**: JSON text or a JSON value in the request body, up to 300,000 characters and 100 levels of nesting.
*   **Rate limit**: 10 requests per second on every plan.

## Use Cases

*   **Parsing model output**: Repair the reply of a language model before `JSON.parse` so a stray code fence or trailing comma does not break your pipeline.
*   **Input validation**: Tell users exactly where their JSON is broken with a line and column before you accept a config or payload.
*   **Change tracking**: Diff two API responses or config versions and store the JSON Pointer changes.
*   **Spreadsheet exports**: Convert an array of records to CSV that opens safely in Excel or Google Sheets.
*   **Config tooling**: Convert JSON to YAML for Kubernetes, CI or app configs, or format and sort keys for stable, reviewable files.
*   **Payload size**: Minify JSON before storing or sending it.

## API Documentation

### Base URL

All requests go through the API.market gateway at this base URL:

```
https://prod.api.market/api/v1/leadharbor/json-tool
```

### Authentication

Every request needs your API.market key in the `x-api-market-key` header:

```
x-api-market-key: YOUR_API_KEY
```

Replace `YOUR_API_KEY` with your actual API key.

### Endpoints

#### 1. Run a JSON operation

Runs one of six operations, `validate`, `format`, `minify`, `diff`, `repair` or `convert`, on the JSON in the request body and returns the result. Send the body as `application/json`.

**Method:** `POST`

**Endpoint:** `/v1/market/json`

**Parameters:**

| Name | In | Description | Type | Required | Default | Max Value |
|---|---|---|---|---|---|---|
| `op` | body | The operation: `validate`, `format`, `minify`, `diff`, `repair` or `convert`. | string | Yes | - | - |
| `json` | body | The input for `validate`, `format`, `minify`, `repair` and `convert`. Send JSON text as a string (always a string for `repair`), or a JSON value directly. | string or JSON value | Yes, except for `diff` | - | 300,000 characters, 100 levels of nesting |
| `a` | body | `diff`: the first document. | JSON value | Yes, for `diff` | - | - |
| `b` | body | `diff`: the second document. | JSON value | Yes, for `diff` | - | - |
| `indent` | body | `format`: spaces per indent level. | integer | No | `2` | 8 |
| `sort_keys` | body | `format` and `minify`: sort object keys alphabetically. | boolean | No | - | - |
| `to` | body | `convert`: output format, `csv` or `yaml`. | string | Yes, for `convert` | - | - |
| `formula_safe` | body | `convert` to CSV: prefix text cells that start with `=`, `+`, `-` or `@` with an apostrophe so spreadsheets do not run them as formulas. | boolean | No | `true` | - |

**Example Request (repair):**

```bash
curl -X POST "https://prod.api.market/api/v1/leadharbor/json-tool/v1/market/json" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  --data-binary @- <<'EOF'
{"op": "repair", "json": "Here you go:\n\u0060\u0060\u0060json\n{name: 'Ada', tags: ['a', 'b',], active: True,}\n\u0060\u0060\u0060"}
EOF
```

The input is a model reply wrapped in prose and a markdown code fence (each `\u0060` is a backtick, escaped so the shell and JSON stay readable), with unquoted keys, single quotes, trailing commas and a Python `True`.

**Example Response (200 OK):**

```json
{
  "op": "repair",
  "valid_before": false,
  "repaired": "{\"name\":\"Ada\",\"tags\":[\"a\",\"b\"],\"active\":true}",
  "value": {
    "name": "Ada",
    "tags": [
      "a",
      "b"
    ],
    "active": true
  },
  "fixes": [
    {
      "id": "code_fence_removed",
      "count": 1
    },
    {
      "id": "prose_removed",
      "count": 1
    },
    {
      "id": "unquoted_keys",
      "count": 3
    },
    {
      "id": "single_quotes",
      "count": 3
    },
    {
      "id": "trailing_commas",
      "count": 2
    },
    {
      "id": "python_literals",
      "count": 1
    }
  ],
  "truncated": false,
  "meta": {
    "user": null
  }
}
```

**Example Request (validate):**

```bash
curl -X POST "https://prod.api.market/api/v1/leadharbor/json-tool/v1/market/json" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"op": "validate", "json": "{\"a\":1,"}'
```

**Example Response (200 OK):**

```json
{
  "op": "validate",
  "valid": false,
  "type": null,
  "error": {
    "message": "Expected double-quoted property name",
    "line": 1,
    "column": 8
  },
  "meta": {
    "user": null
  }
}
```

Invalid input still returns `200`: check `valid`, and read `error.line` and `error.column` for the position of the first error.

**Example Request (format):**

```bash
curl -X POST "https://prod.api.market/api/v1/leadharbor/json-tool/v1/market/json" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"op": "format", "json": "{\"b\":2,\"a\":1}", "indent": 2, "sort_keys": true}'
```

**Example Response (200 OK):**

```json
{
  "op": "format",
  "output": "{\n  \"a\": 1,\n  \"b\": 2\n}",
  "meta": {
    "user": null
  }
}
```

**Example Request (minify):**

```bash
curl -X POST "https://prod.api.market/api/v1/leadharbor/json-tool/v1/market/json" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"op": "minify", "json": "{ \"a\" : 1 }"}'
```

**Example Response (200 OK):**

```json
{
  "op": "minify",
  "output": "{\"a\":1}",
  "meta": {
    "user": null
  }
}
```

**Example Request (diff):**

```bash
curl -X POST "https://prod.api.market/api/v1/leadharbor/json-tool/v1/market/json" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"op": "diff", "a": {"x": 1, "y": 2}, "b": {"x": 1, "y": 3, "z": 4}}'
```

**Example Response (200 OK):**

```json
{
  "op": "diff",
  "equal": false,
  "change_count": 2,
  "changes": [
    {
      "op": "replace",
      "path": "/y",
      "old": 2,
      "new": 3
    },
    {
      "op": "add",
      "path": "/z",
      "new": 4
    }
  ],
  "truncated": false,
  "meta": {
    "user": null
  }
}
```

**Example Request (convert to CSV):**

```bash
curl -X POST "https://prod.api.market/api/v1/leadharbor/json-tool/v1/market/json" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"op": "convert", "json": [{"id": 1, "name": "Ann"}, {"id": 2, "name": "Bo"}], "to": "csv"}'
```

**Example Response (200 OK):**

```json
{
  "op": "convert",
  "to": "csv",
  "output": "id,name\r\n1,Ann\r\n2,Bo",
  "rows": 2,
  "columns": 2,
  "formula_safe": true,
  "meta": {
    "user": null
  }
}
```

**Example Request (convert to YAML):**

```bash
curl -X POST "https://prod.api.market/api/v1/leadharbor/json-tool/v1/market/json" \
  -H "x-api-market-key: YOUR_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"op": "convert", "json": {"users": [{"id": 1, "name": "Ann"}]}, "to": "yaml"}'
```

**Example Response (200 OK):**

```json
{
  "op": "convert",
  "to": "yaml",
  "output": "users:\n  - id: 1\n    name: Ann",
  "meta": {
    "user": null
  }
}
```

**Response fields:**

| Field | Operation | Description |
|---|---|---|
| `op` | all | The operation that ran. |
| `valid_before` | `repair` | `true` if the input was already valid JSON. |
| `repaired` | `repair` | The repaired document as compact JSON text. |
| `value` | `repair` | The repaired document as a parsed JSON value. |
| `fixes` | `repair` | Each fix applied, as an `id` (for example `code_fence_removed`, `prose_removed`, `unquoted_keys`, `single_quotes`, `trailing_commas`, `python_literals`) and a `count`. |
| `truncated` | `repair`, `diff` | For `repair`, `true` when the input was cut off and had to be closed. `diff` also returns this flag. |
| `valid` | `validate` | `true` if the input is valid JSON. |
| `type` | `validate` | The type of the top-level value, or `null` when the input is invalid. |
| `error` | `validate` | The first error, with `message`, `line` and `column`. |
| `output` | `format`, `minify`, `convert` | The result as a string. |
| `equal` | `diff` | `true` if the two documents are the same. |
| `change_count` | `diff` | The number of changes. |
| `changes` | `diff` | Each change, with `op` (`add`, `remove` or `replace`), the JSON Pointer `path`, and `old` and `new` values where they apply. |
| `to`, `rows`, `columns`, `formula_safe` | `convert` | The output format, and for CSV the row and column counts and whether formula-safe quoting was applied. |
| `meta` | all | Metadata (`user` is `null`). You can ignore it. |

## Status Codes

| Code | Status | Description |
|---|---|---|
| 200 | OK | The operation ran. For `validate`, invalid input is still a `200` with `valid: false`. |
| 400 | Bad Request | `op` is missing or unknown, or a field is invalid, for example `indent` outside 1 to 8, or input over the 300,000 character or 100 level nesting limits. The message names the field. |
| 401 | Unauthorized | The `x-api-market-key` value is invalid or expired. |
| 403 | Forbidden | Your subscription does not include this endpoint. |
| 404 | Not Found | The request path is wrong. Use `/v1/market/json`. |
| 405 | Method Not Allowed | The request was not a `POST`. |
| 429 | Too Many Requests | You went over 10 requests per second, or you have used all the calls in your plan. |
| 500 | Internal Server Error | Something failed while processing the request. Retry after a short delay. |

## Rate Limits

The Free trial, Starter and PAYG plans each allow 10 requests per second. The Free trial includes 500 calls with a hard limit, Starter includes 10,000 calls and bills extra calls at $0.001 each, and PAYG has no subscription and is billed at $0.001 per call. Every operation counts as one call. Requests above the per-second limit, or after the Free trial's 500 calls are used up, return `429 Too Many Requests`. Back off before retrying and honour the `Retry-After` header, which says how many seconds to wait. In our tests each operation answered in about 0.3 to 0.6 seconds.

## FAQ

**What can `repair` fix?**

Markdown code fences and prose around the JSON, trailing commas, comments, single or smart quotes, unquoted keys, Python literals (`True`, `False`, `None`), raw newlines inside strings, missing commas and output that was cut off before it closed. Numbers with leading zeros, such as phone numbers, are kept as text so they are not changed.

**How do I know what `repair` changed?**

The `fixes` array lists each fix by `id` with a `count`, and `valid_before` tells you whether the input needed any repair. Repair is a best-effort reading of text that was not valid JSON, so check `fixes` when the exact meaning matters.

**What happens to model output that was cut off?**

Open arrays and objects are closed and `truncated` is `true`. A value that was cut off mid-way, such as an unfinished string or a number at the very end, is dropped and reported instead of being kept as if it were complete.

**Should I send `json` as a string or as an object?**

Send a string when you have raw text, which is always the case for `repair` and usually for `validate`. For `format`, `minify` and `convert` you can also send the JSON value directly, as the CSV and YAML examples do.

**What input does CSV conversion expect?**

An array of objects. The keys become the header row, and values are quoted following RFC 4180. Text cells that start with `=`, `+`, `-` or `@` get an apostrophe prefix so spreadsheets do not run them as formulas; send `formula_safe: false` to turn that off.

**Are there limits on size and precision?**

Input can be up to 300,000 characters, nesting deeper than 100 levels is refused, and numbers larger than 2^53 lose precision.

## Contact Us

If you have any questions or need assistance, you can reach out to us through the embedded chat on the bottom right corner of the page or send an email to hello@magicapi.com.


JSON repair API that fixes broken LLM JSON and lists every fix, plus validation with line and column, formatting, minify, JSON diff and CSV or YAML output.

JSON Repair API: fix LLM JSON, validate, diff, convert

Free trial