Name: Mend: LLM JSON Repair and Validation API
Brand: hybrid-forge-lab
SKU: api-hybrid-forge-lab-mend
Availability: InStock
Author: API Market

# Mend LLM JSON Repair API

## Overview

The Mend API turns the answer a language model gave you into valid JSON. It finds the JSON in prose or a code fence, repairs what models break and lists every fix with its kind and character position.

It also validates the result against a JSON Schema, or coerces the simple types the schema asks for and then validates. Everything arrives in the request body, nothing is stored and nothing is fetched from the network.

## Features

*   **Four endpoints**: JSON repair, JSON Schema validation, type coercion and a health check.
*   **Finds the JSON**: in a Markdown `json` code fence, a plain code block or the middle of a chatty answer, with the prose around it dropped.
*   **Fixes what models break**: trailing and missing commas, single and curly quotes, unquoted keys, `//` and `/* */` comments, `True`/`False`/`None`, `NaN` and `Infinity`, raw newlines in strings.
*   **Closes truncated output**: open strings, objects and arrays are closed, and an incomplete last member is dropped instead of invented.
*   **Every fix, listed**: 16 fix kinds, each with a message and the character position in your text. Valid JSON comes back untouched, with `repaired: false`.
*   **JSON Schema validation**: drafts 4, 6, 7, 2019-09 and 2020-12, with a JSON Pointer path and the most specific message for every error.
*   **Safe coercion**: `"42"` to `42`, `"true"` to `true`, `7` to `"7"` and `x` to `[x]`, only where the schema's type asks for it.
*   **Deterministic**: the same input always gives the same output and the same fixes. No model is called.

## Use Cases

*   **Extraction pipelines**: repair each answer for invoices, CVs, tickets or product pages, coerce it to your schema and only re-prompt when the API says it can't.
*   **Agents and tool calls**: repair tool-call arguments before you dispatch them, and validate them against the tool's JSON Schema.
*   **Open-weight and small models**: local and cheaper models drift from strict JSON more often. Mend lets you keep them without writing a regex for every quirk.
*   **Monitoring prompt quality**: count fix kinds per model and prompt version. A rise in `unclosed_string` means you're hitting `max_tokens`.

## API Documentation

### Base URL

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

```
https://prod.api.market/api/v1/hybrid-forge-lab/mend
```

### 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. Health check

Returns `ok`, the service version and its uptime.

**Method:** `GET`

**Endpoint:** `/v1/health`

**Parameters:**

This endpoint takes no parameters.

**Example Request:**

```bash
curl -X GET 'https://prod.api.market/api/v1/hybrid-forge-lab/mend/v1/health' \
  -H 'x-api-market-key: YOUR_API_KEY'
```

**Example Response (200 OK):**

```json
{
  "ok": true,
  "version": "0.2.1",
  "uptime_s": 337
}
```

#### 2. Repair the JSON in a model answer

Extracts the JSON from the text and repairs it, listing every fix. Valid JSON comes back untouched, with `repaired: false` and an empty `fixes` list.

**Method:** `POST`

**Endpoint:** `/v1/repair`

**Parameters:**

| Name | In | Description | Type | Required | Default | Max Value |
|---|---|---|---|---|---|---|
| `text` | body | The model's answer as it came back. Prose, Markdown code fences and broken or truncated JSON are fine. | string | Yes | - | 1 MB (UTF-8) |

The response has three fields:

*   `json`: the repaired JSON value.
*   `repaired`: `false` when `text` already was valid JSON.
*   `fixes`: every fix with `kind`, `message` and `position` (0-based character offset in `text`), at most 1,000.

The 16 fix kinds are:

*   `code_fence`: the JSON was inside a Markdown code fence.
*   `surrounding_text`: text before or after the JSON was ignored.
*   `comment`: a `//` or `/* */` comment was removed.
*   `trailing_comma`: a comma before `}` or `]` was removed.
*   `missing_comma`: a comma was inserted between two members or items.
*   `single_quotes`: a single-quoted string was converted to a double-quoted one.
*   `smart_quotes`: curly quotes used as string delimiters were converted to straight double quotes.
*   `unquoted_key`: an unquoted object key was quoted.
*   `python_literal`: `True`, `False` or `None` was converted to `true`, `false` or `null`.
*   `nan_infinity`: `NaN`, `Infinity` or `-Infinity` was converted to `null`.
*   `control_character`: a raw control character inside a string was escaped.
*   `invalid_escape`: an invalid backslash escape was fixed.
*   `unclosed_string`: a string cut off at the end of the text was closed.
*   `unclosed_object`: an object cut off at the end of the text was closed.
*   `unclosed_array`: an array cut off at the end of the text was closed.
*   `truncated_value`: an incomplete member or item at the end of the text was dropped.

**Example Request:**

