Format JSON Data Records as a Markdown Table

A uniform record set

When every record shares the same fields, you get a tidy dictionary table — one column per field, one row per record.

Input:
[
  {"field": "order_id", "type": "string", "required": true},
  {"field": "total", "type": "number", "required": true},
  {"field": "note", "type": "string", "required": false}
]

Output:
| field | type | required |
| --- | --- | --- |
| order_id | string | true |
| total | number | true |
| note | string | false |

Optional/nullable fields shown as blanks

Mark optional fields by leaving them out or setting null in some records — they render as empty cells, which reads as 'nullable' in a dictionary.

Input:
[
  {"id": 1, "closedAt": "2026-06-01"},
  {"id": 2, "closedAt": null},
  {"id": 3}
]

Output:
| id | closedAt |
| --- | --- |
| 1 | 2026-06-01 |
| 2 |  |
| 3 |  |

Documenting a default value

Boolean and numeric defaults render as readable text, making a 'default' column in a config dictionary clear at a glance.

Input:
[
  {"setting": "retries", "default": 3, "enabled": true},
  {"setting": "verbose", "default": false, "enabled": false}
]

Output:
| setting | default | enabled |
| --- | --- | --- |
| retries | 3 | true |
| verbose | false | false |

Flatten a nested type descriptor

A nested type object becomes [object Object]. Promote its fields to top level so the dictionary shows them.

Raw:
{"field": "amount", "type": {"base": "decimal", "scale": 2}}

Flatten to:
[{"field": "amount", "type.base": "decimal", "type.scale": 2}]

Output:
| field | type.base | type.scale |
| --- | --- | --- |
| amount | decimal | 2 |

A path value with a pipe stays intact

Spec records often include example paths or expressions containing |. The pipe is escaped so the cell isn't split.

Input:
[{"field": "route", "example": "/a/{id} | /a/all"}]

Output:
| field | example |
| --- | --- |
| route | /a/{id} \| /a/all |

If a record's value is itself an object (a nested type or constraint), it renders as [object Object] because the tool uses String(). Flatten the descriptor into top-level keys, or give it a separate sub-table in the dictionary.

An enum: ["a","b","c"] field becomes a,b,c via String(). That's often acceptable for a dictionary, but nested arrays lose structure. Pre-serialize complex constraints as strings if you need exact formatting.

Trailing commas, comments, single quotes, or an incomplete fragment cause JSON.parse to fail and the tool returns Invalid JSON input.. Validate the sample first; it must be one well-formed JSON document.

An input of [] returns Empty array.. Provide at least one record. For documenting the empty state itself, describe it in prose.

An array of bare strings or numbers (["id","total"]) returns No object keys found. because there are no keys. Wrap each in an object — [{"field":"id"}] — to make a column.

A multi-line description value breaks the row because newlines aren't escaped (only | is). Replace newlines with spaces in the sample, or fix alignment afterward with md-table-repair.

isActive in one record and is_active in another become two separate columns under the union rule. Normalize key names in the sample so the dictionary shows a single column per field.

Records with many fields create very wide tables. The tool does not wrap or paginate columns. Trim to the fields being documented, or split a large schema into grouped dictionary tables.

The tool converts verbatim — real names, emails, or secrets will appear in the published dictionary. Use anonymized sample records, or run md-secret-redactor for tokens, before converting.

The paste box is capped at the tier's character limit (Free 500,000). For a large exported dataset, upload the .json instead (Free 1 MB) or trim to a representative sample — a dictionary rarely needs every row.