Latest conversion
{{ recordCountLabel }}
{{ metrics.inputModeLabel }} input -> {{ metrics.targetType }}
{{ metrics.rootType }} {{ metrics.fieldCount.toLocaleString() }} fields Depth {{ metrics.depth }} {{ metrics.sizeBytes.toLocaleString() }} bytes Path: {{ metrics.pathUsed }} Unsafe ints: {{ metrics.unsafeIntegerCount }} JSONL lines: {{ metrics.jsonLinesCount }}
{{ warning }}
{{ pipelineSourceLabel }} {{ pipelineBranchLabel }} {{ pipelineOutputLabel }}
JSON Input
Paste JSON, a JSON array, or JSONL; .json, .jsonl, and .txt files are read as text.
{{ sourceFileStatus || 'Drop JSON, JSONL, or TXT onto the textarea.' }}
Use Auto for mixed API/log samples, or strict modes when parse failures should be explicit.
Leave blank for root data; examples: items[0].records or /items/0/records.
Choose the handoff text preview: JSONL, CSV, TSV, XML, YAML, HTML, Markdown, or SQL.
Use a simple XML name such as dataset; invalid characters are sanitized.
Use a repeated item name such as record, event, or item.
Select the identifier quoting and boolean literal style for generated INSERT statements.
Use a destination table name such as dataset, events, or api_records.
On creates columns like user.name; Off keeps nested objects as JSON cell text.
{{ flatten_objects ? 'On' : 'Off' }}
On creates headers like tags[0]; Off keeps arrays as JSON cell text.
{{ flatten_arrays ? 'On' : 'Off' }}
Converting JSON...
Accepted range: 0 to 8 spaces; 0 produces compact JSON.
spaces
Preserve source order, or sort object keys A-Z/Z-A before conversion.
On writes null as empty CSV/XLSX cells; Off preserves the visible null value.
{{ null_as_blank ? 'On' : 'Off' }}
Choose Preserve, snake_case, kebab-case, or camelCase for exported column names.
Accepted range: 10 to 2000 visible rows; downloads keep the full dataset.
rows
# {{ header }} Copy
{{ row.rowNumber }} {{ cell }}
No rows available.
Preview limited to {{ max_preview_rows }} rows. Downloads contain the full dataset.
Path Types Coverage Example Copy
{{ row.path }} {{ row.types }} {{ row.coverage }} {{ row.example }}
Path atlas appears after a successful transform.
Risk area Status Evidence Copy
{{ risk.category }} {{ risk.status }} {{ risk.detail }} 
{{ deckText }}
Tags: Data Format, Devtools, Editor
JSON to CSV Converter Turn nested JSON or JSON Lines into clean CSV or TSV, with record-path selection, flattened headers, previews, and spreadsheet formula checks.
Comma-Separated Values (CSV) Converter Convert CSV-like text into previews, profiles, and reusable exports in your browser while checking headers, delimiters, types, and row warnings.
Tab-Separated Values (TSV) Converter Convert TSV or delimiter-separated rows into clean tables and typed exports with header detection, row warnings, and column profiles.
Extensible Markup Language (XML) Converter Convert XML in your browser into JSON, JSON Lines, tables, SQL inserts, and formatted XML with record-path checks and schema clues.
Customize
Advanced
:

JSON is easy for software to exchange and hard for people to audit when it arrives as a real API response, log excerpt, or configuration dump. Useful records may sit under a wrapper object, optional fields may appear only on some rows, and nested arrays can turn one neat value into many table columns. A valid JSON document can still be awkward to compare, paste into a spreadsheet, or hand to a database import step.

JSON conversion is the practical bridge between hierarchical data and review-friendly formats. The first question is not usually the output file extension. It is which part of the data should be treated as records. A root array already behaves like a table, while an object such as {"meta": {...}, "items": [...]} needs the record branch selected before the rows mean anything.

JSON input document or JSON Lines Select branch root, dot path, or pointer path Shape output table columns and handoff text Flattening choices decide whether nested data becomes columns or cell text

Two input shapes are common. A single JSON text is one complete value, often an object or an array. JSON Lines, also called newline-delimited JSON, stores one JSON value on each non-empty line, which makes it common for logs, event streams, and batch exports. Treating those two shapes as interchangeable causes confusing parse errors or silently changes the record count.