The answer has prose, an unclosed `~~~json` fence, a comment, an unquoted key, `True`, `NaN`, a missing comma, a trailing comma and a cut-off string.

```bash
curl -X POST 'https://prod.api.market/api/v1/hybrid-forge-lab/mend/v1/repair' \
  -H 'x-api-market-key: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"text": "Here is the order you asked for:\n\n~~~json\n{\n  // parsed from the email\n  order_id: 1042,\n  \"paid\": True,\n  \"discount\": NaN,\n  \"items\": [\n    {\"sku\": \"A-1\", \"qty\": 2}\n    {\"sku\": \"B-7\", \"qty\": 1},\n  ],\n  \"note\": \"Leave at the do"}'
```

**Example Response (200 OK):**

```json
{
  "json": {
    "order_id": 1042,
    "paid": true,
    "discount": null,
    "items": [
      {
        "sku": "A-1",
        "qty": 2
      },
      {
        "sku": "B-7",
        "qty": 1
      }
    ],
    "note": "Leave at the do"
  },
  "repaired": true,
  "fixes": [
    {
      "kind": "code_fence",
      "message": "extracted the JSON from a Markdown code fence",
      "position": 34
    },
    {
      "kind": "surrounding_text",
      "message": "ignored the text before the JSON",
      "position": 0
    },
    {
      "kind": "unclosed_object",
      "message": "closed an object cut off at the end of the text",
      "position": 42
    },
    {
      "kind": "comment",
      "message": "removed a // comment",
      "position": 46
    },
    {
      "kind": "unquoted_key",
      "message": "quoted the key 'order_id'",
      "position": 73
    },
    {
      "kind": "python_literal",
      "message": "True → true",
      "position": 99
    },
    {
      "kind": "nan_infinity",
      "message": "NaN → null",
      "position": 119
    },
    {
      "kind": "missing_comma",
      "message": "inserted a missing comma",
      "position": 170
    },
    {
      "kind": "trailing_comma",
      "message": "removed a trailing comma before ']'",
      "position": 194
    },
    {
      "kind": "unclosed_string",
      "message": "closed a string cut off at the end of the text",
      "position": 211
    }
  ]
}
```

Anything the API can't fix without guessing, such as an unquoted value, is a `422` with the position, line and column.

```bash
curl -X POST 'https://prod.api.market/api/v1/hybrid-forge-lab/mend/v1/repair' \
  -H 'x-api-market-key: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"text": "{\"status\": active, \"id\": 7}"}'
```

**Example Response (422 Unprocessable Entity):**

```json
{
  "detail": "could not repair the JSON: unexpected word 'active' (strings must be quoted) at position 11 (line 1, column 12)"
}
```

#### 3. Validate JSON against a JSON Schema

Checks the schema against its meta-schema, then validates the value. Every error comes with a JSON Pointer `path` and the most specific failing rule, sorted by path.

**Method:** `POST`

**Endpoint:** `/v1/validate`

**Parameters:**

| Name | In | Description | Type | Required | Default | Max Value |
|---|---|---|---|---|---|---|
| `json` | body | The JSON value to check. | any | Yes | - | 1 MB |
| `schema` | body | The JSON Schema. The draft comes from `$schema` (4, 6, 7, 2019-09 or 2020-12), else 2020-12, and external `$ref`s are never fetched. | object or boolean | Yes | - | 256 KB |

**Example Request:**

```bash
curl -X POST 'https://prod.api.market/api/v1/hybrid-forge-lab/mend/v1/validate' \
  -H 'x-api-market-key: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"json": {"order_id": "1042", "qty": 0, "paid": "yes", "tags": "urgent"}, "schema": {"type": "object", "required": ["order_id", "qty", "paid"], "properties": {"order_id": {"type": "integer"}, "qty": {"type": "integer", "minimum": 1}, "paid": {"type": "boolean"}, "tags": {"type": "array", "items": {"type": "string"}}}}}'
```

**Example Response (200 OK):**

```json
{
  "valid": false,
  "errors": [
    {
      "path": "/order_id",
      "message": "'1042' is not of type 'integer'"
    },
    {
      "path": "/paid",
      "message": "'yes' is not of type 'boolean'"
    },
    {
      "path": "/qty",
      "message": "0 is less than the minimum of 1"
    },
    {
      "path": "/tags",
      "message": "'urgent' is not of type 'array'"
    }
  ]
}
```

#### 4. Coerce simple types, then validate

Converts values only where the schema's `type` at that location doesn't already accept them, then validates like `/v1/validate`. Every conversion is listed in `coerced`, and `null` is never changed.

The conversions are:

*   A plain integer string to `integer`, such as `"42"` to `42`.
*   A JSON number string to `number`, such as `"3.5"` to `3.5`.
*   Exactly `"true"` or `"false"` to `boolean`.
*   A number to `string`, such as `42` to `"42"`.
*   A single value to a one-item `array`, such as `x` to `[x]`.

