Content Archive (CAR) File

A Content Archive (CAR) file is a serialized format that bundles one or more IPLD (InterPlanetary Linked Data) blocks into a single file, prefixed by a header that acts as an index. This header contains a list of the Content Identifiers (CIDs) for all the blocks within the archive and their byte offsets, enabling efficient random access to specific pieces of data without needing to parse the entire file. The format is defined by IPLD's CAR specification and is essentially a concatenation of the raw, binary block data.

The primary function of a CAR file is to facilitate the bulk transfer and storage of verifiable, content-addressed data. Instead of fetching individual blocks from a distributed network, a node can import a complete CAR file to quickly populate its local datastore. This is crucial for data onboarding in services like Filecoin, where storage providers receive client data packaged as CAR files. The self-contained and indexed nature of the format ensures data integrity, as each block's CID can be recalculated and verified against the index upon import.

Beyond data transfer, CAR files serve as a foundational interoperability layer. They provide a standard way to snapshot, archive, and exchange datasets between different implementations that support the IPLD data model, such as IPFS, Filecoin, and various blockchain platforms. Tools like ipfs-car and go-car are used to create (pack) and extract (unpack) these archives. The format's design emphasizes determinism, meaning the same set of input blocks will always produce an identical CAR file, which is essential for cryptographic verification and reproducible builds in decentralized systems.

A Content Addressable aRchive (CAR) file is a serialized container format that bundles one or more InterPlanetary Linked Data (IPLD) blocks into a single file. Each block contains data (like a file chunk) and is identified by its cryptographic Content Identifier (CID), which acts as a unique, verifiable fingerprint. The CAR format essentially packages the directed acyclic graph (DAG) structure of IPFS content into a portable, self-contained archive, preserving all the links between blocks. This makes it a fundamental tool for data import/export, cold storage, and Filecoin deal-making, as the entire dataset can be verified without external references.

The internal structure of a CAR file is straightforward but powerful. It consists of a header followed by a series of concatenated IPLD blocks. The header specifies the version and the roots—the CIDs of the top-level nodes from which the entire DAG can be traversed. Each subsequent block is stored as a simple pair: the block's length in bytes, the block's CID, and the raw block data itself. This linear sequence allows for efficient streaming and random access, as tools can read the index of CIDs to locate specific blocks without parsing the entire file.

Creating a CAR file, a process called 'car-ing,' involves traversing a DAG from its root CIDs, fetching each linked block, and writing them sequentially to the archive. Common tools for this include ipfs-car and Lotus's generate-car utility. A key property is determinism: given the same DAG and parameters, the generation process should produce an identical CAR file byte-for-byte. This is crucial for trustless verification in systems like Filecoin, where storage providers must prove they are storing the exact data promised in a deal, identifiable by the CAR's root CID.

The primary use case for CAR files is in the Filecoin storage market. When a client wants to store data, they prepare a CAR file from their data and propose a deal containing the Payload CID (the root of the CAR). The storage provider imports this CAR file to their node. Later, for Proof of Spacetime, the provider must prove they still have the data by responding to challenges that can only be answered by possessing the specific blocks within that original CAR. This workflow decouples data preparation from storage, creating a clear, auditable pipeline.

Beyond Filecoin, CAR files are versatile for data migration and distribution. They enable efficient bulk pinning to IPFS nodes by pre-packaging all necessary blocks. Developers use them for static website hosting on IPFS, shipping a single CAR file instead of numerous individual block fetches. The format also facilitates dataset publishing and backups, as the contained data is entirely self-describing and verifiable. As a core primitive of the content-addressed web, the CAR file is the standard vessel for moving verifiable data across networks and protocols.

A Content Archive (CAR) file is a serialized format that packages one or more IPLD (InterPlanetary Linked Data) blocks into a single file, preserving their cryptographic content identifiers (CIDs) and the directed acyclic graph (DAG) structure that links them. The format is defined by IPLD and is essentially a container for the raw, binary block data that makes up content-addressed datasets. Its primary purpose is to enable the efficient import and export of content-addressed data between systems, nodes, and services without losing the intrinsic verifiability provided by CIDs.

The technical specification for CAR files is maintained as IPLD Specification - CAR (Content Addressable aRchives). The file structure consists of a simple header followed by a series of concatenated IPLD blocks. Each block is prefixed by its length in bytes and includes its CID and the corresponding raw binary data. This design allows for random access and streaming, as the CID for each block can be used to locate its data within the archive without needing to parse the entire file sequentially. The format is versioned, with CARv1 being the initial stable version and CARv2 introducing features like an optional index for faster lookups and data payload deduplication.

The etymology of the term stems from its function: it is an Archive format for Content-Addressed data. In practice, CAR files are the standard mechanism for creating static, portable snapshots of IPFS DAGs. They are crucial for data onboarding to services like Filecoin, where storage deals are often made for specific CAR files, and for data pinning services that accept CAR uploads. Developers use libraries like @ipld/car in JavaScript or go-car in Go to generate, read, and manipulate these archives, making them a foundational tool for interoperable, verifiable data exchange in decentralized networks.