Free Avro and Arrow Viewer
Open an Avro or Arrow file to read its records as JSON, see the schema it was written with, and check how it’s packed.
What is an Avro and Arrow Viewer?
Avro and Arrow are binary formats for moving data between systems: Avro for Kafka messages and Hadoop files, Arrow for fast in-memory tables shared by pandas, Spark and DuckDB. This viewer opens either kind of file and shows the records inside.
Avro container files are decoded here from the specification, including deflate blocks and the logical types for dates, timestamps and decimals. Arrow IPC files and streams, including Feather v2, are read with the official apache-arrow library. Everything runs in your browser.
Key Features
Records as JSON
The first 1,000 records as one JSON object per line, ready to download as NDJSON.
The Real Schema
Avro’s writer schema as stored in the file, or Arrow’s fields with their types and nullability.
Logical Types Applied
Avro dates, timestamps and decimals show as readable values, not raw integers and bytes.
Container Details
Codec, block count and metadata for Avro; file or stream, batches and metadata for Arrow.
Read Locally
Files are decoded in your browser and never uploaded anywhere.
Perfect for everyone
- Data engineers working with Kafka
- Spark and Hadoop
- Analysts handed an .avro or .arrow file
- Developers debugging serialisation
How to Use the Avro and Arrow Viewer
Open the file and switch between the three views. The format is detected for you, so the steps are the same for Avro and Arrow.
Open the File
Choose Open Avro or Arrow file. The format is detected from the first bytes, whatever the extension.
Read the Records
Rows shows each record as JSON, with logical types turned into readable values.
Check the Schema
Schema shows the field names and types the file was written with.
Look at the Container
File info shows the codec, block or batch count and any metadata.
Avro and Arrow Files, Read
Each row is a sample file, named as the sample buttons load it, and each answer is this viewer’s output in the mode on the chip. The files hold greenhouse sensor readings and shop orders, written with avsc and apache-arrow.
“readings.avro”
“readings.avro”
“readings.avro”
“orders.avro”
“readings-plain.avro”
“readings.arrow”
“readings.arrow”
“readings.arrows”
“readings-cut.avro”
“sensors.json”
How Avro and Arrow Files Are Built
Both formats are self-describing: the schema travels inside the file. These ten facts explain what this viewer reads from each, and why the two formats look so different on disk.
Avro Magic
Avro container files start with the bytes Obj followed by 0x01.
“How many magic bytes does Avro use?”
Avro Header Metadata
A map of strings after the magic holds avro.schema, avro.codec and any custom entries.
“Where is the schema stored?”
Sync Markers
A random 16-byte marker follows the header and every block, so readers can find block boundaries.
“How long is a sync marker?”
Avro Blocks
Records are grouped into blocks, each with a record count, a byte size and optional compression.
“Is compression per file or per block?”
Zigzag Varints
Avro writes ints and longs as zigzag variable-length numbers, so small values take one byte.
“How many bytes does -1 take?”
Writer Schema
Data is written without field names, so it can only be read with the schema it was written with.
“Are field names stored in each record?”
Arrow File Magic
Arrow IPC files start and end with ARROW1, with a footer listing the record batches.
“What starts an Arrow file?”
Arrow Streams
The stream format has no footer and starts with a 0xFFFFFFFF continuation marker.
“Does a stream have a footer?”
Record Batches
Arrow stores rows in batches of columns, each column a contiguous buffer.
“Is Arrow row or column oriented?”
Dictionary Encoding
Repeated values such as categories are stored once and referenced by small integer indices.
“Why do categories shrink so well in Arrow?”
Avro’s Type System
Every Avro value is written according to its schema, with no type tags in the data. These are the types the Rows view decodes, and how each one appears in the JSON output.
Primitive Types
null, boolean, int, long, float, double, bytes and string. Ints and longs are zigzag varints, and bytes are shown here as hex.
Records
Named groups of fields written in schema order with no field names in the data. They come out as JSON objects.
Enums
A fixed list of symbols stored as an index into that list. The viewer shows the symbol, such as WARN, rather than the number.
Arrays and Maps
Written in blocks of items, ended by an empty block. Map keys are always strings, so maps come out as JSON objects.
Unions
A branch index followed by the value. A union of null and another type is how Avro writes an optional field.
Fixed
A set number of bytes, such as a 16-byte MD5 hash. It appears as hex unless it carries the decimal logical type.
Logical Types
Annotations on a base type: date, time and timestamp in millis or micros, decimal and uuid. They’re turned into readable strings here.
Arrow Types You’ll See in Schema View
Arrow’s schema names each column’s exact in-memory type. These are the ones that turn up most often in files from pandas, Polars, Spark and DuckDB.
Int32, Int64 and Float64
Fixed-width numbers stored in contiguous buffers. A nullable column adds a validity bitmap marking the missing values.
Utf8 and LargeUtf8
Strings stored as offsets into one data buffer. LargeUtf8 uses 64-bit offsets for columns bigger than 2 GB.
Timestamp
A 64-bit count in seconds, milliseconds, microseconds or nanoseconds, with an optional time zone in the type.
Date32 and Date64
Date32 counts days since 1970 and Date64 counts milliseconds. pandas dates usually arrive as timestamps instead.
Dictionary
Small integer indices pointing into a dictionary of values, the type pandas categoricals become.
List and Struct
Nested types: a List holds a variable number of child values per row, and a Struct holds named child columns.
Avro Schema Evolution
Avro data can be read with a newer schema than the one it was written with, as long as the changes follow a few rules. Knowing them helps when the Schema view shows an older writer schema than you expected.
Adding a Field
A new field needs a default, so readers can fill it in for older records that don’t have it.
Removing a Field
Readers skip fields their schema doesn’t mention. Removing a field without a default breaks older readers.
Renaming a Field
Give the new name an alias listing the old one, so data written under either name still matches.
Widening a Number
int can be read as long, float or double, and long as float or double, without changing the data.
Changing an Enum
Adding symbols is safe when the reader has a default symbol. A writer symbol the reader doesn’t know is an error otherwise.
Writer Versus Reader Schema
The file always stores the writer schema. The reader schema lives in your application or schema registry.
Avro and Arrow Pitfalls
Common reasons a file reads differently from what you expected. Most come from how the file was written, not from the viewer reading it.
Kafka Message Bytes Aren’t Files
A single Kafka message has no container header, often just a 5-byte registry prefix and the record. It won’t open as an Avro file.
Unsupported Codecs
Snappy, zstandard, bzip2 and xz Avro files need converting first, for example with avro-tools recodec.
Lost Logical Types
Some writers drop logicalType from the stored schema, so dates and decimals appear as plain numbers and bytes.
64-Bit Numbers
Longs beyond 2^53 lose precision in JavaScript numbers, so they’re shown as exact strings instead.
Feather v1
The original Feather format before 2020 isn’t Arrow IPC, so very old .feather files won’t open.
Large Files in the Browser
Only the first 1,000 records are shown, and the whole file is held in memory while reading.
Where You’ll Meet These Files
Both formats sit underneath tools you may already use, so an .avro or .arrow file usually comes from one of these systems, even when nobody chose the format on purpose.
Kafka and Schema Registry
Kafka messages are often Avro, with the schema kept in a registry rather than each message.
Hadoop and Spark
Avro container files are a common storage and exchange format in data lakes.
BigQuery Exports
BigQuery can export tables as Avro files, keeping types that CSV loses.
pandas and Feather
df.to_feather writes Feather v2, which is an Arrow IPC file.
Arrow Flight
Services built on Arrow Flight send query results as Arrow streams.
DuckDB and Polars
Both read and write Arrow directly, so tables move between them without copying.
When to Open an Avro or Arrow File
Whenever a binary data file needs a quick look before you load it anywhere, or you need to show someone what’s inside without installing Python, Java or a database.
Debugging a Pipeline
Check that a job wrote the records and fields you expected.
Checking a Schema Change
Compare the writer schema of old and new files before deploying a consumer.
Sharing Data With a Colleague
Download records as NDJSON for someone without data tools.
Verifying an Export
Confirm a BigQuery or Spark export has the right row count and codec.
Learning the Formats
See how schemas, blocks, batches and dictionaries fit together on real files.