CSV to JSON Converter
Convert any CSV file or pasted tabular data into a structured JSON array of objects, array of arrays, keyed dictionary, or NDJSON (JSON Lines) instantly. Automatically detects common delimiters (comma, semicolon, tab, pipe), parses RFC 4180 compliant quoted fields, auto-detects data types, allows schema column customization, and strips Excel UTF-8 BOM characters. Runs 100% privately in your browser.
Convert any CSV file or pasted tabular data into a structured JSON array of objects, array of arrays, keyed dictionary, or NDJSON (JSON Lines) instantly. Automatically detects common delimiters (comma, semicolon, tab, pipe), parses RFC 4180 compliant quoted fields, auto-detects data types, allows schema column customization, and strips Excel UTF-8 BOM characters. Runs 100% privately in your browser.
This tool is designed to provide a seamless experience for developers by handling complex operations directly in your browser with maximum speed and security.
A CSV to JSON converter is a tool that reads tabular data structured as rows and columns — separated by a delimiter character — and transforms it into a JSON array of objects. Each row after the first becomes one JSON object, and the column names from row one become the keys for every object in the array.
That description makes it sound simple. The implementation is anything but.
CSV has been around since the early 1970s and was standardised (loosely) by RFC 4180 in 2005. Despite that standard, virtually every system that exports CSV does it slightly differently. Excel on Windows adds a UTF-8 BOM at the start of the file. European locale systems use semicolons instead of commas as the delimiter because commas are used as decimal separators in those regions. Some systems wrap every field in double quotes; others wrap only fields that contain special characters; others wrap nothing and hope for the best. Some use CRLF line endings; others use LF only. Some embed actual newlines inside quoted fields. A naive parser that just splits on commas will break on every single one of these cases.
A production-grade CSV to JSON converter handles all of it: RFC 4180 quoted fields that contain the delimiter, escaped double quotes inside strings, multi-line values wrapped in quotes, BOM stripping, flexible delimiter detection, and consistent line-ending normalisation. That is what this tool does — and it does all of it in your browser, without sending a single byte of your data to any server.
JSON (JavaScript Object Notation) is the format that modern APIs, web applications, and configuration systems actually consume. It has a type system (strings, numbers, booleans, null, arrays, objects), it is natively understood by JavaScript, Python, Go, Rust, and virtually every other language used in production today, and it maps directly onto the data structures those languages use. CSV has none of these properties. Converting between them is one of those tasks that appears in nearly every data pipeline, every migration project, and every integration workflow — which is why having a reliable, edge-case-aware converter matters more than it looks like at first glance.
This tool takes flat, tabular CSV data and converts it into a JSON array of objects. Every row after the header row becomes one JSON object, and the column names from the first row become the keys for every object produced. If your CSV has 500 rows and 8 columns, you get back a JSON array containing 500 objects, each with 8 keys. The parser is built to handle the full range of CSV dialects you encounter in real projects. It auto-detects whether your file uses commas, semicolons, or tabs as the delimiter — a detail that sounds minor until you spend thirty minutes debugging why a European colleague's export is producing single-key objects. You can also override the delimiter manually if auto-detection guesses wrong, which occasionally happens with files that have an unusual mix of characters. Quoted fields are handled correctly per RFC 4180. That means a field like "Singh, Priya" — containing a comma inside double quotes — is parsed as a single value, not split into two fields. A field containing an escaped double quote (represented as "" inside a quoted string) is parsed as a literal double quote character. A field containing an embedded newline is kept intact as a multi-line string value in the JSON output. Excel exports get special treatment. Files exported from Excel on Windows almost always start with a UTF-8 BOM — three invisible bytes (0xEF, 0xBB, 0xBF) that prepend themselves to your first header key and turn "id" into something that looks fine visually but breaks every downstream key lookup silently. This tool strips the BOM automatically before parsing. Output comes in two modes. Pretty-printed mode produces readable, indented JSON with each key-value pair on its own line — useful when you are inspecting the data or pasting it into a config file. Compact mode produces minified JSON with all whitespace removed — the right choice for API payloads, environment variables, or anywhere that byte count matters. You can switch between modes after conversion without re-running the parse step. The entire operation runs in your browser using JavaScript. No CSV data is uploaded to any server, logged, or stored anywhere. The page does not make any network requests with your data. This is not a marketing claim — it is a technical architecture choice that makes the tool safe to use with production database exports, customer records, payroll data, or any file you would not normally email to a stranger.
1. Paste your CSV text directly into the input panel on the left, or click the Upload File button to load a .csv or .tsv file from your machine. Both paths produce the same result — use whichever is faster for your workflow.
2. Watch the delimiter indicator below the input. The tool reads your data and auto-detects whether you are using commas, semicolons, or tabs. If it shows the wrong delimiter — most common with European semicolon-separated exports — open the delimiter dropdown and set it manually before proceeding.
3. Check the preview table that appears automatically after you paste or upload. It shows your parsed headers and the first several rows as a visual table. This is your sanity check — confirm the column count, header names, and row data look correct before converting. If columns are misaligned, your delimiter is wrong.
4. Click the Convert to JSON button. Conversion is instant regardless of file size — the output appears immediately in the right panel, pretty-printed and ready to read.
5. Review the JSON output. Spot-check a few objects to make sure values landed in the right keys, empty cells are represented as empty strings, and any fields containing commas or special characters parsed correctly.
6. Copy the result using the Copy to Clipboard button, or click Download .json to save the output as a file. Use the Compact toggle if you need minified JSON for an API payload, config value, or environment variable where whitespace is overhead.
CSV is the default output format of almost everything that stores data in rows and columns. Relational databases export to CSV. Business intelligence tools export to CSV. Google Sheets, Excel, Notion, Airtable — all of them export to CSV. It is the common denominator of the data world, and that is precisely why it is such a problem for developers. Modern software does not consume CSV. REST APIs exchange JSON. GraphQL returns JSON. Node.js, Python, Go, and Rust all parse JSON natively and have zero native support for CSV in their standard libraries. When you receive a CSV from a client, export from a legacy system, or pull an analytics report, the first thing you have to do before you can use that data in code is convert it. If you do not have a reliable converter, you write a throwaway script. If the CSV has edge cases your script does not handle, you get corrupted data silently — and in my experience, it almost always has edge cases. I have been in more than a few production incidents that traced back to a CSV parser that did not handle quoted fields. A field containing a comma. A name with a comma in it — "Singh, Priya" — getting split into two fields and silently corrupting a user record import. An Excel export with a BOM character turning every database lookup by user ID into a no-match because the first key was "id" instead of "id". These are not exotic edge cases. They are the everyday reality of working with real-world CSV data. Beyond one-off conversions, there are entire categories of development work where CSV to JSON conversion shows up constantly. Database seeding during development — you have sample data in a spreadsheet and need to seed a Postgres or MongoDB instance; converting to JSON gives you a fixture format you can load directly. Frontend development — you want to test a data table component with realistic data; converting a CSV export gives you a proper array of objects to pass as props. API prototyping — you want to mock an endpoint that returns user or product data; converting a CSV gives you the response body in seconds. Data migration — you are moving content from a legacy CMS to a headless system; the export is CSV, the import expects JSON. The browser-based, no-install design matters more than it sounds. At 11pm when you are trying to unblock a deployment and you need to convert a CSV to seed a staging database, you do not want to install a Node package, write a script, debug a dependency, or upload a file to a service you have never audited. You want to paste, convert, copy. That is the workflow this tool is designed for.
Zero data transmission — conversion runs entirely in your browser with no server contact
RFC 4180 compliant parsing including quoted fields with embedded commas and newlines
Auto-detection of comma
semicolon
and tab delimiters with manual override
Automatic UTF-8 BOM stripping for reliable Excel export handling
Pretty-printed and compact output modes switchable after conversion
Instant results with no page reload
no install
no account
Handles CRLF and LF line endings consistently across Windows and Unix exports
Free with no rate limits
no file size caps beyond browser memory
Seeding a development or staging database from a spreadsheet export
Building realistic JSON fixtures for frontend component testing
Migrating legacy CMS content exported as CSV into a headless JSON-based system
Converting Google Analytics or Mixpanel exports for JavaScript consumption
Generating mock API response payloads from sample data sheets
Transforming ERP or CRM data exports for REST API ingestion
Creating JSON config files from human-editable CSV lookup tables
Inspecting and debugging CSV exports from third-party data providers
Example Input
id,name,email,role,department,joined,active 1,Priya Singh,priya@techcorp.io,Principal Engineer,Platform,2019-03-12,true 2,Arjun Mehta,arjun@techcorp.io,Senior Backend Dev,Infrastructure,2020-07-01,true 3,Sana Qureshi,sana@techcorp.io,DevOps Lead,Infrastructure,2018-11-22,true 4,Rohan Verma,rohan@techcorp.io,Frontend Engineer,Product,2022-01-15,false 5,"Singh, Vikram",vikram@techcorp.io,Data Engineer,Analytics,2021-06-30,true
Example Output
[
{
"id": "1",
"name": "Priya Singh",
"email": "priya@techcorp.io",
"role": "Principal Engineer",
"department": "Platform",
"joined": "2019-03-12",
"active": "true"
},
{
"id": "2",
"name": "Arjun Mehta",
"email": "arjun@techcorp.io",
"role": "Senior Backend Dev",
"department": "Infrastructure",
"joined": "2020-07-01",
"active": "true"
},
{
"id": "5",
"name": "Singh, Vikram",
"email": "vikram@techcorp.io",
"role": "Data Engineer",
"department": "Analytics",
"joined": "2021-06-30",
"active": "true"
}
]First JSON key has a strange prefix or looks like \uFEFFid
Fix: Your CSV was exported from Excel on Windows and contains a UTF-8 BOM at byte position zero. This is invisible in most editors. Re-export the file as UTF-8 without BOM from your source application, or rely on the tool's automatic BOM stripping which handles this case.
All row data appears in a single key instead of multiple separate fields
Fix: The delimiter is mismatched. Your file uses semicolons or tabs, but the parser is treating commas as the delimiter. Open the delimiter selector and choose semicolon or tab, or use auto-detect. This is the most common issue with European locale CSV exports.
A field value containing a comma is being split across two keys
Fix: The field is not wrapped in double quotes in your source CSV. Per RFC 4180, any field containing the delimiter character must be enclosed in double quotes. Either fix the source export to properly quote such fields, or pre-process your CSV to add missing quotes before converting.
Row count in the JSON is higher than expected
Fix: A trailing blank line at the end of your CSV file is being counted as an additional empty row. This is standard parser behaviour. Most downstream use cases are unaffected, but if you need to strip empty rows, filter out any object where all values are empty strings after conversion.
A multi-line value in a field is breaking the row structure
Fix: Fields containing literal newline characters must be wrapped in double quotes per RFC 4180. If your source system is exporting multi-line values without quoting them, the parser has no way to distinguish a field newline from a row delimiter. Pre-process the CSV to properly quote multi-line fields before converting.
Assuming CSV values will come out as typed — CSV has no type system, every cell is a string. The number 42 in a CSV cell becomes the string "42" in the JSON output. If your downstream code does arithmetic on it or strict-equals it to a number, it will silently fail. Cast numeric fields explicitly after parsing: parseInt(), parseFloat() in JavaScript, int() or float() in Python.
Using a European CSV without checking the delimiter — files exported from Excel, LibreOffice, or any system set to a European locale typically use semicolons as the delimiter because commas are used as decimal separators in those regions. If you paste such a file and your output is a single-key object containing your entire row, the delimiter is wrong. Switch to semicolon in the dropdown.
Ignoring the UTF-8 BOM on Excel exports — Excel for Windows silently prepends three invisible bytes (EF BB BF) to the start of every UTF-8 CSV export. This corrupts your first header key from 'id' to '\uFEFFid'. Everything downstream that looks up values by key will silently produce undefined or null. The BOM is invisible in most text editors, which makes it one of the most frustrating bugs to diagnose the first time you hit it.
Expecting empty cells to become null — they become empty strings. If your application uses null checks to detect missing values, those checks will silently pass over empty CSV cells that converted to "". You need an explicit post-processing step: object[key] === '' ? null : object[key].
Feeding the converter a CSV with inconsistent column counts — if some rows have fewer columns than the header, those objects will have missing keys. If some rows have more columns, the extra values are silently dropped. Neither is an error — the converter follows the header definition. Clean inconsistent rows in your source data before converting.
Git Cheatsheet
Quick reference guide for essential Git commands, branching workflows, remote repositories, stashing, and rollbacks.
Regex Cheatsheet
Interactive guide to Regex anchors, character classes, quantifiers, lookarounds, capturing groups, and search flags.
HTTP Headers Cheatsheet
Complete guide to standard and security HTTP headers including Authorization, CORS control, caching policies, and CSP directives.
SQL Cheatsheet
Complete guide to SQL statements including SELECT queries, WHERE filters, aggregate functions, JOIN types, and DDL commands.
Is my CSV data sent to any server when I use this tool?
No. The entire conversion runs in your browser using JavaScript. Your CSV data is never transmitted to any server, never logged, and never stored anywhere outside your browser tab. This is a deliberate architectural choice, not just a privacy claim. You can verify it by opening your browser's network inspector before pasting a CSV — you will see zero outbound requests carrying your data. This makes the tool safe for production database exports, customer records, payroll files, or any sensitive data you would not upload to a third-party service.
Why are all my number values coming out as strings in the JSON?
Because CSV has no type system. Every cell in a CSV file is plain text. The number 42 and the string '42' are identical in CSV — there is no difference at the file format level. A converter that silently tries to infer and cast types would introduce unpredictable behaviour and could corrupt data in edge cases. This converter preserves the raw string values faithfully. If your downstream code needs typed values, cast them explicitly after parsing: parseInt(row.id, 10) in JavaScript, int(row['id']) in Python, row.id.parse::() in Rust.
My CSV uses semicolons instead of commas. Will this convert correctly?
Yes. Semicolons are the standard CSV delimiter in any system configured for a European locale, because commas serve as decimal separators in those regions. The tool auto-detects semicolons when your data consistently uses them. If auto-detection guesses wrong — which can happen with small files or files that contain both commas and semicolons in values — open the delimiter dropdown and select semicolon manually. You will know it guessed wrong if your output shows everything in a single key instead of separate fields.
How do I handle a CSV exported from Excel that has a weird first key?
Excel on Windows exports UTF-8 CSV files with a BOM (byte-order mark) — three invisible bytes prepended to the file that corrupt the first column header. The key that should be 'id' becomes '\uFEFFid', which is visually identical in many editors but breaks every downstream key lookup silently. This tool automatically detects and strips the BOM before parsing, so you should not see this problem. If you are writing your own parser and hitting this issue, check for bytes EF BB BF at the start of your file and strip them before processing.
What happens to empty cells in the CSV?
Empty cells become empty strings in the JSON output. They do not become null, undefined, or zero — they become "". This is the faithful representation of what the CSV actually contains. If your application uses null checks to detect missing values, you will need to add a post-processing step to convert empty strings to null: const clean = Object.fromEntries(Object.entries(row).map(([k,v]) => [k, v === '' ? null : v])). This is intentional behaviour — the converter does not make assumptions about what an empty cell means in your specific data model.
Can it handle CSV files with quoted fields containing commas?
Yes, this is handled correctly per RFC 4180. A field like "Singh, Priya" — a name containing a comma, wrapped in double quotes — is parsed as a single string value 'Singh, Priya', not split into two fields 'Singh' and ' Priya'. This is one of the most common failure modes of naive CSV parsers that split on every comma regardless of quoting context. You can test it directly using the example input provided on this page, which includes a quoted field with a comma.
How large a file can I convert?
The tool handles files up to several megabytes without issue in any modern browser. For very large files — hundreds of megabytes or millions of rows — you will start hitting browser memory limits, and a command-line tool will serve you better. In Node.js, the csvtojson package handles streaming conversion of arbitrarily large files. In Python, the csv module combined with json.dump processes large files with minimal memory overhead. In Rust, the csv crate with serde_json handles this natively. For anything under 50MB, the browser-based approach is simpler and faster than reaching for a CLI tool.
Does the tool preserve the original column order from my CSV?
Yes. The keys in each output object follow the same order as the columns in your CSV header row. JavaScript objects technically have no guaranteed key order per the ECMAScript spec, but in practice all modern JavaScript engines preserve insertion order for string keys, and JSON serialisers output keys in insertion order. If you are consuming the output in a context where key order matters strictly, process the header array separately to maintain a canonical column ordering.
Recent Activity
No recent activity