Best Free Online JSON to CSV Converter 2026 — I Tested 5
Photo by Myriam Jessier on Unsplash
Table of Contents
The API Response That Wouldn't Open in Excel
I handed her the JSON file. She opened it in Excel. Excel showed one cell with the entire raw JSON string. She handed it back to me.
Fair enough. JSON and spreadsheets are two very different data shapes, and converting between them manually would've taken an hour. I opened three different online converters, pasted the JSON, hit convert, and compared the results. Two of them mangled the nested objects. One produced a CSV that opened correctly but lost about 200 rows. The third worked perfectly.
That experience made me actually sit down and test five tools properly — with nested objects, arrays of arrays, null values, escaped quotes inside strings, and a large dataset. Here's what I found.
The context for why this matters: JSON is tree-structured (objects can contain objects can contain arrays), and CSV is flat (rows and columns). Converting between them requires decisions about how to handle nesting. Every tool makes different choices, and some of those choices destroy your data silently.
Why JSON-to-CSV Is Harder Than It Looks
```json [ {"id": 1, "name": "Alice", "email": "alice@example.com"}, {"id": 2, "name": "Bob", "email": "bob@example.com"} ] ```
That maps to CSV directly. But real API data almost never looks like this.
Here's where it gets messy:
**Nested objects** — `{"user": {"id": 1, "name": "Alice"}}`. Some tools produce two columns: `user.id` and `user.name` (dot notation, my preference). Others stringify the nested object into a single cell as `{"id":1,"name":"Alice"}` (usually useless in a spreadsheet). Others just drop nested objects entirely.
**Arrays inside objects** — `{"tags": ["typescript", "react"]}`. Should this become one cell with `typescript,react`? Three separate columns (`tags.0`, `tags.1`, `tags.2`)? Or one row per tag value (which changes your total row count)? There's no universally right answer — it depends on your use case.
**Mixed schemas** — Real API responses often have optional fields. One object has a `metadata` key, others don't. A good converter produces empty cells for missing fields. A bad one either errors out or drops the rows with missing keys.
**Special characters in values** — A value containing commas needs to be quoted. A value containing quotes needs them escaped. A value containing newlines needs careful handling. Most converters handle this for standard cases but get weird with unusual combinations.
I tested all five tools with: a clean flat array, a nested-object array, an array-of-arrays, a dataset with optional fields (mixed schema), and a 10,000-row export from our analytics tool. That last test is where the really interesting differences showed up — processing speed and whether the browser tab survived.
If you're working with the JSON itself before conversion, the JSON formatter at ToolsFuel is useful for validating and prettifying the structure so you can see what you're dealing with before feeding it to a converter.
Tool 1: JSON to CSV by Konklone — Simple and Reliable
Photo by Florian Olivo on Unsplash
It handles the flat array case correctly. For nested objects, it flattens them with dot notation: `user.id`, `user.name`. For arrays inside objects, it concatenates values with pipe separators by default: `typescript|react`. That's a reasonable convention.
Where it breaks down: very large JSON files. I threw 10,000 rows at it and the browser stalled for about 20 seconds before producing the output. Not a crash — just slow. For anything over a few thousand rows, you'll want a different approach.
Mixed schemas (optional fields) were handled correctly — empty cells for missing keys, consistent column order based on the first row's keys.
It's open-source, runs entirely in the browser, and the code is clean enough to fork if you need custom behavior. For one-off conversions of API data under a couple thousand rows, it's my first recommendation.
**Verdict**: Best for simple conversions. A bit slow on large files. No download button — you copy the output (not ideal for huge datasets).
Tool 2: JSON CSV by DannyDainton — Best for Large Files
On my 10,000-row test it was noticeably faster than konklone — about 3 seconds. The output had a download CSV button that produced a clean file, not a copy-paste job.
Nested object handling: same dot-notation flattening as konklone, which is the right call. Array values were handled less gracefully — arrays were stringified as JSON rather than piped, which means your nested arrays come out as `["typescript","react"]` inside a CSV cell. Usable but ugly.
The free tier has a row limit for very large files (I hit it around 50,000 rows). For most developer use cases — API responses, exports under a few hundred thousand rows — you're fine.
This is the tool I'd recommend for production data work where you need downloads and speed. The UX is clean, errors are surfaced with helpful messages (not silent failures), and the download flow is the smoothest I tested.
**Verdict**: Best overall for practical use — fast, has download button, clear UI. Array handling is less elegant but functional.
Tools 3-5 and My Final Recommendation
**Csvjson (csvjson.com/json2csv)** — Written by Martin Drapeau, focused specifically on the JSON-to-CSV case. Clean single-purpose interface, handles nested objects with dot notation, handles arrays by joining with commas. Ran fine on my large file test without notable lag. The UI is barebones but it works. I'd put it in the same tier as konklone but with slightly better large-file performance.
**BeautifyTools JSON to CSV (beautifytools.com)** — Part of a large utilities suite. It worked on the flat array case and simple nesting. Failed silently on my mixed-schema test — just dropped rows where a field was missing rather than producing empty cells. That's a data-loss bug you'd only notice if you checked the row count. I wouldn't recommend it for production data.
**My final ranking:**
1. **json-csv.com** — Best for real work: fast, download button, clear errors, handles large files. 2. **konklone.io/json** — Best for quick one-off conversions, clean copy output. 3. **csvjson.com** — Solid alternative to konklone, slightly better on large files. 4. **convertcsv.com** — Best if you need XLSX output or unusual delimiter options. 5. **BeautifyTools** — Skip for data-critical work (silent row drops).
For validating your JSON before running the conversion, I use the JSON formatter at ToolsFuel — pasting 10,000 rows of JSON into a formatter first to catch any syntax errors saves a lot of confusion if the converter gives a cryptic error message. And if your API returns URL-encoded data that you need to decode before parsing as JSON, the URL encoder/decoder handles that step.
One non-obvious tip: for really large files (100MB+), you're better off doing the conversion programmatically with a Node.js library like `json2csv` or Python's `pandas`. Online tools hit browser memory limits above a certain size, and you'll get browser crashes rather than useful error messages.
Writing the Conversion Yourself (When You Need Control)
```javascript function jsonToCsv(jsonArray) { if (!jsonArray.length) return '';
// Collect all unique keys from all rows (handles mixed schemas) const headers = [...new Set(jsonArray.flatMap(obj => Object.keys(obj)))];
const csvRows = [ headers.join(','), // header row ...jsonArray.map(row => headers.map(header => { const value = row[header] ?? ''; // empty string for missing fields const str = typeof value === 'object' ? JSON.stringify(value) : String(value); // Wrap in quotes if value contains commas, quotes, or newlines return /[,"\n]/.test(str) ? `"${str.replace(/"/g, '""')}"` : str; }).join(',') ) ];
return csvRows.join('\n'); }
// Usage const csv = jsonToCsv(myApiResponse); const blob = new Blob([csv], { type: 'text/csv' }); const url = URL.createObjectURL(blob); // trigger download via <a> tag ```
This handles the common cases: mixed schemas (different keys across rows), values containing commas (wrapped in quotes), values containing quotes (doubled per RFC 4180). What it doesn't handle: deeply nested objects. For those, add a recursive flattening step before the conversion, or use the `flat` npm package.
The CSV spec is RFC 4180 — much shorter and more readable than most RFCs if you want to know the actual quoting and escaping rules.
Frequently Asked Questions
Can I convert JSON to CSV without losing nested object data?
Yes, but it requires a decision about how to represent nesting in a flat format. The two common approaches are: flatten with dot notation (a nested object {user: {id: 1}} becomes a column named 'user.id'), or stringify nested objects into a single cell. Most good converters default to dot-notation flattening. For arrays inside objects, common options are pipe-separating the values, joining with commas, or creating separate columns per array index. There's no one-size-fits-all answer — it depends on how you'll use the resulting CSV.
What's the best way to handle JSON arrays with different keys in each object?
Mixed schemas (different keys across objects in the same array) should produce a CSV where every possible key becomes a column header, and missing values become empty cells. Not all converters handle this correctly — some drop rows with missing keys. Tools like konklone.io/json and json-csv.com handle this correctly. If you're writing the conversion yourself, collect all unique keys across the entire array before generating the headers, rather than assuming all objects have the same keys as the first row.
Why does my CSV open correctly in a text editor but display wrong in Excel?
Usually a delimiter or encoding issue. Excel defaults to comma-separated in most locales, but some European locale Excel installations expect semicolons. If your values contain commas that weren't properly quoted, columns will shift. Another common cause is UTF-8 encoding without a BOM (byte order mark) — Excel on Windows sometimes misreads UTF-8 CSV without the BOM, garbling accented characters. Add a UTF-8 BOM to your CSV file or save as UTF-8 with BOM in your converter settings.
Is there a size limit for online JSON to CSV converters?
Yes — browser-based tools have practical limits based on available memory. Most online converters handle files up to a few megabytes without issues. Files in the range of 10-50MB may be slow. Files over 50-100MB will often crash the browser tab. For large datasets, use a command-line tool (Python's pandas, Node.js json2csv package, or jq) instead of an online converter. These process data in streams and aren't limited by browser memory.
How do I handle special characters like commas and quotes in CSV values?
Per RFC 4180, values containing commas, double quotes, or newlines must be wrapped in double quotes. Any double quotes within a quoted value must be escaped by doubling them: 'She said, "hello"' becomes '"She said, ""hello"""' in the CSV. Most converters handle this automatically. If you're generating CSV manually in code, always check for these cases — a value containing a comma that isn't quoted will silently break your column alignment.
Can I convert CSV back to JSON?
Yes, most tools that do JSON-to-CSV also do CSV-to-JSON in the other direction. convertcsv.com handles both. csvjson.com has a dedicated csv2json page. Programmatically, Python's csv module or Node.js's csv-parse library are the standard options. The reverse conversion is generally simpler since CSV is already flat — you just map each row to an object keyed by the header row. The [JSON formatter at toolsfuel.com/tools/json-formatter](/tools/json-formatter) can help you inspect and validate the JSON output after conversion.
Try ToolsFuel
23+ free online tools for developers, designers, and everyone. No signup required.
Browse All Tools