JSON to Markdown Table Converter for API Data
API responses, database exports, and config dumps usually arrive as arrays of JSON objects, and those arrays copy badly into documents that render Markdown. This page reads the array you paste, lines the fields up as table columns, and hands back GitHub-flavored Markdown you can drop into a README, a wiki page, or a pull request comment.
Nested objects can be split into separate columns, array cells can be written as compact JSON, comma lists, or line breaks, and fields missing from a row get the placeholder you pick. Nothing is uploaded: the array is parsed by JavaScript running in this tab, and the table is built from that local parse.
Turn a JSON Array Into a Markdown Table
JSON array input
Paste one array of objects. Each object becomes one row of the table.
Table options
Markdown output
The table text lands here after a run. Copy it or download it as table.md.
How It Works
The converter parses your text with the browser's own JSON parser, so a stray comma or a missing quote stops the run before any table is drawn. Each error you see comes from that parse step and names the problem in place. After the parse, the array is walked row by row, columns are collected, and every cell is rendered as text.
- Paste the array. The whole text area must hold one JSON array, and every object in it becomes one row of the table.
- Pick how columns are collected. Union gathers every key across all rows, first uses only the keys of the first object, and alphabetical sorts the column names.
- Set the cell rules. Nested objects are split into dotted columns when flatten is on, arrays follow the style you chose, and missing keys take your empty text.
- Press Build Table. The output area holds the Markdown text, the summary line counts rows and columns, and the copy and download buttons hand the table over.
Before and After
Two runs on the same four-row array. The first pair uses the defaults, which split nested objects into dotted columns and join array items with line-break tags. The second pair turns flattening off, sorts the column names, and writes arrays as compact JSON.
[
{
"id": 1,
"name": "Alpha",
"tags": ["red", "blue"],
"meta": { "city": "Oslo", "zip": "0150" }
},
{
"id": 2,
"name": "Beta",
"tags": ["green"],
"meta": { "city": "Lima" }
},
{
"id": 3,
"name": "Gamma",
"meta": { "city": "Accra", "zip": "0024" }
},
{
"id": 4,
"name": "Delta",
"tags": ["lime", "navy"],
"meta": { "city": "Cairo", "zip": "11511" }
}
]| id | name | tags | meta.city | meta.zip |
| --- | --- | --- | --- | --- |
| 1 | Alpha | red<br>blue | Oslo | 0150 |
| 2 | Beta | green | Lima | - |
| 3 | Gamma | - | Accra | 0024 |
| 4 | Delta | lime<br>navy | Cairo | 11511 |column order: alphabetical
split nested objects: off
array cell style: compact JSON
empty cell text: (none)| id | meta | name | tags |
| --- | --- | --- | --- |
| 1 | {"city":"Oslo","zip":"0150"} | Alpha | ["red","blue"] |
| 2 | {"city":"Lima"} | Beta | ["green"] |
| 3 | {"city":"Accra","zip":"0024"} | Gamma | (none) |
| 4 | {"city":"Cairo","zip":"11511"} | Delta | ["lime","navy"] |Use Cases
| Developer | Production | Workflow |
|---|---|---|
| Endpoint rows pasted into a README | Three account rows for a support reply | Changelog dump turned into release notes |
| Union columns keep sparse fields visible | First-row columns keep the table narrow | Alphabetical columns give a fixed reading order |
| meta.city split out of nested rows | Tags joined into one comma cell | Missing keys filled with a dash |
| Copy Markdown straight into the pull request | Download table.md for the ticket | The array is parsed in the tab each run |
Common Mistakes
- Pasting a single object instead of an array. The converter needs a top-level array, and a lone object is refused with a message that says the top level must be an array of objects.
- Leaving flatten on when the nested keys are the part you wanted to hide. Flattening exposes every inner field as its own column, so switch it off when you would rather show the object as one JSON cell.
- Picking first-row columns while row one is the odd one out. First takes the keys of the first object only, so keys that appear later in the array drop out of the table; union keeps every key that occurs anywhere.
- Expecting line-break cells to read the same in every Markdown renderer. The line-break style writes an inline tag inside the cell, and some renderers show that tag as plain text; the comma style is the plain fallback.
Best Practices
- Start from the defaults. Union columns, flatten on, line-break arrays, and a dash for empty cells cover most API dumps, and changing one option at a time shows what each one does.
- Choose a separator that cannot appear in your field names. The flatten separator joins the column header, so a dot works until a key already carries one, and a colon avoids that clash.
- Trim long cell text before pasting. Pipes inside cells are escaped for you, but a table with very wide columns is hard to read in a README, so cut the long fields down first.
- Download the file when the table is headed for a build. table.md lands in your downloads folder with the exact text from the output area, which sidesteps the stray characters some editors add on paste.
Frequently Asked Questions
What JSON shape does this converter accept?
The text must be one JSON array whose items are objects, because each object becomes one row of the table. Arrays of strings or numbers at the top level are refused with a message that names the problem. Strings, booleans, and numbers inside the objects all become cell text as they are.
What does the flatten option do with nested objects?
With flatten on, an object inside a row is split into one column per inner field, and the column header carries the path joined by your separator, such as meta.city. With flatten off, the whole nested object is written into a single cell as compact JSON text. Flattening stops at arrays, which stay in one cell under the style you picked.
How are array values written into a cell?
Three styles are offered for array cells. The line-break style joins the items with a line-break tag, which Markdown renderers that allow inline HTML show as stacked lines. The comma style joins items with a comma and a space, and the JSON style writes the array as compact JSON text.
What happens to fields that a row is missing?
A key that is absent from a row is filled with the text in the empty cell box, a dash by default. The same text is used when a value is null. Rows all carry the same column count, so the table stays rectangular even when the source data is sparse.
How are the columns ordered?
Union collects keys from every row in the order they first appear, which keeps late-arriving fields visible. First takes only the keys of the first object, which gives a narrow table that can miss fields found later in the array. Alphabetical sorts the column names for a fixed reading order.
Can I get the raw Markdown instead of a rendered table?
Yes. The output area holds the plain Markdown text with its pipes and dashes, and the copy button puts that text on your clipboard. The download link saves the same text as table.md, ready to commit next to a README or paste into a wiki page.
Does my JSON leave the browser?
No. The array is parsed by JavaScript running in this tab, and the table is built from that local parse. No request carries your text anywhere, and closing the tab discards the input along with the generated table.