Delimiter

Flatten

Array join

Headers Excel BOM Force Quotes

Target array (JSONPath):

Input JSON

Waiting

CSV Output

Convert JSON to see table preview

Ready

Schema Discovery — detected columns (click to toggle include/exclude)

Convert JSON to see schema

—

Rows

—

Columns

—

Included

—

Total Cells

—

CSV Size

Free Online JSON to CSV Converter — No Signup Required

Convert JSON to CSV Online —
Nested Flatten, Table Preview & Excel Ready

The most complete JSON to CSV converter online. Handles nested objects with dot-notation flattening, custom delimiters, column selection, live table preview, schema discovery, and Excel BOM — all in your browser.

Nested JSON flattening Live table preview Schema discovery Excel BOM support 100% browser-based

Smart Nested Flattening

Three modes: dot notation, bracket arrays, or keep nested objects as JSON strings in a cell.

Live Table Preview

See your data as a formatted table before downloading. Verify columns look correct.

Schema Discovery

Auto-detects all columns with type badges. Click to exclude unwanted fields before export.

Excel BOM Ready

Add UTF-8 BOM so Excel displays special characters correctly — no garbled text.

How It Works

Convert JSON to CSV in 4 Steps

No installation, no signup. Results in under a second for any file size.

Paste or Upload JSON

Paste a JSON array, upload a .json file, or target a specific nested array using the JSONPath field — for example data.users for wrapped API responses.

Configure Options

Choose delimiter, flatten mode, array joiner character, whether to include headers, Excel BOM, and forced quoting. The schema panel shows detected columns instantly.

Review & Select Columns

The schema panel shows every detected column with its data type. Click any column to toggle it in or out of the export — no need to edit the JSON.

Download or Copy

Switch to Table Preview to verify, then download as .csv or copy to clipboard. Open directly in Excel, Google Sheets, Power BI, or import into any database.

Flatten Modes

Three Ways to Handle Nested JSON

Nested objects are the #1 challenge in JSON to CSV conversion. Choose the mode that matches your target system.

DefaultDot Notation Flatten

Recursively expands nested objects into columns using dot-separated key paths. The most compatible output for Excel, pandas, SQL imports, and most analytics tools.

// Input JSON { "user": { "name": "Alice", "city": "London" }, "score": 97 } // CSV columns produced user.name, user.city, score Alice, London, 97

ArraysBracket Array Mode

Expands arrays into indexed columns rather than joining them. Use when every record has a fixed-length array and you need each element in its own column.

// Input JSON { "name": "Alice", "scores": [90, 85, 92] } // CSV columns produced name, scores[0], scores[1], scores[2] Alice, 90, 85, 92

PreserveKeep as JSON String

Leaves nested objects and arrays as serialized JSON strings inside the CSV cell. Use for database imports that store JSON columns, or when downstream code will parse the nested data itself.

// Input JSON { "name": "Alice", "addr": { "city": "London" } } // CSV columns produced name, addr Alice, "{""city"":""London""}"

What is JSON to CSV Conversion?

Why Convert JSON to CSV — and When Not To

JSON and CSV represent fundamentally different data models. JSON is hierarchical — it supports nested objects, arrays, and mixed types natively. CSV is tabular — flat rows and columns with uniform types per column.

Converting JSON to CSV makes sense when your downstream tool expects flat data: Excel, Google Sheets, Tableau, Power BI, SQL imports, and pandas DataFrames. It does not make sense when your JSON has deeply recursive structures that don't map to a natural table shape — in those cases, keep it as JSON and query it with tools like jq or DuckDB.

The Flattening Problem

The hardest part of JSON to CSV is handling nested objects. A naive converter simply errors or ignores them. Our tool offers three strategies:

Dot notation — expands address.city into its own column. Most compatible
Bracket arrays — expands scores[0], scores[1] into separate columns
Keep as JSON — serializes nested objects as strings. Best for database JSON columns

Missing Keys and Mixed Types

Real-world API responses often have inconsistent schemas — some objects have fields others don't. The converter collects all keys across all rows as the column set, then fills missing values with empty strings. The schema panel flags columns with mixed types in amber so you can investigate before exporting.

Code Equivalent — JSON to CSV in Your Language

Python — pandas (recommended)

import pandas as pd
import json

# Flat JSON array
data = json.load(open("data.json"))
pd.DataFrame(data).to_csv("out.csv", index=False)

# Nested JSON — flatten with json_normalize
df = pd.json_normalize(data, sep=".")
df.to_csv("out.csv", index=False, encoding="utf-8-sig")
# utf-8-sig adds Excel BOM automatically

# Target a nested array (e.g. response["data"]["users"])
wrapped = json.load(open("api.json"))
df = pd.json_normalize(wrapped["data"]["users"])
df.to_csv("users.csv", index=False)

Node.js

const fs    = require("fs");
const data  = JSON.parse(fs.readFileSync("data.json"));

// Collect all headers across all rows
const headers = [...new Set(data.flatMap(r => Object.keys(r)))];

// Build CSV rows with proper RFC 4180 quoting
function quote(v) {
  const s = v == null ? "" : String(v);
  return s.includes(",") || s.includes("
") || s.includes('"')
    ? `"${s.replace(/"/g, '""')}"` : s;
}
const rows = [
  headers.join(","),
  ...data.map(r => headers.map(h => quote(r[h])).join(","))
];
fs.writeFileSync("out.csv", "" + rows.join("
"));

Vanilla JavaScript (Browser)

function jsonToCsv(data, delim = ",") {
  const headers = [...new Set(data.flatMap(r => Object.keys(r)))];
  const q = v => {
    const s = v == null ? "" : String(v);
    return s.includes(delim) || s.includes("
") || s.includes('"')
      ? `"${s.replace(/"/g, '""')}"` : s;
  };
  const rows = [
    headers.join(delim),
    ...data.map(r => headers.map(h => q(r[h])).join(delim))
  ];
  return "" + rows.join("
");
}

// Download helper
const csv = jsonToCsv(myData);
const a   = document.createElement("a");
a.href     = URL.createObjectURL(new Blob([csv], {type:"text/csv"}));
a.download = "output.csv";
a.click();

PHP

$data    = json_decode(file_get_contents("data.json"), true);
$headers = [];
foreach ($data as $row) {
    $headers = array_unique(array_merge($headers, array_keys($row)));
}

$f = fopen("output.csv", "w");
// Add UTF-8 BOM for Excel
fputs($f, "ï»¿");
fputcsv($f, $headers);
foreach ($data as $row) {
    $csv_row = [];
    foreach ($headers as $h) {
        $v = $row[$h] ?? "";
        $csv_row[] = is_array($v) ? json_encode($v) : (string)$v;
    }
    fputcsv($f, $csv_row);
}
fclose($f);

import (
    "encoding/csv"; "encoding/json"; "os"
)

var data []map[string]interface{}
json.Unmarshal(jsonBytes, &data)

// Collect all headers
seen := map[string]bool{}
var headers []string
for _, row := range data {
    for k := range row {
        if !seen[k] { seen[k] = true; headers = append(headers, k) }
    }
}
f, _ := os.Create("out.csv")
f.WriteString("ï»¿") // UTF-8 BOM
w := csv.NewWriter(f)
w.Write(headers)
for _, row := range data {
    var vals []string
    for _, h := range headers {
        if v, ok := row[h]; ok { vals = append(vals, fmt.Sprint(v))
        } else { vals = append(vals, "") }
    }
    w.Write(vals)
}
w.Flush()

Use Cases

When Do You Need JSON to CSV Conversion?

Any workflow where JSON data needs to reach a spreadsheet, database, or BI tool.

API Response → Excel / Google Sheets

REST APIs return JSON. Most stakeholders want Excel. Paste the API response, select columns, and download a spreadsheet-ready CSV in seconds — no code required.

Use dot-notation flatten for nested API responses

NoSQL → SQL Migration

Convert MongoDB, Firestore, or DynamoDB JSON exports to CSV for import into PostgreSQL, MySQL, or SQLite. Dot notation creates the right column names for your table schema.

Use schema panel to verify all columns before export

Power BI / Tableau / Data Studio

BI tools expect flat tabular data. Convert JSON datasets or API outputs to CSV and import directly. The table preview confirms the structure before you commit to the import.

Enable BOM for Power BI compatibility

Log File Analysis

JSON log files from services like Elasticsearch, Datadog, or custom apps can be converted to CSV for analysis in Excel pivot tables or pandas without writing a parser.

Use tab delimiter for log data that contains commas

Data Science / pandas

Convert JSON API responses or scraping output to CSV as the first step in a pandas or R workflow. Use pd.json_normalize() for the same flattening our tool does automatically.

Use Python snippet — json_normalize is pandas' built-in flatten

Sharing with Non-Technical Teams

Product managers, finance, and ops teams can't open raw JSON. Convert and share a clean CSV. Use the column selector to strip technical fields before sharing.

Use schema panel to exclude internal ID fields

FAQ

Frequently Asked Questions

Everything developers ask about converting JSON to CSV.

How do I convert JSON to CSV online?▼

Paste your JSON array into the input panel or upload a .json file. Choose your delimiter, flatten mode, and column options. Click Convert to CSV. Review the live table preview to confirm the output looks correct, then download the .csv file or copy it to clipboard. The tool handles flat arrays, nested objects, and inconsistent schemas automatically.

How does JSON to CSV handle nested objects?▼

Nested objects are flattened using dot notation by default. For example, an object with a nested address containing city and country fields produces CSV columns named address.city and address.country. You can choose bracket mode to expand arrays into indexed columns, or keep-as-JSON mode to serialize nested objects as JSON strings in a single CSV cell.

What JSON structure does this converter accept?▼

The converter expects a JSON array of objects — [{}, {}, {}]. Each object becomes one CSV row. If your API response wraps the array inside an object (like {data: [{}, {}]}), use the JSONPath field to target the inner array. Single objects are wrapped in an array automatically. The tool handles missing keys, mixed types, null values, and schemas that vary between rows.

Why do I need the Excel BOM option?▼

Excel on Windows does not detect UTF-8 encoding by default when opening CSV files. Without a BOM, special characters like accented letters, CJK characters, or emoji appear as garbled text. The BOM (three bytes: EF BB BF) signals to Excel that the file is UTF-8. Always enable BOM if you plan to open the CSV directly in Microsoft Excel.

What delimiter should I use?▼

Use comma for standard CSV compatible with most tools. Use semicolon for Excel in European locales where comma is the decimal separator — Germany, France, Spain, Italy, and most of continental Europe. Use tab for TSV which avoids conflicts when your data contains commas. Use pipe for data that may contain commas and semicolons in values. The tool automatically quotes fields that contain your chosen delimiter.

What happens to arrays inside JSON objects?▼

In dot-notation mode, arrays inside objects are joined into a single cell using the array joiner character you configure (default: semicolon). For example, ["admin", "editor"] becomes admin;editor. In bracket mode, each element gets its own indexed column: roles[0], roles[1]. For nested arrays of objects, the tool flattens each inner object into dot-notation columns.

How do I convert JSON to CSV in Python?▼

The easiest way is pandas: import pandas as pd; df = pd.json_normalize(json_data, sep="."); df.to_csv("output.csv", index=False, encoding="utf-8-sig"). The encoding="utf-8-sig" adds the Excel BOM automatically. For simple flat arrays without nesting, pd.DataFrame(data).to_csv("output.csv", index=False) is enough. The online tool does the same thing for one-off conversions without any code.

Is my JSON data safe to paste into this tool?▼

Yes. All conversion logic runs entirely in your browser using JavaScript. Your JSON — including API keys, database exports, or records with PII — is never sent to any server, never stored, and never logged. You can verify this by opening your browser Network tab and clicking Convert — zero outbound requests are made during the entire conversion.

Related Guides