Converting Tabular Data: CSV, JSON and HTML Tables

A spreadsheet arrives from finance as CSV. The API I'm feeding it to wants JSON. The report I'm publishing needs an HTML table. Same data, three formats — and moving between them cleanly is a surprisingly common chore that, done by hand, goes wrong in small infuriating ways. After one too many afternoons lost to a single misplaced comma, I learned to treat format conversion as a tool job, not a manual one.

Here's how to move tabular data between CSV, JSON and HTML tables without the headaches.

Three formats for the same thing

Tabular data — rows and columns — shows up in three main formats, each suited to a different place:

• CSV (comma-separated values) is compact and universal. Every spreadsheet reads and writes it, which makes it the lingua franca of data exports.
• JSON represents the same rows as an array of objects. It handles nested and typed data and is the standard for APIs and web apps.
• HTML tables are how tabular data gets displayed on a web page.

None is "best" — they're suited to different destinations. The skill is converting between them cleanly, because that's where the subtle bugs live.

CSV to JSON

Turning a CSV into JSON is the most common conversion. The logic is: the header row becomes the object keys, and each subsequent row becomes an object. So:

name,age
Sam,34

becomes [{"name":"Sam","age":"34"}]. A CSV-to-table tool does this parsing for you and lets you view or export the result, which beats writing a parser or splitting on commas by hand — a method that breaks the moment a value contains a comma (more on that below).

JSON (or a table) back to CSV

The reverse is just as common: you have JSON from an API and someone in finance wants it in a spreadsheet. A table-to-CSV tool flattens structured data back into clean CSV rows, handling the quoting so values with commas survive the trip. And when you need to inspect messy or deeply nested JSON before converting, a JSON tree viewer renders it as an expandable outline so you can see the structure at a glance instead of scrolling a wall of brackets.

The comma-and-quote gotcha

Here's the trap that catches everyone who tries to convert CSV by hand: a value that contains a comma.

In CSV, commas separate fields — but what about a value that legitimately has a comma, like "Smith, John" or "$1,000"? The standard answer is to wrap that value in quotes: "Smith, John". A proper parser respects those quotes and treats the whole thing as one field. Naive comma-splitting does not — it sees two fields where there's one, and every column after it shifts over, silently corrupting the row.

This is the single biggest reason to use a real converter rather than splitting on commas in a quick script. The tool handles quoting, escaped quotes, and newlines inside fields correctly; hand-rolled code almost never does.

A quick worked example

Take a CSV row: Acme, Inc.,100,"Widgets, deluxe". By naive comma-splitting you'd get four or five mangled fields. A proper converter reads it as exactly three: company Acme, Inc., quantity 100, product Widgets, deluxe — because it honours the quotes around the values that contain commas. The data stays aligned. That difference between "looks parsed" and "actually parsed correctly" is where silent data corruption hides.

Choosing the right format

A quick guide to which format to reach for:

• Going to a spreadsheet or a non-technical colleague? CSV.
• Feeding an API or a web app, or the data is nested/typed? JSON.
• Displaying on a web page? An HTML table.

Convert at the boundary — keep data in whatever format suits the current step, and transform it only when it crosses into a system that prefers another. Converting back and forth needlessly just adds chances for things to break.

A note on types and privacy

Two things worth remembering. First, CSV has no types — everything is text — so a number like 34 becomes the string "34" when converted to JSON unless you explicitly cast it; decide whether your downstream code needs real numbers. Second, be mindful of what you convert online: for data with personal or sensitive fields, prefer tools that process entirely in your browser so nothing is uploaded.

The takeaway

CSV, JSON and HTML tables are three dialects for the same rows-and-columns idea, each suited to a different destination — spreadsheets, APIs and web pages respectively. Converting between them is routine, but the comma-and-quote gotcha makes hand-rolled conversion quietly unreliable, which is exactly why a proper tool is worth using. Convert at the boundaries, watch out for quoted values and CSV's lack of types, and keep sensitive data local. Get that right and moving data between systems stops being an afternoon-eating chore.