Convert JSON to Markdown Tables & Lists
json to md with the shape of your data decided by the data itself: a top-level array of flat objects becomes a GitHub Flavored Markdown table, and anything nested becomes an indented bullet list with bolded keys. Parsing is the browser’s own JSON.parse, running in a Web Worker — no library download, no upload, no signup.Processing happens 100% in your browser — nothing is uploaded.
How to convert JSON to Markdown
- Provide the data: drop a .json file onto the dropzone, or paste the payload straight into the editor.
- Local processing: the browser's native JSON.parse runs in a Web Worker, the shape is inspected, and the data is rendered as a GFM table or a nested bullet list.
- Copy or download: copy the Markdown to your clipboard or save it as a .md file for a README, a wiki, or an Obsidian vault.
Why Convert JSON to Markdown with MD Convert?
Shape dispatch: tables for records, lists for hierarchy
An array whose every element is a flat object maps exactly onto a pipe table. As soon as one element holds a nested object or array, the whole structure renders as an indented bullet list instead — because a Markdown cell cannot contain a block, and stringifying the nesting would bury your data as unreadable [object Object] text.
Columns unioned across every row
Every key seen in any object becomes a column, in first-seen order, and an object missing that key emits an empty cell. Sampling only the first object — the common shortcut in json2md-style tools — silently drops optional fields that appear later in a real API payload.
Pipe escaping and explicit nulls
Any | inside a string value is escaped as \| so a URL, regex or log line cannot split a cell and desynchronise the row. An explicit null is rendered as inline code rather than as blank, keeping it distinguishable from a key that was simply absent from that object.
Zero dependencies, zero data leaving the device
There is no parser to download: JSON.parse is already compiled into your browser. An API response with customer records, a manifest holding an access token, or an unshipped schema is processed locally and never transmitted — verifiable in the DevTools Network panel.
JSON to Markdown: Before and After
A top-level array of flat objects is the one shape with an exact Markdown equivalent, so it becomes a pipe table. Keys are unioned across all rows, so a field missing from one object yields an empty cell rather than a shifted column.
[
{ "endpoint": "/v1/users", "method": "GET", "auth": true, "p95_ms": 42 },
{ "endpoint": "/v1/users", "method": "POST", "auth": true, "p95_ms": 118 },
{ "endpoint": "/v1/health", "method": "GET", "auth": false, "p95_ms": 3 }
]| endpoint | method | auth | p95_ms |
| --- | --- | --- | --- |
| /v1/users | GET | true | 42 |
| /v1/users | POST | true | 118 |
| /v1/health | GET | false | 3 |Understanding the JSON Format: RFC 8259 / ECMA-404
- Format
- JavaScript Object Notation
- Specification
- RFC 8259 / ECMA-404
- Media type
application/json- Parser used
- Native JSON.parse
Technical Specifications & Shape Dispatch Rules
- Deterministic Shape Dispatch: Top-level arrays of flat scalar objects map directly to GFM pipe tables; nested objects or arrays fall back to hierarchical indented bullet lists to prevent unreadable [object Object] output.
- Full Column Unioning: Table headers represent the superset union of all keys across every record in first-seen order; missing optional keys emit empty cells rather than shifted columns.
- Structural Pipe & Explicit Null Handling: Pipes within string values are escaped to \| to preserve cell integrity; explicit null values render as inline null code to distinguish them from absent keys.
- Zero-Dependency Native Execution: Uses the browser's compiled JSON.parse inside a background Web Worker; multi-megabyte payloads parse with zero third-party downloads, zero network transfers, and precise character-offset error reporting.
- Envelope Payload Unpacking: To convert API responses wrapped in envelope objects ({ "data": [...] }) into tables, unpack the inner array before conversion; root-level envelopes render as outline lists.
Developer Alternative: CLI (jq) & Python (Pandas) Extraction
For scheduled jobs or server-side pipelines, jq and Pandas produce the same kind of Markdown table outside the browser.
# Format a JSON array of objects directly into a Markdown pipe table using jq
jq -r '(.[0] | keys_unsorted) as $k | ($k | join(" | ")), ($k | map("---") | join(" | ")), (.[] | [.[$k[]]] | join(" | "))' data.json# Programmatic JSON to Markdown table conversion using Pandas
# requires: pip install pandas tabulate
import json
import pandas as pd
with open("data.json") as f:
data = json.load(f)
# Normalizes JSON records into a DataFrame and outputs a GFM table
df = pd.json_normalize(data)
markdown_table = df.to_markdown(index=False)
print(markdown_table)How You Can Verify the Privacy Claim
Zero server upload
Conversion runs inside your browser tab. Open DevTools, switch to the Network panel, and convert a file: for every format except URL to Markdown you will see no request carrying your document — because there is no endpoint to send it to.
Off the main thread
Heavy parsing is dispatched to a Web Worker, so a 500-page PDF or a large spreadsheet never freezes the interface. Everything is plain JavaScript — no native plugin, no WebAssembly toolchain, nothing to install.
Nothing to sign up for
No login, no quota, no paywall, and no tracking tied to your files. Analytics are cookieless and aggregate only. Read the privacy policy for the full data-flow breakdown, including the one proxied exception.
The parsers doing the work
No proprietary black box: each format is handled by a widely audited open-source library, running client-side at the version pinned in our lockfile.
JSON to Markdown — FAQ
How do I convert JSON to a Markdown table?
Make the array of records the top level of the document. An array whose elements are all flat objects becomes a pipe table with column headers taken from the union of all keys. If your array is nested inside an envelope object under a key such as data or items, extract that inner array first.
What happens with deeply nested JSON or a config file?
It becomes an indented bullet list with each key in bold. Every nesting level adds two spaces of indentation and array elements stay in order, so the hierarchy of a schema or a configuration file is preserved exactly rather than flattened into unreadable [object Object] text.
Are pipe characters and null values handled safely?
Yes. Pipes inside string values are escaped as \| so they cannot break the table structure, and explicit null is emitted as inline `null` code so it stays distinguishable from an empty cell caused by an absent key.
My API response is wrapped in an envelope object — how do I get a table?
Unpack the inner array before conversion — for example, copy the value of the "data" key so it sits at the top level. Root-level envelope objects render as outline lists by design; guessing which nested array is the interesting one would fail on real payloads.