Avro vs Parquet: Real File Size Test and When to Use Each

Avro and Parquet both store a table in a compact binary file, and the usual advice is that Parquet is smaller and Avro is for streaming. Is that true? We saved the same 100,000-row table in both formats and measured it. The result is not quite what the summaries say, and it shows what to check before you choose one.

Open the Format Converter

Quick answer

  • **Choose Parquet** to store data you will query or analyse. It keeps each column together, so a query can read only the columns it needs.
  • **Choose Avro** to move records between systems, for example events written one at a time. It keeps each row together and carries its schema in the file.
  • **Many pipelines use both**: records arrive as Avro, then land in a data lake as Parquet for analysis.

Row-based and columnar, in one picture

The difference is how the same three rows are laid out in the file:

Avro (row by row):    [1, Ada, London] [2, Alan, Leeds] [3, Grace, Oslo]
Parquet (by column):  order_id: 1 2 3 | customer: Ada Alan Grace | city: London Leeds Oslo

Row by row is natural when a record arrives and you write it. Column by column is natural when you read: a query that needs only city can skip the other columns, and values of the same kind sit side by side, which compresses well.

What we measured

One orders table with 100,000 rows and 7 columns: order_id, customer, email, city, amount, order_date and status. The values come from a seeded random generator, so the test can be repeated. We made a CSV, read it with the Data Utility CSV reader, and wrote each format with the same converter code that the free tools use. Sizes are exact. Times are the median of five runs on one computer, so treat them as a guide.

Two things to know before you read the numbers. The Data Utility Avro writer uses no compression codec, so the Avro file here is uncompressed. And the CSV reader keeps dates such as 2025-06-23 as text, so order_date is a string in every format.

The results

Format    Size       After gzip   Write time
CSV        7.27 MB    1.62 MB      43 ms
JSON      14.81 MB    2.03 MB      48 ms
Parquet    2.01 MB    1.65 MB     133 ms
Avro       7.69 MB    1.87 MB     335 ms
  • Parquet is 72 percent smaller than the CSV and 3.8 times smaller than the Avro file.
  • The Avro file is 6 percent larger than the CSV. Without a compression codec it stores every value in full, plus a marker for each value saying whether it is null.
  • Gzip changes the picture. Gzipped, the Avro file shrinks by about 76 percent to 1.87 MB, close to the gzipped CSV. Parquet is already compressed, so gzip trimmed it only from 2.01 to 1.65 MB.
  • Both files read back correctly. We converted each one back to rows and the last row, order 100000, matched the original exactly.

Why the sizes differ, and why size is not the main point

The likely reason for the gap is the repeated values. In this table status has five different values across 100,000 rows and city has twenty. Stored column by column, runs of similar values are easy to encode compactly. Stored row by row without compression, each value is written out again every time.

But file size is not the main reason to pick Parquet. With an Avro compression codec, such as deflate, the Avro file would be much smaller than what we measured here. We did not test that, so we do not give a number. The bigger difference is in reading. An analytical query that needs two of the seven columns can read just those two from a Parquet file, and Parquet also keeps statistics that let an engine skip chunks of rows. An Avro reader has to read every row in full.

When to choose Avro

  • Records are produced one at a time, such as events on a message queue.
  • Producers and consumers change independently, and you want the schema to travel with the data. Avro files carry their schema in the file header, and Avro defines rules for reading data written with an older or newer schema.
  • The consumer processes whole records, not a few columns.

When to choose Parquet

  • You store data to query it later with Spark, DuckDB, or a warehouse or lake query engine.
  • Queries touch a few columns of a wide table.
  • You write in batches. A Parquet file is finished when it is written and is not appended to, so writing thousands of tiny files hurts performance.

What about ORC?

ORC is another columnar format from the Hive world, with a role close to Parquet's. Data Utility reads and writes Avro and Parquet but does not support ORC at the time of writing, so we did not test it. The Parquet and ORC choice is mostly decided by the engine you use.

