Real Parquet binary — pure JS — no upload

Convert CSV to Parquet
Binary output,
in your browser.

Free CSV to Parquet converter. Creates a genuine binary Apache Parquet file using pure JavaScript — no libraries, no server. Download and open with Python, DuckDB, Spark or any Parquet tool. Your data never leaves your device.

Your data never leaves your browser
Real binary .parquet output
INT32 / DOUBLE / STRING types
Python / DuckDB / Spark compatible
Always free
Need the reverse? Parquet to CSV converter
CSV to Parquet Converter  Pure JavaScript
No external libraries. The Parquet binary format is encoded directly in JavaScript using the Apache Thrift binary protocol.
Drop your CSV file here
.csv, .txt or .tsv — creates a real binary .parquet file
 Parquet file ready 

      

 
    

  

 
  
  
Read the output with any Parquet tool

  
The downloaded .parquet file works with all major data tools.

  

    

      
Python pandas

      
import pandas as pd
df = pd.read_parquet('file.parquet')
print(df.head())

    

    

      
DuckDB

      
import duckdb
duckdb.query(
  "SELECT * FROM 'file.parquet'"
).df()

    

    

      
Apache Spark

      
df = spark.read.parquet(
  'file.parquet'
)
df.show()

    

    

      
Apache Arrow

      
import pyarrow.parquet as pq
table = pq.read_table('file.parquet')
df = table.to_pandas()

    

    

      
AWS Athena / S3

      
-- Upload to S3, then:
SELECT * FROM my_table
-- (Parquet backed table)

    

    

      
Node.js (hyparquet)

      
import { parquetRead } from 'hyparquet'
await parquetRead({ file,
  onComplete: data => console.log(data) })

    

  

 
  
  
CSV to Parquet in Python

  
Code examples for common Python workflows.

 
  

    
pandas — simplest approach

    
import pandas as pd
 
df = pd.read_csv('data.csv')
df.to_parquet('output.parquet', index=False)
 
# With compression (smaller file):
df.to_parquet('output.parquet', compression='snappy', index=False)
 
# With explicit types:
df['date_col'] = pd.to_datetime(df['date_col'])
df.to_parquet('output.parquet', index=False)

    
Requires: pip install pandas pyarrow. pyarrow is the default engine and produces the most compatible output.

  

 
  

    
DuckDB — fastest for large files

    
import duckdb
 
duckdb.query("""
  COPY (SELECT * FROM read_csv_auto('data.csv'))
  TO 'output.parquet'
  (FORMAT PARQUET, COMPRESSION SNAPPY)
""")
 
# Or partition by column:
duckdb.query("""
  COPY (SELECT * FROM read_csv_auto('data.csv'))
  TO 'output/'
  (FORMAT PARQUET, PARTITION_BY (year))
""")

    
Requires: pip install duckdb. Fastest option for large CSVs — processes millions of rows per second.

  

 
  

    
pyarrow — most control over schema

    
import pyarrow as pa
import pyarrow.csv as pcsv
import pyarrow.parquet as pq
 
table = pcsv.read_csv('data.csv')
pq.write_table(table, 'output.parquet',
               compression='snappy',
               row_group_size=100_000)

    
Requires: pip install pyarrow. Best when you need fine-grained control over schema, compression codec and row group size.

  

 
  

 
  
  
Why convert CSV to Parquet?

  
The advantages of columnar storage over row-based CSV.

  

    CSV is row-oriented and untyped — every value is stored as text, every row must be read to access any column, and there is no built-in compression or type information. For large analytical datasets, this is extremely inefficient.
  

  

    Parquet is columnar — values from the same column are stored together. This means: reading one column skips all others entirely; identical or similar values in a column compress dramatically; and data types are stored explicitly, so tools know without parsing that a column is INTEGER or DOUBLE.
  

  

    A 1 GB CSV file typically compresses to 100–200 MB as Parquet with Snappy compression. Query engines like AWS Athena charge per byte scanned — Parquet files with column pruning can reduce a query cost from $5 to $0.10 on the same dataset. This is why Parquet is the standard format for data lakes, cloud analytics (Athena, BigQuery, Redshift Spectrum, Snowflake external tables) and ML training data.
  

 
  
  
When do you need CSV to Parquet?

  
Common data engineering workflows that require Parquet.

  

    

      
 AWS Athena and S3 data lakes

      
Athena charges per byte scanned. Converting CSV exports to Parquet before uploading to S3 reduces storage costs and query costs by 5-10x. Parquet with Snappy compression is the recommended format for Athena external tables.

    

    

      
 Data pipeline inputs

      
