CSV to JSON Converter

Convert CSV to JSON the Right Way

CSV looks deceptively simple — values separated by commas, rows separated by newlines — but real-world CSV files are riddled with edge cases: quoted fields containing commas, escaped quotes, embedded newlines, BOMs from Excel, semicolons in European locales, and the occasional rogue line ending. A naive line.split(',') breaks on all of these. This converter implements a proper RFC 4180 parser that handles them correctly, then renders the result as clean, valid JSON.

How the Parser Handles Edge Cases

• Quoted fields with commas — "Doe, John",42 is parsed as two fields: Doe, John and 42. Commas inside quotes are not delimiters.
• Escaped quotes — Two double-quotes inside a quoted field represent one literal double-quote. "He said ""hi""." becomes He said "hi".
• Embedded newlines — A newline inside a quoted field is preserved, not treated as row terminator. Useful for address fields, multi-line comments, and long-form text.
• UTF-8 BOM — Excel and some other tools prepend three magic bytes (EF BB BF) to UTF-8 files. The parser strips this automatically so it doesn't end up as part of the first column name.
• Trailing newline — Most CSV exports end with a newline. The parser ignores empty trailing rows so your JSON doesn't get a phantom null entry at the end.
• Mixed line endings — \r\n (Windows), \n (Unix), and \r (legacy Mac) are all handled.

Choosing the Output Format

Array of objects uses the first row as keys, producing one object per data row:

// Input:
// name,age,city
// Alice,30,Paris
// Bob,25,Berlin

[
  { "name": "Alice", "age": "30", "city": "Paris" },
  { "name": "Bob",   "age": "25", "city": "Berlin" }
]

This is the format you'll feed into JSON.parse and iterate with .map() in JavaScript, or load into a Pandas DataFrame in Python. Use it whenever the CSV has a meaningful header row.

2D array preserves the raw row-and-column structure with no header inference:

[
  ["name", "age", "city"],
  ["Alice", "30", "Paris"],
  ["Bob",   "25", "Berlin"]
]

Use this when you don't trust that the first row is a header, when columns have duplicate names (which break the object form), or when you need positional access in code that doesn't care about column names.

Type Coercion: When to Enable It

By default, every value in the output is a string — even numeric-looking ones like 42. This is intentional. CSV has no type system, and any code that auto-converts can corrupt your data. The classic example: a column of US ZIP codes containing 02134 gets silently converted to the integer 2134, dropping the leading zero. The same problem hits product SKUs, ISBNs, and phone numbers.

Enable Coerce types only when you've confirmed the data is numeric/boolean by nature: financial reports, scientific measurements, sensor readings. The coercion rules are:

• Strings matching /^-?\d+$/ become integers
• Strings matching /^-?\d*\.\d+$/ become floats
• Exact true / false (case-insensitive) become booleans
• Empty strings become null
• Everything else stays a string

If you need to preserve string fidelity but also want types for some columns, do the coercion in code after parsing — it gives you per-column control.

Doing the Same in Code

// Node.js — using csv-parse for streaming
import { parse } from 'csv-parse/sync';
const records = parse(csvString, {
  columns: true,        // array of objects with header keys
  skip_empty_lines: true,
  cast: false           // keep strings; turn on for numeric columns
});

// Python — using csv.DictReader
import csv, json
with open('data.csv', encoding='utf-8-sig') as f:  // utf-8-sig strips BOM
    rows = list(csv.DictReader(f))
print(json.dumps(rows, indent=2))

// Python — using pandas (best for large files)
import pandas as pd
df = pd.read_csv('data.csv', dtype=str)             // dtype=str disables coercion
print(df.to_json(orient='records', indent=2))

For very large files (50 MB+) prefer streaming parsers like csv-parse in Node, pandas.read_csv(chunksize=10000) in Python, or the csv command-line tool. This browser-based converter is great for ad-hoc work; it's not suited for multi-gigabyte ETL.

Common Pitfalls and Fixes

• European-locale CSV uses semicolons, not commas — because the comma is the decimal separator. Switch the Delimiter to ; or use Auto-detect.
• Excel exports as ANSI / Windows-1252 by default — special characters (é, ñ, €) become mojibake. Save as CSV UTF-8 in Excel's Save As dialog.
• Tab-separated values (TSV) are the same idea with \t as delimiter — pick Tab in the dropdown. TSV avoids most quoting issues since tabs rarely appear inside fields.
• Pipe-delimited (PSV) is common in older mainframe exports. Pick Pipe.
• Duplicate column names (e.g., two columns both called Email) break the object form — only the last one wins. Switch to 2D array or rename the columns.

Need to go the other way? Use the JSON to CSV tool (under Related Tools). For ad-hoc filtering, sorting, or aggregating before conversion, our JSON Formatter is the next step.