Apache Avro

What is an Avro File?

A plain-English guide to the .avro file format — what's inside one, and how to open, read, and create it

February 20269 min read

The Short Answer

An Avro file is a file with a .avro extension that stores data in Apache Avro's compact binary format. The clever part: the file carries its own schema inside it, so anything reading the file already knows exactly what every field means.

Quick definition: A .avro file = your data in efficient binary + the schema that describes it, bundled together in one self-describing file. New to Avro itself? Start with what Apache Avro is.

If you've worked with a JSON file before, you already have the right mental model — a file that holds structured data. The difference is that a JSON file is text you can read with your eyes, while an Avro file is binary built for machines to process fast and store cheaply. You'll bump into .avro files most often in data pipelines built on Kafka, Hadoop, and Spark.

What's Actually Inside an Avro File

Every .avro file follows the same layout. Once you've seen it, the format stops feeling mysterious:

1. Header

Holds the schema (in JSON) plus metadata like which compression codec was used. This is what makes the file self-describing.

2. Data Blocks

Your actual records, stored as compact binary. Field names aren't repeated here — the header already defined them.

3. Sync Markers

Small markers between blocks so big-data tools can split the file and read chunks in parallel.

That header is the key idea. Because the schema lives inside the file, you can open an Avro file someone created years ago and still know exactly what every value represents — no separate documentation required.

A Real Example

Say you're storing user records. The schema tucked into the file's header looks like this (it's ordinary JSON):

{
  "type": "record",
  "name": "User",
  "namespace": "com.example",
  "fields": [
    { "name": "id",    "type": "int" },
    { "name": "name",  "type": "string" },
    { "name": "email", "type": "string" },
    { "name": "active", "type": "boolean" }
  ]
}

The data blocks then store just the values in binary. If you decoded them back to something readable, three records would look like this:

1, "Alice",   "[email protected]",   true
2, "Bob",     "[email protected]",     false
3, "Charlie", "[email protected]", true

Notice the field names id, name, email appear once in the schema — not on every row like they would in a JSON file. Multiply that saving across millions of records and you can see why .avro files are so much smaller.

How to Open and Read an Avro File

Since .avro files are binary, double-clicking one or opening it in Notepad just shows garbled characters. Here are the real ways to read one:

Online Converter (Easiest)

Drop the file into our Avro to JSON converter and it decodes into clean, readable JSON — no install needed.

Command Line

Use the official avro-tools jar: avro-tools tojson data.avro prints the records as JSON.

Python

Install fastavro and read the file in a few lines — great for data scientists working in notebooks.

Java / Big Data Tools

Spark, Hive, and the rest of the Hadoop ecosystem read .avro natively — usually just point them at the file.

Here's the Python version, which is about as short as it gets:

from fastavro import reader

with open("users.avro", "rb") as f:
    for record in reader(f):
        print(record)

Avro File vs JSON File

The two often get compared because they store similar data. Here's how they stack up:

FeatureAvro FileJSON File
FormatBinaryText
Human ReadableNo (needs a tool)Yes
File SizeSmallLarger
Schema IncludedYes, in the fileNo
Best ForBig data, pipelinesAPIs, config, debugging

Neither is "better" — they're built for different jobs. Reach for a JSON file when you want to read and edit data by hand, and an Avro file when you're moving large volumes efficiently. Want the deeper comparison? See what Apache Avro is.

How to Create an Avro File

You create an Avro file in two steps: define a schema, then write records against it. The fastest way to see the whole thing in action is to start from JSON you already have.

1

Write a schema

Describe your fields and their types in JSON. The Avro schema guide covers every type, or auto-generate one with the schema generator.

2

Convert your data

Run existing JSON through the JSON to Avro converter to produce the .avro output — a great way to compare file sizes instantly.

3

Validate it

Double-check the schema is correct with the schema validator before wiring it into a pipeline.

Free Avro Tools

Everything you need to work with .avro files, right in your browser:

Learn More

Official Resources

Related Guides