Tools like Apache Spark, dbt, Airflow and most modern ETL frameworks prefer Parquet as their interchange format. Converting CSV sources to Parquet at ingestion time improves downstream query performance across the entire pipeline.

    

    

      
 ML training datasets

      
Large ML training datasets in CSV format load slowly and waste memory. Converting to Parquet lets PyArrow, TensorFlow Datasets and Hugging Face Datasets load only the feature columns needed for a specific training run, without reading the full file.

    

    

      
 Analytics and BI

      
DuckDB, Polars and Apache Arrow read Parquet significantly faster than CSV for analytical queries. Converting a large CSV export to Parquet before analysis reduces query time from minutes to seconds for aggregations over millions of rows.

    

  

 
  

 
  
  
Related CSV tools

  
Other free converters on CSVShift you might need.

  
Parquet to CSV
Read any Parquet file and export it as CSV.
CSV to JSONL
One JSON object per line for BigQuery, OpenAI and Elasticsearch.
JSONL to CSV
Convert JSON Lines / NDJSON files into a CSV spreadsheet.
CSV to TSV
Comma-separated to tab-delimited, with quotes handled.
CSV to JSON
Arrays, objects or keyed JSON from any CSV, with types.
JSON to CSV
Flatten nested JSON into a clean CSV table.
CSV to XML
XML with your own root and row tags from any CSV.
XML to CSV
Flatten nested XML elements and attributes into CSV.
CSV to YAML
Valid YAML with correct quoting from any CSV.
All data format converters 

 
  
  
 
  

 
  
  

    

      
Parquet binary written
in your browser. No libraries.

      
CSVShift encodes the Apache Parquet binary format directly in JavaScript — no sql.js, no pyodide, no WebAssembly dependency. The Thrift binary protocol metadata, the PLAIN-encoded column data and the PAR1 magic bytes are all assembled in memory and exported as a Uint8Array.

      
The output follows Parquet format version 2 with PLAIN encoding and UNCOMPRESSED storage. It is readable by Python pyarrow, pandas, DuckDB, Apache Spark, Apache Arrow and any other compliant Parquet reader. Verify with: python -c "import pandas as pd; print(pd.read_parquet('file.parquet'))"

    

    

      

        
Pure JavaScript — no WASM

        
Thrift binary protocol and Parquet format encoded directly in JS. No WebAssembly, no download delay, no external dependencies.

      

      

        
Standard Parquet v2

        
PAR1 magic, Thrift binary FileMetaData, PLAIN UNCOMPRESSED columns — compliant with the Apache Parquet format specification.

      

      

        
Type inference

        
Integer columns stored as INT32, floating-point as DOUBLE, text as BYTE_ARRAY with UTF8 annotation.

      

      

        
Free, no conditions

        
No row limit, no file size cap, no watermark. Funded by display advertising only.

      

    

  

 
  
  

    
Frequently asked questions

    
Common questions about converting CSV files to Apache Parquet format.

 
    

      
How do I convert CSV to Parquet?

      
Upload your CSV, optionally enable type inference, and click Convert. CSVShift creates a binary Apache Parquet file in your browser — download it and open with Python pandas (pd.read_parquet()), DuckDB (read_parquet()), Apache Spark or any Parquet-compatible tool.

    

 
    

      
How do I convert CSV to Parquet in Python?

      
Simplest: import pandas as pd; df = pd.read_csv('f.csv'); df.to_parquet('out.parquet'). With Snappy compression: df.to_parquet('out.parquet', compression='snappy'). Requires pip install pandas pyarrow. For large files use DuckDB: duckdb.query("COPY (SELECT * FROM read_csv_auto('f.csv')) TO 'out.parquet'").

    

 
    

      
Why is Parquet better than CSV for analytics?

      
Parquet is columnar — values from the same column are stored together. This enables: reading only the columns a query needs (skipping others entirely), dramatically better compression (5-10x vs CSV), explicit data types (no parsing guessing), and predicate pushdown (skipping row groups that don't match a WHERE clause). For analytical workloads on large datasets, Parquet is typically 10-100x faster to query than CSV.

    

 
    

      
How do I verify the Parquet file is valid?

      
In Python: import pandas as pd; df = pd.read_parquet('file.parquet'); print(df.dtypes). In DuckDB: import duckdb; duckdb.query("DESCRIBE SELECT * FROM 'file.parquet'").show(). Valid files open immediately with correct column types and row counts.

    

 
    

      
Is my data safe when converting CSV to Parquet online?

      
Yes. CSVShift builds the Parquet binary entirely in JavaScript in your browser. No data is uploaded or transmitted. Open the Network inspector during conversion — zero outbound requests carrying your file content will be made.