Common mistakes

  • **Comparing sizes without checking the codec.** An uncompressed Avro file against a compressed Parquet file is not a fair test. Check the compression of both.
  • **Using Avro as the place analysts query.** It works, but every query reads whole rows. Convert it to Parquet for analysis.
  • **Writing many tiny Parquet files.** Collect records into larger batches before writing.
  • **Expecting required fields.** The Avro written from a CSV here makes every column a union of null and its type, so any value may be empty. Read the schema before you rely on it.
  • **Letting dates stay text.** If a date column arrives as a string, cast it to a date downstream, or your queries will sort and filter it as text.

Read both formats in code

import pandas as pd

df = pd.read_parquet("orders.parquet")   # needs pyarrow
print(df.dtypes)
from fastavro import reader

with open("orders.avro", "rb") as f:
    avro = reader(f)
    print(avro.writer_schema["fields"][0])   # the schema is in the file
    first = next(avro)
-- DuckDB
SELECT status, count(*) FROM read_parquet('orders.parquet') GROUP BY status;

Convert between them without code

In the browser, the Avro to Parquet and Parquet to Avro converters do it in one step, and CSV to Avro writes Avro from a CSV. To look inside an Avro file first, use the Avro viewer. The files are read on your own computer, not uploaded. Nested JSON is flattened into columns before it is written as Avro.

Repeat the test on your own data

Your table will behave differently, because column types, repeated values and the compression setting all change the result. Convert your own CSV to Parquet and to Avro, compare the file sizes, and check each file's compression setting. For more measurements, see the data format benchmark, the CSV vs Parquet size test and what a Parquet file is. All Avro pages are collected in the Avro guide.

Open the Format Converter

Related tool pages

  • Avro Viewer Online: Open .avro Files: Open and view an Avro (.avro) file online: see the schema and records as a table, then save as CSV, JSON, Excel or Parquet. Free, no upload.
  • Avro to CSV Converter: Convert an Avro file to CSV online. Nested records are flattened. Free, private, runs in your browser.
  • CSV to Avro Converter: Convert CSV to an Avro (.avro) file online. Column types are detected and written into the Avro schema. Free and private: nothing is uploaded.
  • Avro to JSON Converter: Convert an Avro file to JSON online. Nested records, arrays and maps stay nested. Free, private, no upload.
  • JSON to Avro Converter: Convert JSON to an Avro (.avro) file online. The schema is built from your data. Free, private, no upload.
  • Parquet to Avro Converter: Convert a Parquet file to Avro online. Column types are kept in the Avro schema. Free, private, runs in your browser.

Also try

How to use the Format Converter: step by step

  1. Open the converter for your input, for example CSV to Parquet.
  2. Convert your file to Parquet, then to Avro.
  3. Compare the two file sizes and check each compression setting.
  4. Pick Parquet for analysis and Avro for moving records.

When to use the Format Converter

  • Choose a storage format for a data lake
  • Decide between Avro and Parquet for a pipeline
  • Check how big your table is in each format
  • Convert Avro files for analysis

Example

Input: id,name,age 1,Ada,36 2,Alan,41

Output: [{"id":1,"name":"Ada","age":36},{"id":2,"name":"Alan","age":41}]

Frequently asked questions

Is Avro smaller than Parquet?

In our test, no. The same 100,000 rows were 7.69 MB as Avro and 2.01 MB as Parquet. That Avro file had no compression codec, so the gap would be smaller with one, but we did not measure it.

Which is better for streaming, Avro or Parquet?

Avro is usually the better fit for records written one at a time, because it is row based and carries its schema. Parquet suits data you store in batches and query later.

Can I convert Avro to Parquet online?

Yes. Drop the .avro file into the Avro to Parquet converter and download the result. It runs in your browser and the file is not uploaded.

Does Data Utility support ORC?

Not at the time of writing. It reads and writes CSV, JSON, Excel, Parquet and Avro.

Why did the Avro file come out bigger than the CSV?

The Avro writer uses no compression codec and marks every value as null or not null, so the file stores more than the plain text does. A compression codec would shrink it.

Tip: Before you compare two formats, compare their compression settings. Most surprising size results come from one file being compressed and the other not.