CSV, Parquet, JSON or Excel: Which Format to Use

Your data warehouse wants Parquet. Your team has CSVs. Someone emailed you an .xlsx and your ETL script only reads CSV. The API returns JSON and your colleague wants a spreadsheet. Every one of these is a format conversion problem, and none of them should require installing a tool or writing a script.

ExploreMyData opens 26 file extensions and exports 9 formats. Open a file, optionally clean it up, and export in the format you need. The whole thing runs in the browser.

Supported formats

Input (what you can open):

• Text tables: .csv, .tsv, .txt
• Columnar and binary: .parquet, .arrow, .feather, .avro
• JSON family: .json, .jsonl, .ndjson
• Spreadsheets: .xlsx, .xls
• Databases: .duckdb, .db, .sqlite, .sqlite3
• Documents: .pdf, .doc, .docx, .xml
• Archives and compressed files: .gz, .bz2, .zst, .zip, .tar, .tgz

Archives are unpacked in the browser and you pick which entry inside to load. Multi-table sources behave the same way: open a .sqlite or .duckdb file and you choose which tables to bring in.

Excel gets a sheet picker. If the workbook has more than one non-empty sheet, a dialog lists them and you tick the ones you want. Each selected sheet lands as its own file tab with its own pipeline, so a five-sheet workbook can become five independent conversions in one pass. Single-sheet workbooks skip the dialog and load straight in.

Output (what you can export):

• CSV: maximum compatibility
• Parquet: compression and type preservation
• Excel (.xlsx): a real workbook, not a CSV with a renamed extension
• JSON: one array of objects, pretty-printed
• JSON Lines: one JSON object per line
• XML: a row element per row, a child element per column
• TSV: tab-separated text
• PDF: a printable table
• HTML: a self-contained page you can open or email
• DuckDB: a database file with your data as a table

The conversion process

It's three steps:

1. Open your file in any supported format. Drag and drop or use the file picker.
2. Preview the data. Make sure it loaded correctly. Check column types.
3. Export in whichever of the nine formats you need.

That's it. The conversion happens in-browser using DuckDB WASM. No server, no upload, no waiting for a job to finish.

Clean before you convert

The real power is that you can transform the data between open and export. Every pipeline step you apply is included in the exported file. This means you can:

• Open an Excel file, fix column names, remove empty rows, then export as clean CSV
• Open a JSON API response, flatten nested fields, filter to relevant records, then export as Parquet
• Open a messy CSV, fix data types, remove duplicates, then export as a typed Parquet file for your warehouse

The exported file reflects the final state of your pipeline, not just the raw input. This turns a simple format conversion into a lightweight ETL step.

Why convert to Parquet?

If you're only working with small files and non-technical collaborators, CSV is fine. But Parquet has real advantages when files get bigger or data integrity matters:

• Compression. Typical results are 3x to 7x smaller, so a 100 MB CSV lands somewhere around 15 to 35 MB. That is a rule of thumb rather than a measurement: columnar storage compresses repeated values extremely well, so a file of long low-cardinality strings can beat 7x comfortably, while wide float data may barely hit 2x.
• Types are preserved. A Parquet file knows that a column is an integer, a date, or a boolean. CSV stores everything as text, so downstream tools have to guess (and often guess wrong).
• Faster to read. Tools like DuckDB, Pandas, and Spark can read specific columns from a Parquet file without scanning the whole thing. With CSV, you read the entire file even if you only need two columns.

Why convert to CSV?

CSV is the lowest common denominator. Every tool, language, and spreadsheet app can read it. Convert to CSV when:

• You need to share data with someone who uses Excel or Google Sheets
• A script or legacy system only accepts CSV input
• You want a human-readable file you can open in a text editor
• You're converting from Excel or JSON to something simpler

Format comparison

Common conversions

Excel to CSV: Open the .xlsx file. If it has several sheets, tick the one you want in the sheet picker (or tick several and get a tab each). Preview it, verify the columns look right, and export as CSV. Useful when a colleague sends you a spreadsheet and your code expects CSV.

CSV to Excel: The reverse works too, and it is a real workbook rather than a CSV with the extension swapped. Numeric columns arrive as numeric cells, so leading zeros in a text column stay put instead of being eaten by Excel's import guesser. Open the CSV, fix any column types with Convert Type, and export Excel.

CSV to Parquet: Open the CSV. Check that column types were detected correctly (use Convert Type if needed). Export as Parquet. The result is smaller, faster to query, and preserves types. Ideal before loading into a data warehouse.

JSON to CSV: Open the JSON file. DuckDB flattens the top-level array of objects into rows and columns automatically. If you have nested fields, use the SQL Query operation, or JSON Extract from the Data group, to pull them into their own columns. Then export as CSV.

Anything to JSON Lines: The JSON export writes newline-delimited JSON, one object per row, into a .jsonl file. That's the shape log shippers, BigQuery loads, and most streaming consumers actually want. If you need a single bracketed JSON array instead, this isn't it, and you'll want to wrap the output yourself.

Parquet to CSV: Sometimes you need to make a Parquet file human-readable, or hand it to a tool that only reads CSV. Open the Parquet file and export as CSV.

PDF and XML

ExploreMyData also supports PDF table extraction and XML import. You can extract a table from a PDF, clean the data with the pipeline, and export as CSV, Excel, or Parquet. XML files are flattened into columns automatically.

Convert a file now →