Flattening deserves the same care. Turning owner.name or labels[0] into a column makes a table easier to scan, but it also replaces tree structure with header names. Keeping nested values as JSON cell text can be safer when an array has variable length, when objects differ widely from row to row, or when the receiving system expects a nested value rather than many columns.

The biggest mistake is trusting a tidy output before checking the branch, field coverage, depth, and numeric precision. A table can look complete while using the wrong wrapper level, hiding sparse fields, or rounding an identifier that should have stayed as text.

How to Use This Tool:

Start by making the source shape and record branch explicit, then choose the output that matches the next system.

  1. Paste data into Payload, or browse/drop a .json, .jsonl, or .txt file. If the text is empty or invalid, an error appears above the input instead of producing stale results.
  2. Set Source mode. Auto detect tries normal JSON first and JSON Lines second; Strict JSON and Strict JSONL are better when you need a failure to point at the wrong source shape.
  3. Use Record path when records are nested inside a wrapper. Dot/bracket paths such as items[0].records and JSON Pointer paths such as /items/0/records can select the branch that should feed the table.
  4. Choose Output format for the selected-format preview. The parsed branch can be previewed as JSON Lines, CSV, TSV, XML, YAML, an HTML table, a Markdown table, or SQL insert text.
  5. Set Flatten objects and Flatten arrays before reviewing the table. These switches decide whether nested values become path-style headers or remain JSON text inside cells.
  6. Open Advanced when the destination has naming or formatting expectations. Indent size, key sorting, null handling, header case, SQL dialect, table name, XML tags, and preview row limits all affect the handoff shape.
  7. Check Latest conversion, then review Record Grid, Path Atlas, Risk Audit, and JSON. If a path warning appears, fix the path or clear it before copying or downloading output.

The on-page grid can be limited with Preview rows so the browser stays responsive, but the generated downloads use the full selected dataset.

Interpreting Results:

Latest conversion is the first sanity check. Record count, root type, target type, field count, depth, payload size, JSON Lines count, selected path, and unsafe-integer badges tell you whether the parser found the kind of data you expected.

Record Grid is useful for row-by-row review, but it is a flattened view. Use JSON to confirm the selected branch before flattening, and use Path Atlas to see which paths became fields, which value types appeared, how much coverage each field has, and a sample value.

Risk Audit does not declare the data wrong. It highlights conditions that often break handoffs: unresolved paths, integer values outside the safe exact range for browser numbers, very broad header sets, and unusually deep payloads.

  • Trust the conversion only after the record count and selected branch match the source you meant to convert.
  • Review sparse fields in Path Atlas before treating blank cells as missing, null, or intentionally empty.
  • Treat large numeric identifiers as text when exact digits matter, especially before spreadsheet or SQL handoff.

Technical Details:

JSON represents data as strings, numbers, booleans, null, arrays, and objects. Objects preserve named members, arrays preserve order, and nested combinations of both create the tree structure that makes JSON expressive. A tabular export has to flatten or serialize that tree because a table needs a finite set of headers and one cell value per row and column.

JSON Lines changes the outer framing rather than the value rules. Each non-empty line is parsed as its own JSON value, so an event log with 500 lines becomes 500 records without wrapping the file in square brackets. Blank lines are ignored by this converter, but a non-empty line that is not valid JSON stops the strict JSONL path with a line-specific error.

Path selection happens after parsing. A blank path uses the parsed root. Dot/bracket notation walks ordinary object keys and numeric array positions, while JSON Pointer uses slash-separated reference tokens and its own escaping rules for literal slash and tilde characters. If the selected path cannot be resolved, the conversion warns and uses root data so the page can still show a recoverable result.

Transformation Core:

StageRuleReview Check
ParseStrict JSON parses one complete JSON text. Strict JSONL parses each non-empty line. Auto detect tries JSON first, then JSONL.Use strict mode when you need the error to identify the source shape.
SelectBlank path keeps the root. Dot/bracket paths and JSON Pointer paths can select nested values.A path warning means the output is using root data, not the typed path.
RecordizeA selected array becomes multiple records. A selected object, scalar, null, or empty structure becomes a single record shape.Compare the summary record count with the source system's expected count.
FlattenNested objects and arrays either expand into path-style headers or stay serialized in cells, depending on the flattening switches.Wide headers and sparse coverage suggest the tree may not fit a simple table.
FormatThe same selected data feeds the grid, path audit, pretty JSON, and chosen handoff text.Keep settings fixed when comparing two runs.