**Method:** `POST`

**Endpoint:** `/v1/coerce`

**Parameters:**

| Name | In | Description | Type | Required | Default | Max Value |
|---|---|---|---|---|---|---|
| `json` | body | The JSON value to coerce and check. | any | Yes | - | 1 MB |
| `schema` | body | The JSON Schema. The draft comes from `$schema` (4, 6, 7, 2019-09 or 2020-12), else 2020-12, and external `$ref`s are never fetched. | object or boolean | Yes | - | 256 KB |

**Example Request:**

```bash
curl -X POST 'https://prod.api.market/api/v1/hybrid-forge-lab/mend/v1/coerce' \
  -H 'x-api-market-key: YOUR_API_KEY' \
  -H 'Content-Type: application/json' \
  -d '{"json": {"order_id": "1042", "qty": "3", "paid": "true", "tags": "urgent"}, "schema": {"type": "object", "required": ["order_id", "qty", "paid"], "properties": {"order_id": {"type": "integer"}, "qty": {"type": "integer", "minimum": 1}, "paid": {"type": "boolean"}, "tags": {"type": "array", "items": {"type": "string"}}}}}'
```

**Example Response (200 OK):**

```json
{
  "json": {
    "order_id": 1042,
    "qty": 3,
    "paid": true,
    "tags": [
      "urgent"
    ]
  },
  "coerced": [
    {
      "path": "/order_id",
      "from": "1042",
      "to": 1042
    },
    {
      "path": "/qty",
      "from": "3",
      "to": 3
    },
    {
      "path": "/paid",
      "from": "true",
      "to": true
    },
    {
      "path": "/tags",
      "from": "urgent",
      "to": [
        "urgent"
      ]
    }
  ],
  "valid": true,
  "errors": []
}
```

## Status Codes

| Code | Status | Description |
|---|---|---|
| 200 | OK | The request was processed. Data that fails the schema is still a 200; check `valid` and `errors`. |
| 401 | Unauthorized | The `x-api-market-key` header is missing or the key is not valid. |
| 403 | Forbidden | Your key has no active subscription to this API, your plan quota is used up, or the endpoint is not part of your plan. |
| 404 | Not Found | The path is wrong. This API has `GET /v1/health`, `POST /v1/repair`, `POST /v1/validate` and `POST /v1/coerce`. |
| 413 | Payload Too Large | `text` or `json` is over 1 MB, `schema` is over 256 KB, or the whole body is over 8 MB. |
| 415 | Unsupported Media Type | The body is not `application/json`. |
| 422 | Unprocessable Entity | The text can't be repaired without guessing, no JSON was found, or the schema is invalid. Also an external `$ref`, over 128 levels of nesting, over the 10 s time budget, or a malformed body. |
| 429 | Too Many Requests | You sent more requests per second than your plan allows. Wait and try again. |

## Rate Limits

Each plan has a monthly quota and a per-second rate limit:

*   **Free**: 15 requests, a 7-day free trial, once per customer, 2 requests per second.
*   **Pro**: 10,000 requests per month, 10 requests per second.
*   **Ultra**: 60,000 requests per month, 20 requests per second.
*   **Mega**: 300,000 requests per month, 50 requests per second.

Each request counts as one call, whatever the endpoint. Calls stop when the quota runs out until the next month.

## FAQ

*   **Which JSON does Mend pick from a long answer?**

    The whole text if it is valid JSON, otherwise the first code fence tagged `json`, `json5`, `jsonc`, `javascript`, `js` or untagged. Inside it, or else in the whole text, the first `{` or `[` from which an object or array can be parsed wins.

*   **Does it ever make things up?**

    No. Truncated output is closed and an incomplete last member is dropped, while unquoted values, `undefined` and mismatched brackets are refused with a `422` that says where.

*   **What happens to valid JSON?**

    It comes back untouched, with `repaired: false` and an empty `fixes` list. Strings that only look like problems, such as `"// not a comment"` or `"True"`, are left alone.

*   **Why not just use JSON mode?**

    Use it when you can. Mend covers providers and models without strict modes, answers cut off by `max_tokens`, prompts that ask for prose plus JSON, and outputs you already stored.

*   **How does coercion decide?**

    Only from the schema's `type` at that location, and only when the value doesn't already fit. `null` is never changed, and `allOf`, `anyOf` and `oneOf` branches are never guessed.

*   **Is my data stored?**

    No. Text and data are processed in memory and discarded, and no model is called.

## 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.


Repair the JSON in LLM output with every fix listed, then validate it against a JSON Schema or coerce simple types. Nothing stored.

Mend: LLM JSON Repair and Validation API

Mend LLM JSON Repair, Validation and Coercion