Free Sample Parquet Files

PyArrow is the fastest path. Install it and read any file in two lines:

pip install pyarrow pandas

import pyarrow.parquet as pq
import pandas as pd

# Read the full file
table = pq.read_table('ecommerce_orders.parquet')
df = table.to_pandas()
print(df.head())

# Read only specific columns (columnar advantage!)
df_slim = pq.read_table('iot_sensor_readings.parquet',
    columns=['device_id','sensor_type','value_raw']).to_pandas()

# Inspect schema without loading data
schema = pq.read_schema('financial_transactions.parquet')
print(schema)

DuckDB lets you run full SQL directly on parquet files — no database required. It's blazing fast for analytics:

pip install duckdb

import duckdb

# SQL on a parquet file directly
duckdb.sql("""
    SELECT status, COUNT(*) as cnt, SUM(quantity) as total_qty
    FROM 'ecommerce_orders.parquet'
    GROUP BY status
    ORDER BY cnt DESC
""").show()

# Join two parquet files
duckdb.sql("""
    SELECT o.region, l.status_code, COUNT(*) as hits
    FROM 'ecommerce_orders.parquet' o
    JOIN 'web_server_logs.parquet' l ON o.order_id = l.log_id
    GROUP BY 1, 2
""").show()

Parquet is Spark's native format — no conversion needed:

from pyspark.sql import SparkSession

spark = SparkSession.builder.appName("ParquetDemo").getOrCreate()

df = spark.read.parquet("iot_sensor_readings.parquet")
df.printSchema()
df.createOrReplaceTempView("sensors")

spark.sql("""
    SELECT sensor_type,
           AVG(value_raw)        AS avg_value,
           COUNT(*)              AS readings,
           SUM(alert_triggered)  AS total_alerts
    FROM sensors
    GROUP BY sensor_type
""").show()

The arrow package brings full Parquet support to R with a tidy interface:

install.packages("arrow")
library(arrow)
library(dplyr)

# Read and convert to tibble
orders <- read_parquet("ecommerce_orders.parquet")
glimpse(orders)

# Use dplyr verbs directly on the Arrow table (lazy)
orders |>
  group_by(status) |>
  summarise(n = n(), total_qty = sum(quantity)) |>
  arrange(desc(n)) |>
  collect()  # pulls into R data.frame

Upload the files to an S3 bucket, then create an external table in Athena — pay only for data scanned:

-- Upload first: aws s3 cp *.parquet s3://my-bucket/data/

-- Create external table in Athena
CREATE EXTERNAL TABLE IF NOT EXISTS iot_readings (
    reading_id       INT,
    device_id        STRING,
    sensor_type      STRING,
    location         STRING,
    value_raw        INT,
    battery_level    INT,
    signal_strength  INT,
    device_model     STRING,
    alert_triggered  INT
)
STORED AS PARQUET
LOCATION 's3://my-bucket/data/iot_sensor_readings/';

-- Query it
SELECT sensor_type, AVG(value_raw) FROM iot_readings GROUP BY 1;

All five files use Parquet format version 2 (the spec version stored in the FileMetaData.version field). They use PLAIN encoding for all columns and no compression — making them ideal for validating parsers since there is no codec dependency. Compatible with all major readers: PyArrow ≥ 0.17, Spark ≥ 2.x, Hive ≥ 1.2, Presto, Trino, DuckDB, and Pandas.

Yes — completely free for any purpose. All datasets are synthetically generated; they contain no real personal, financial, or proprietary information. You may use them in commercial software, open-source projects, tutorials, courses, test suites, and benchmarks without attribution.

Several GUI tools can open Parquet files directly:

• DBeaver — free, cross-platform, supports Parquet natively
• Apache Parquet Viewer — lightweight desktop app
• VS Code — install the Parquet Viewer extension
• Tad — fast tabular data viewer with Parquet support
• AWS Glue DataBrew — cloud-based, no install
• Command-line: parquet-tools schema file.parquet

Parquet v2 (also called "format version 2") introduced several improvements over v1: the Data Page V2 format (separate repetition/definition levels that can be compressed independently), better statistics coverage, improved encoding for nested types, and support for newer encodings like DELTA_BINARY_PACKED and BYTE_STREAM_SPLIT. Most modern tools default to v2. The version field in the footer is 2 for v2 files. The physical layout is largely compatible — all v1 readers can read v2 files if they don't use v2-only page headers.

With Pandas, it's one line:

import pandas as pd
df = pd.read_parquet('ecommerce_orders.parquet')
df.to_csv('ecommerce_orders.csv', index=False)

Or with DuckDB, which handles very large files efficiently:

duckdb.sql("""
  COPY (SELECT * FROM 'ecommerce_orders.parquet')
  TO 'ecommerce_orders.csv' (HEADER, DELIMITER ',')
""")

In PLAIN encoding: INT32 values are stored as 4 consecutive little-endian bytes; INT64 as 8 bytes LE; FLOAT as IEEE 754 single (4 bytes); DOUBLE as IEEE 754 double (8 bytes); BYTE_ARRAY (strings) as a 4-byte LE length prefix followed by raw UTF-8 bytes; BOOLEAN as 1 bit per value packed LSB-first. Definition and repetition levels use RLE/bit-packed hybrid encoding regardless of value encoding.

BigQuery: Upload via the console (Create Table → Upload → File format: Parquet) or use bq load --source_format=PARQUET dataset.table file.parquet. Schema is auto-detected from the embedded Parquet schema.

Snowflake: Stage the files in an S3 or GCS bucket, then: COPY INTO my_table FROM @my_stage/file.parquet FILE_FORMAT = (TYPE = 'PARQUET');. Use $1:column_name syntax to reference columns during the COPY.

The quickest way with Python:

import pandas as pd
import pyarrow as pa
import pyarrow.parquet as pq

# Create a DataFrame
df = pd.DataFrame({
    'id':     range(1, 1001),
    'name':   [f'User_{i}' for i in range(1, 1001)],
    'score':  [i * 1.5 for i in range(1, 1001)],
    'active': [i % 2 == 0 for i in range(1, 1001)],
})

# Write with compression
table = pa.Table.from_pandas(df)
pq.write_table(table, 'my_sample.parquet',
               compression='snappy',
               row_group_size=512)