Path and Header Rules:

ChoiceBehaviorConsequence
Dot pathitems[0].records walks object keys and array indexes.Readable for common API wrappers and hand-written paths.
JSON Pointer/items/0/records walks slash-separated tokens; ~1 means slash and ~0 means tilde inside a token.Useful when another system already reports pointer-style paths.
Header caseGenerated headers can stay preserved or become snake_case, kebab-case, or camelCase.Name collisions receive numeric suffixes instead of merging two fields.
Null as blankNull and missing values can display as empty cells or visible null text.Blank cells are cleaner for spreadsheets, but visible null is safer for audits.
Preview rowsThe visible grid is capped between 10 and 2000 rows.Exports and downloads still use the full selected dataset.

Worked Transformation Path:

An input such as {"meta":{"page":1},"items":[{"id":"9007199254740993","owner":{"name":"Ada"},"tags":["ops","release"]}]} becomes a table only after the record branch is chosen. With Record path set to items, object and array flattening on, and preserved headers, the selected array becomes one record with headers such as id, owner.name, tags[0], and tags[1]. If array flattening is off, tags remains one JSON text cell instead of two positional columns.

Precision checks focus on parsed numeric values. The decimal digits in a quoted identifier stay text, while an unquoted integer above 9,007,199,254,740,991 is flagged because browser number handling can no longer guarantee exact integer comparison. That warning matters most for account IDs, ticket IDs, order numbers, and other identifiers that look numeric but should not be rounded.

Privacy Notes:

Pasted text and selected files are read and converted in the browser after the page loads. Regular previews, copied text, CSV output, document exports, and JSON output are generated from that local parsed data. Requesting XLSX output may load spreadsheet code from a public CDN; the workbook is still built in the browser, and the JSON payload is not uploaded by the conversion workflow.

Worked Examples:

An API response contains {"meta":{"page":1},"items":[{"id":1,"owner":{"name":"Ada"}}]}. Set Record path to items and keep object flattening on. Latest conversion should show 1 record, Record Grid should include id and owner.name, and Path Atlas should confirm that the wrapper metadata is not part of the table.

A log excerpt has one object per line, such as {"event":"login"} followed by {"event":"logout"}. Strict JSONL should show a JSON Lines count of 2. If the second line is missing a closing brace, the error identifies the bad JSONL line instead of treating the whole file as one normal JSON document.

A nested payload produces 160 generated headers with arrays flattened. Risk Audit warns about header breadth, and Path Atlas shows many low-coverage paths. Turning Flatten arrays off may keep repeated values in fewer cells, which is safer when the destination cannot handle a very wide table.

A path typo such as item.records when the source key is items triggers the path warning and uses root data. Correct the path, then verify the Latest conversion record count and Path Atlas coverage before using the selected output.

FAQ:

Can I convert a single JSON object?

Yes. A single object becomes one record, and a scalar value becomes one record with a value-style field.

When should I use Strict JSONL?

Use Strict JSONL when every non-empty line should be its own JSON value, such as log events or streamed records. It gives clearer line-level errors for bad input.

Why did my record path fall back to root?

The selected path did not resolve against the parsed data. Check spelling, array indexes, and whether Path mode should be dot notation or JSON Pointer.

Does flattening change the JSON shown in the JSON tab?

No. Flattening changes the table and handoff formats. The JSON tab shows the selected branch before table shaping.

Why are unsafe integers flagged?

Parsed integer numbers above the browser safe-integer range may not keep exact digits. Keep IDs and other exact numeric-looking values as strings when precision matters.

Why is my grid shorter than the download?

Preview rows limits only the visible grid. Copy and download actions use the full selected dataset when data is available.

Glossary:

JSON Lines
A line-based format where each non-empty line is parsed as one JSON value.
Record path
The path that selects which branch of the parsed data becomes the working dataset.
JSON Pointer
A slash-based path syntax for identifying a value inside a JSON document.
Flattening
Turning nested objects and arrays into table-style path headers and cell values.
Path Atlas
The result view that lists generated paths, value types, coverage, and examples.
Unsafe integer
An integer number too large for exact browser number handling.

References: