In short: what does a JSON to CSV converter do?
A JSON to CSV converter turns hierarchical JSON — objects, arrays and nested structures — into a flat, tabular CSV spreadsheet with rows and columns. This platform flattens nested objects into dot-notation columns, expands arrays into rows, and lets you map fields, clean data, profile columns and export to CSV, Excel, SQL, XML, YAML, Markdown and more — all 100% in your browser, with no data ever uploaded.
Smart conversion
Flatten nested JSON to a clean table with a live spreadsheet preview.
Field mapping
Include, exclude, rename and reorder columns before export.
Array strategies
Expand to rows, index to columns, join or stringify — your choice.
Data profiling
Per-column types, null counts and a 0–100 quality score.
9 export formats
CSV, TSV, Excel, SQL, HTML, Markdown, XML, YAML & JSON.
100% private
Everything runs in your browser. Your data is never uploaded.
What is JSON to CSV conversion?
JSON (JavaScript Object Notation) is a hierarchical, typed data format: it nests objects inside objects and holds arrays of values, which makes it perfect for APIs and configuration but awkward for analysis. CSV (Comma-Separated Values) is the opposite — a flat grid of rows and columns that every spreadsheet, database and BI tool understands instantly. JSON to CSV conversion is the process of flattening that hierarchy into a table so the data can be opened in Excel, imported into a database, or analysed in a notebook.
The conversion sounds trivial but rarely is. Real JSON contains nested objects (user.address.city), arrays of primitives (tags: ["a", "b"]) and arrays of objects (orders: [{...}, {...}]). A naive converter dumps these into a single unreadable cell. A proper converter — like this one — gives you control: nested keys become path-notation columns, and arrays can be expanded into multiple rows, indexed into numbered columns, joined into one cell, or kept as raw JSON. That flexibility is what turns messy API output into a clean, analysis-ready dataset.
JSON vs CSV: understanding the trade-off
Each format is optimised for a different job. Converting between them means trading hierarchy for tabular simplicity.
| Aspect | JSON | CSV |
|---|---|---|
| Structure | Hierarchical / nested | Flat rows & columns |
| Data types | Typed (number, bool, null) | Untyped text |
| Readability for humans | Good for structure | Great for tables |
| Spreadsheet support | Needs conversion | Native |
| Database import | Needs mapping | Direct (COPY / LOAD DATA) |
| Size | Larger (repeated keys) | Compact |
| Best for | APIs, configs, documents | Analytics, exports, BI |
The rule of thumb: keep data as JSON while it moves between systems, and convert to CSV when a human or a spreadsheet needs to read it. Because this tool also converts CSV, XML and YAML back to JSON, it works as a two-way bridge in either direction.
When to convert JSON to CSV
Converting to CSV is the right move whenever data needs to leave the world of code and enter the world of analysis:
- Sharing with non-developers — analysts, marketers and managers live in spreadsheets, not JSON viewers.
- Importing into databases —
COPY(Postgres),LOAD DATA INFILE(MySQL) and.import(SQLite) all take CSV. - Loading into BI tools — Tableau, Power BI, Looker and Google Sheets ingest CSV effortlessly.
- Data science & ML —
pandas.read_csv()is the de-facto entry point for tabular analysis. - Bulk exports & reporting — turning an API's paginated JSON into a single downloadable dataset.
- Archiving — CSV is a durable, tool-agnostic format for long-term storage.
Working with API data
The single most common reason to convert JSON to CSV is to make sense of an API response. REST and GraphQL endpoints return deeply nested JSON: a list of records, each with sub-objects for relationships and arrays for one-to-many data. Pulling that into a table is the first step of nearly every analysis.
A typical workflow with this tool:
- Capture the response — paste it, or fetch it directly from a URL in the import bar.
- Flatten — nested fields like
data.user.emailbecome columns automatically. - Expand arrays — an
itemsarray of objects becomes one row per item, repeating the parent fields. - Map & rename — drop internal fields, reorder columns and give them friendly headers.
- Export — download CSV for Excel, or SQL to load straight into a database.
Because every step runs client-side, you can safely paste responses that include access tokens, internal IDs or personal data — nothing is sent to a server.
JSON flattening guide
Flattening is the heart of JSON-to-CSV conversion: collapsing a tree into a single level of columns. This platform gives you fine-grained control over how it happens.
Path notation determines how nested keys are named:
- Dot —
user.address.city(the most common, spreadsheet-friendly style). - Bracket —
user[address][city](mirrors how code accesses the value). - Underscore —
user_address_city(safe for database column names).
Array handling is where converters differ most. You can choose per conversion:
| Mode | What it does | Best for |
|---|---|---|
| Expand | One row per array element | Arrays of objects (orders, items) |
| Index | Numbered columns: tags.0, tags.1 | Short, fixed-length arrays |
| Join | Concatenate into one cell | Arrays of tags/labels |
| Stringify | Keep raw JSON in the cell | Preserving nested structure |
You can also set a maximum flattening depth so very deep structures are serialized as JSON strings instead of producing hundreds of sparse columns — a pragmatic balance between detail and readability.
CSV export best practices
- Always include a header row so columns are self-describing when the file is opened elsewhere.
- Pick the right delimiter for your locale. Use a comma for standard CSV, but a semicolon for European Excel where the comma is a decimal separator.
- Quote fields that contain the delimiter, quotes or newlines. This tool does it automatically per RFC 4180.
- Add a UTF-8 BOM for Excel. The downloads include one so accented characters and emoji render correctly.
- Normalise headers for databases — lowercase, snake_case, no spaces — using the cleaning options.
- Remove empty rows and duplicates before export to keep the dataset tidy.
- Verify in the preview — sort and search the live table to catch issues before you download.
Data transformation techniques
Converting format is only half the job — real datasets need transformation before they are useful. This platform bundles the core steps of a lightweight ETL (Extract, Transform, Load) pipeline into the browser:
- Field selection & reordering — include only the columns you need, in the order you want them.
- Renaming — turn
profile.email_addressinto a cleanEmailheader. - Cleaning — trim whitespace, drop empty rows, remove duplicates and normalise headers.
- Type awareness — the profiler infers integer, decimal, boolean, date, email and URL types per column.
- Reshaping arrays — denormalise one-to-many data with Expand, or keep it compact with Join.
Together these mean you can go from a raw API payload to a warehouse-ready table without writing a line of code or installing anything.
JSON for analytics & data profiling
Before you trust a dataset, you should understand it. The Analyze tab profiles every output column and assigns a data-quality score across four dimensions:
- Completeness — how many cells are filled rather than empty.
- Consistency — how uniformly each column sticks to a single data type.
- Validity — how many values match the expected format (e.g. valid emails or dates).
- Uniqueness — how many rows are duplicates.
For each column you also get the dominant type, unique-value count, null count, fill rate, min/max (and average for numeric columns) and the most frequent values. That profile tells you instantly whether a column is a good key, whether a field is mostly empty, or whether dates are formatted inconsistently — the kind of insight that prevents a broken dashboard downstream.
Spreadsheet & database import guide
Once you have a CSV (or Excel/SQL export), getting it into your tool of choice is straightforward:
- Microsoft Excel — open the .csv directly, or use the Excel (.xls) export for a pre-styled sheet. For non-comma locales, choose the semicolon delimiter.
- Google Sheets — File → Import → Upload, and pick "Detect automatically" for the separator.
- PostgreSQL —
COPY table FROM 'data.csv' CSV HEADER;, or use the SQL export which includes CREATE TABLE + INSERTs. - MySQL —
LOAD DATA INFILE 'data.csv' INTO TABLE t FIELDS TERMINATED BY ','; - pandas —
pd.read_csv('data.csv')for instant analysis in Python.
The SQL export is especially convenient: it infers column types (INTEGER, DECIMAL, BOOLEAN, VARCHAR) from your actual data and emits a ready-to-run script, so you can create and populate a table in one paste.
Why use this JSON to CSV platform
Most online converters do one thing: paste JSON, get a CSV blob, hope the nesting worked. This platform is built for the full data-transformation workflow. It flattens arbitrarily nested JSON with configurable path and array strategies, lets you visually map, rename and reorder columns, cleans and de-duplicates rows, profiles every column with a quality score, and exports to nine formats — CSV, TSV, Excel, SQL, HTML, Markdown, XML, YAML and JSON — while also converting those formats back to JSON. It generates JSON Schema, TypeScript interfaces and SQL table definitions from your data, and runs entirely client-side for total privacy and offline capability. For developers, analysts and data engineers who move data between APIs, spreadsheets and databases every day, it is a complete, browser-based ETL companion.
Frequently asked questions
Paste, upload or drag-and-drop your JSON into the editor and the tool converts it to CSV instantly. You get a live spreadsheet preview and can copy or download the result as .csv. Nested objects are flattened automatically using dot notation, and arrays are handled according to the strategy you choose. Everything runs in your browser — your data is never uploaded.
Nested objects are flattened into columns using path notation. For example, {"user": {"name": "Ada", "city": "London"}} becomes the columns user.name and user.city. You can switch between dot notation (user.name), bracket notation (user[name]) or underscore notation (user_name), and cap the flattening depth so very deep structures are stringified instead.
You choose how arrays are converted: Expand creates one CSV row per array element (denormalizing the data, ideal for arrays of objects); Index creates numbered columns like tags.0, tags.1; Join concatenates primitive values into a single cell with a separator; and Stringify keeps the raw JSON array in one cell. Expand is the default because it produces the most spreadsheet-friendly output.
Yes — that is one of the most common uses. Paste a REST or GraphQL API response (or fetch it directly from a URL) and the converter flattens the nested structure into a clean table you can open in Excel, Google Sheets or a database. Because processing is local, you can safely convert responses containing tokens or internal data.
Yes. The Export tab offers Excel (.xls), CSV, TSV, SQL, HTML table, Markdown table, XML, YAML and JSON. The Excel export opens directly in Microsoft Excel, LibreOffice Calc and Google Sheets with the columns and header styled.
Flattening is automatic. The engine walks the JSON tree and turns every nested key into a column using path notation. You control the path style (dot/bracket/underscore), the maximum depth, and how arrays are treated. The Structure tab also lets you explore the JSON as an interactive tree before converting.
Yes. The Field Mapping tab lists every detected column. You can include or exclude any field, rename a column to a friendlier header, and reorder columns up or down. Only the columns you keep — in the order you set — appear in the exported CSV or spreadsheet.
Yes. In the Field Mapping tab, each detected field has an editable output name. The original JSON path stays intact internally while the CSV header shows your chosen label — useful for turning user.profile.email into simply Email.
Yes. The flattener is recursive and handles arbitrarily deep structures. For extreme nesting you can set a maximum depth so deeper values are serialized as JSON strings rather than producing hundreds of columns. A safety cap also prevents pathological inputs (many large nested arrays under Expand) from exploding the row count.
You can output comma (standard CSV), semicolon (common in European locales where the comma is a decimal separator), tab (TSV) or pipe-delimited files. Fields containing the delimiter, quotes or newlines are automatically quoted and escaped per RFC 4180.
JSON is a hierarchical, typed format that represents nested objects and arrays — ideal for APIs and configuration. CSV is a flat, tabular format (rows and columns) understood by every spreadsheet and database. Converting JSON to CSV means flattening the hierarchy into a grid, which is exactly what this tool automates.
Completely. All parsing, flattening, transformation and export run locally in your browser using JavaScript — nothing is uploaded to a server, logged or stored remotely. That makes the tool safe for proprietary datasets, API responses with credentials and regulated data.
Yes. It is 100% free with no sign-up, no usage limits and no watermarks. Convert, map, clean and export as much data as you like, in any supported format.
Yes. The Reverse tab converts CSV, TSV, XML and YAML back into JSON, inferring numbers and booleans automatically. This makes the tool a two-way bridge between tabular and hierarchical formats.
Select SQL in the Export tab. The tool generates a CREATE TABLE statement with column types inferred from your data (INTEGER, DECIMAL, BOOLEAN, VARCHAR) followed by INSERT statements for every row — ready to run in PostgreSQL, MySQL or SQLite.
Yes. The Export tab can produce a GitHub-flavored Markdown table or a clean HTML <table>, both built from the same flattened data, so you can drop your dataset straight into documentation, a README or a web page.
Yes — an array of objects is the ideal input. Each object becomes a CSV row and the union of all keys becomes the header, so objects with slightly different shapes are merged into one consistent table with empty cells where a key is missing.
The converter collects the union of all keys across every object in first-seen order. Rows that lack a particular key get an empty cell for that column, so heterogeneous data still produces a valid, rectangular CSV.
The Analyze tab profiles every output column: it detects the dominant data type, counts unique and null values, computes min/max/average for numeric columns, lists the most frequent values, and assigns a per-column and overall data-quality score across completeness, consistency, validity and uniqueness.
Yes. The cleaning options let you remove empty rows and columns, drop duplicate rows, trim whitespace and collapse repeated spaces, and normalize headers to snake_case — all before export, so the CSV you download is analysis-ready.
Yes. The live preview renders your converted data as an interactive spreadsheet with sortable, searchable columns, sticky headers and pagination, so you can verify the output and spot issues before exporting.
The tool handles multi-megabyte files comfortably in the browser, with virtualized rendering keeping the preview responsive. For very large datasets the row generation is capped to protect performance, and we recommend splitting extremely large files. No data leaves your device regardless of size.
Yes. The import bar lets you fetch JSON directly from a public URL or API endpoint (subject to the remote server's CORS policy), in addition to pasting, uploading or dragging files.
Standard JSON (a single value or an array) is fully supported. For newline-delimited JSON, wrap the objects in an array or paste them as an array; each object then becomes a row in the output.
CSV, TSV, Excel (.xls), SQL (CREATE TABLE + INSERTs), HTML table, Markdown table, XML, YAML and pretty JSON — all generated client-side from the same flattened dataset.
The tool can derive a JSON Schema (Draft-07), TypeScript interfaces and a SQL CREATE TABLE structure from your data, giving you a typed contract and a database table definition alongside the converted rows.
CSV itself is untyped (every cell is text), so numbers and booleans are written as their literal text (42, true). When converting back to JSON, or when profiling, the tool re-infers these types automatically.
For tabular outputs (CSV, Excel, SQL) flattening is required because those formats are flat. If you want to preserve the hierarchy, export to XML, YAML or JSON instead, or use the Index/Stringify array modes to retain nested structure within cells.
Yes. Values containing commas, quotes, newlines or the chosen delimiter are escaped per RFC 4180, and full Unicode (including emoji and non-Latin scripts) is preserved in every output format.
Absolutely. The combination of flattening, field mapping, cleaning, profiling and multi-format export makes the tool a lightweight, browser-based ETL step: extract from an API, transform (flatten/clean/map) and load into a spreadsheet, database or warehouse-ready format.
Yes. Because everything runs client-side, conversion keeps working without a connection once the page has loaded, and the interface is fully responsive — the preview table scrolls horizontally and adapts to small screens.
Download the CSV (or Excel) export and open it in Excel, Google Sheets or Numbers — they recognise the format automatically. For locale-specific spreadsheets, choose the semicolon delimiter so columns split correctly.
Related Tools
Explore More Tools
Go ad-free & unlock power features
- Zero ads, faster focused workflow
- Upload 50MB+ files & batch process
- Priority AI type & schema generation