JSON to Markdown Table

About Markdown Tables

Markdown tables are a simple way to display tabular data in documentation, README files, GitHub issues, and other Markdown-compatible platforms.

Example Output

Given this JSON:

[
  {"name": "Alice", "role": "Admin", "active": true},
  {"name": "Bob", "role": "User", "active": false}
]

You get this Markdown:

| name | role | active |
|------|------|--------|
| Alice | Admin | true |
| Bob | User | false |

Which renders as:

Supported JSON Structures

• Array of objects — Most common, each object becomes a row
• Nested values — Automatically stringified
• Mixed types — Strings, numbers, booleans all supported

Column Alignment

Markdown supports column alignment using colons in the separator row:

| Left | Center | Right |
|:-----|:------:|------:|
| a    | b      | c     |

Use Cases

• API Documentation — Document request/response formats
• README files — Display configuration options
• GitHub Issues — Present data clearly in tickets
• Technical specs — List features or requirements
• Database schemas — Document table structures

Limitations

• Markdown tables don't support cell merging
• No built-in sorting or filtering
• Complex nested objects shown as JSON strings
• Very wide tables may not render well

Related Tools

• JSON to CSV — Convert to spreadsheet format
• JSON Table Viewer — Interactive HTML table
• JSON Validator — Validate your JSON first

Common Mistakes & Pro Tips

• Pipe characters in values must be escaped or they split the cell — In a Markdown table the pipe | is the column separator, so a value like a|b will be read as two cells and misalign the row. The fix is to escape it as a\|b. A correct converter escapes every literal pipe inside a value; if yours doesn't, any value containing | will corrupt the table layout.
• Markdown tables require a flat array of objects — A GFM table is rows and columns of scalar text, so the input should be an array of objects with primitive values. Nested objects and arrays have no cell representation and are typically stringified (e.g. {"a":1} shown as JSON text) or flattened with dot-notation headers. Deeply nested JSON won't render as a clean table without flattening first.
• Newlines inside a value break the table; use <br> instead — A literal line break inside a cell ends the table row in Markdown, so multi-line values must have their newlines replaced — commonly with a <br> tag, which renderers display as a line break inside the cell. Without this substitution, a value containing \n will split one row into several malformed lines. Check whether your converter does the replacement.
• Headers are the union of all keys, and column order matters — The header row is built from every key seen across all objects, so a field present in only some records still gets a column, with blank cells where it's absent. Column order usually follows first-seen order of keys. If two objects list the same keys in different orders, the converter normalizes them to one consistent column order — values are placed by key, not by position.
• The separator row controls alignment, not just structure — The second row of dashes (|---|---|) is mandatory and also encodes alignment: :--- is left, :---: is center, and ---: is right. Some converters let you set alignment; plain output defaults to left. Pasting a table without that separator row makes most Markdown renderers show it as literal text rather than a formatted table.