CSV (Comma-Separated Values) is one of the oldest and most widely used data interchange formats in computing. Despite its simplicity -- or perhaps because of it -- CSV has endured for decades as the lingua franca of tabular data exchange. Virtually every spreadsheet application, database system, data analysis tool, and programming language supports CSV import and export.
At its core, a CSV file is plain text where each line represents a row of data and values within each row are separated by a delimiter, traditionally a comma. The first line typically contains column headers that name each field.
name,email,age,city
Alice Johnson,alice@example.com,32,New York
Bob Smith,bob@example.com,28,San Francisco
Carol Davis,carol@example.com,45,ChicagoCSV's greatest strength is its simplicity: it can be created and read with any text editor, processed with basic command-line tools, opened in any spreadsheet, and parsed with minimal code. Its greatest weakness is the lack of a strict standard, leading to incompatibilities between different tools and implementations.
Common use cases for CSV include database exports and imports, spreadsheet data interchange, log file analysis, data migration between systems, business reporting, scientific data storage, and configuration data for batch processing.
RFC 4180 is the closest thing CSV has to an official standard. Published in 2005, it defines the "Common Format and MIME Type for Comma-Separated Values (CSV) Files" with the MIME type text/csv.
"").# Field with comma -- must be quoted
"New York, NY",10001,US
# Field with double quote -- quotes are doubled
"She said ""hello""",greeting,informal
# Field with line break -- must be quoted
"Line 1
Line 2",multiline,field
# Field without special characters -- quoting optional
Alice,alice@example.com,32Despite RFC 4180, many CSV implementations deviate from the standard:
\") instead of double-quote doubling.JSON (JavaScript Object Notation) represents tabular data differently from CSV. Rather than a flat grid of values, JSON uses an array of objects where each object represents a row and each key-value pair represents a column.
[
{
"name": "Alice Johnson",
"email": "alice@example.com",
"age": 32,
"city": "New York"
},
{
"name": "Bob Smith",
"email": "bob@example.com",
"age": 28,
"city": "San Francisco"
},
{
"name": "Carol Davis",
"email": "carol@example.com",
"age": 45,
"city": "Chicago"
}
]The basic algorithm for converting CSV to JSON involves parsing the CSV into rows and columns, then mapping each row to a JSON object using the header row as keys.
1. Parse the first row as column headers
2. For each subsequent row:
a. Split the row into fields (respecting quoted fields)
b. Create a JSON object
c. Map each field to its corresponding header key
d. Optionally detect and convert types (numbers, booleans)
3. Collect all objects into a JSON array
4. Serialize to JSON stringfunction csvToJson(csv, delimiter = ',') {
const lines = csv.split('\n').filter(line => line.trim());
const headers = parseCsvLine(lines[0], delimiter);
const result = [];
for (let i = 1; i < lines.length; i++) {
const values = parseCsvLine(lines[i], delimiter);
const obj = {};
headers.forEach((header, index) => {
obj[header.trim()] = values[index]?.trim() ?? '';
});
result.push(obj);
}
return result;
}import csv
import json
def csv_to_json(csv_file_path):
with open(csv_file_path, 'r') as f:
reader = csv.DictReader(f)
return json.dumps(list(reader), indent=2)There are several ways to structure the JSON output:
// Array of objects (most common)
[{"name": "Alice", "age": 32}, {"name": "Bob", "age": 28}]
// Array of arrays (compact, preserves order)
[["name", "age"], ["Alice", 32], ["Bob", 28]]
// Object with column arrays (columnar format)
{"name": ["Alice", "Bob"], "age": [32, 28]}
// Keyed by a unique field
{"alice@ex.com": {"name": "Alice", "age": 32}, ...}Converting JSON to CSV is conceptually the reverse: extract the set of all keys (for headers), then output each object as a row of values.
1. Collect all unique keys across all objects (union of keys)
2. Output the keys as the CSV header row
3. For each object:
a. For each header key, extract the value (or empty string if missing)
b. Quote values that contain delimiters, quotes, or newlines
c. Output as a CSV row
4. Handle nested objects/arrays (flatten or stringify)JSON-to-CSV conversion introduces several challenges that do not exist in the reverse direction:
Parsing CSV correctly requires careful handling of delimiters, quoting, and escaping. Many bugs in CSV processing stem from naive parsing that fails on edge cases.
// DON'T DO THIS -- fails on quoted fields
const fields = line.split(',');
// Fails on: "New York, NY",10001
// Produces: ['"New York', ' NY"', '10001']
// Expected: ['New York, NY', '10001']A correct CSV parser must implement a state machine that tracks whether the current position is inside or outside a quoted field. When inside a quoted field, commas and newlines are treated as literal characters, not separators.
// Simplified CSV line parser
function parseCsvLine(line, delimiter = ',') {
const fields = [];
let current = '';
let inQuotes = false;
for (let i = 0; i < line.length; i++) {
const char = line[i];
if (inQuotes) {
if (char === '"') {
if (line[i + 1] === '"') {
current += '"'; // Escaped quote
i++;
} else {
inQuotes = false; // End of quoted field
}
} else {
current += char;
}
} else {
if (char === '"') {
inQuotes = true;
} else if (char === delimiter) {
fields.push(current);
current = '';
} else {
current += char;
}
}
}
fields.push(current);
return fields;
}Many CSV files use delimiters other than commas. Understanding common alternatives helps when auto-detecting or configuring parsers:
Delimiter Name Common Use Case
-------------------------------------------------
, Comma Standard CSV (most common)
\t Tab TSV files, database exports
; Semicolon European locales (where , is decimal)
| Pipe Data with commas and quotes
\x01 SOH Hive/Hadoop data (control character)CSV stores everything as text, but JSON supports distinct types. When converting CSV to JSON, you must decide how to handle type detection.
CSV Value Possible JSON Types
--------------------------------------------
"42" number (42) or string ("42")
"3.14" number (3.14) or string ("3.14")
"true" boolean (true) or string ("true")
"false" boolean (false) or string ("false")
"" null or string ("")
"null" null or string ("null")
"2026-03-12" string (JSON has no date type)
"1,234.56" string (comma prevents number parsing)Aggressive type detection can cause problems. A ZIP code like "01234" would lose its leading zero if converted to a number (1234). A phone number like "5551234567" should remain a string despite being numeric. Product IDs, account numbers, and other numeric-looking identifiers should generally stay as strings.
The safest approach is to keep all values as strings by default and only convert types when explicitly requested or when the data schema is known. This preserves all information and avoids silent data corruption.
// Conservative: everything is a string
{"zip": "01234", "phone": "5551234567", "count": "42"}
// Aggressive: auto-detect types (risky)
{"zip": 1234, "phone": 5551234567, "count": 42}
// Schema-aware: convert only known numeric fields
{"zip": "01234", "phone": "5551234567", "count": 42}One of the biggest challenges in CSV/JSON conversion is handling data that does not fit neatly into a flat table structure.
// Input JSON
{
"name": "Alice",
"address": {
"street": "123 Main St",
"city": "New York",
"state": "NY"
},
"tags": ["admin", "user"]
}
// Flattened CSV (dot notation)
name,address.street,address.city,address.state,tags
Alice,"123 Main St","New York",NY,"admin,user"
// Alternative: JSON-stringify nested values
name,address,tags
Alice,"{""street"":""123 Main St"",""city"":""New York"",""state"":""NY""}","[""admin"",""user""]"// Input JSON
{"name": "Alice", "skills": ["Python", "JavaScript", "SQL"]}
// Expanded to multiple rows
name,skill
Alice,Python
Alice,JavaScript
Alice,SQLOur CSV to JSON Converter handles bidirectional conversion between CSV and JSON with full support for RFC 4180 quoting, custom delimiters, type detection options, and nested object flattening.
Paste CSV data and get instant JSON output, or paste JSON and get properly quoted CSV. The tool auto-detects delimiters, handles multiline quoted fields, and lets you choose between conservative and aggressive type detection. It processes everything locally in your browser -- no data is sent to any server.
CSV (Comma-Separated Values) is a plain text format for storing tabular data where each line is a row and values are separated by commas. It is defined in RFC 4180 and is universally supported by spreadsheets, databases, and programming languages.
Fields containing commas must be enclosed in double quotes: "New York, NY". Double quotes within quoted fields are escaped by doubling: "She said ""hello""".
CSV is best for flat tabular data and is more compact. JSON supports nested objects, arrays, and typed values, making it better for complex data structures. JSON is self-describing (includes field names), while CSV is more spreadsheet-friendly.
Parse the first row as headers, then for each subsequent row create a JSON object mapping header names to cell values. Collect all objects into an array. Use a proper CSV parser to handle quoted fields correctly.
Yes, but nested structures must be flattened. Common approaches include dot notation for keys (address.city), JSON-stringifying nested values, or creating separate CSV files for each nesting level.
Common alternatives include tabs (TSV), semicolons (European locales), and pipes. The delimiter should be consistent within a file and documented or auto-detectable.