Bitstring Status List

A Bitstring Status List is a W3C Verifiable Credentials standard that uses a compact bitstring—a sequence of 0s and 1s—to represent the revocation or suspension status of a batch of credentials. Each credential is mapped to a specific bit position within the string, where a 0 typically indicates the credential is valid, and a 1 indicates it is revoked or suspended. This method provides a highly efficient, privacy-preserving way for verifiers to check credential status without revealing which specific credential is being queried, as the entire list is fetched and the relevant bit is checked locally.

The core innovation is its space efficiency and scalability. Instead of managing individual revocation entries for thousands of credentials, an issuer maintains a single, compressed bitstring. This bitstring is published at a stable URL, often as a Verifiable Credential itself, containing metadata like the statusPurpose (e.g., revocation or suspension), the encodedList (a base64-encoded GZIP-compressed bitstring), and the cryptographic proof of its integrity. This design drastically reduces bandwidth and storage requirements compared to traditional certificate revocation lists (CRLs).

For a verifier to check a credential's status, they follow the credentialStatus property embedded in the credential, which points to the status list's URL and specifies the credential's unique index within the bitstring. The verifier downloads the list, decompresses it, and checks the bit at the given index. This process is cryptographically verifiable, ensuring the list hasn't been tampered with, and is privacy-enhancing because the issuer only sees a request for the entire list, not the index of the credential being verified.

The standard defines two primary list types: a StatusList2021 for general-purpose status tracking and a BitstringStatusListEntry as the corresponding entry in a credential. Key technical parameters include the statusListIndex (the bit position), statusListCredential (the URL of the list VC), and the compression algorithm. This approach is foundational for building scalable, interoperable decentralized identity systems where credential revocation must be efficient, trustworthy, and privacy-respecting.

A Bitstring Status List is a verifiable data structure that uses a string of bits—where each bit represents the binary status (e.g., 0 for valid, 1 for revoked) of a corresponding item in a list—enabling highly efficient and scalable status checks for systems like Verifiable Credentials. This mechanism, defined in the W3C Status List 2021 specification, compresses what would be a large list of individual status entries into a single, compact bitstring, dramatically reducing the data payload required for status dissemination and verification.

The core operation involves indexing and bitwise operations. Each verifiable item, such as a credential, is assigned a unique, stable index number. To check its status, a verifier retrieves the shared bitstring and checks the value of the bit at that specific index. A 1 typically indicates a revoked or suspended status, while a 0 indicates valid. This check is performed using a simple bitwise AND operation against a bitmask, making it computationally trivial and extremely fast, even for lists containing millions of entries.

Integrity and trust are ensured by anchoring the bitstring within a Verifiable Credential itself, known as a Status List Credential. This credential is cryptographically signed by the issuer. The bitstring is encoded, often using Base64 (e.g., "H4sIAAAAAAAA_-3BMQEAAADCoPVPbQwfoAAAAAAAAAAAAAAAAAAAAIC3AYbSVKsAQAAA"), and included in the credential's payload. Verifiers must fetch this credential and verify its signature to trust the status list, ensuring the bitstring has not been tampered with by any intermediary.

The primary advantages are efficiency and privacy. Unlike querying a centralized revocation registry for each credential, a static bitstring can be cached and distributed via content-addressable networks like IPFS. This reduces latency, avoids issuer-side query bottlenecks, and enhances scalability. From a privacy perspective, checking a single bit reveals no information about other entries in the list, unlike some schemes that might leak the total number of revoked items.

Practical implementation requires careful management. Issuers must maintain the mapping between credentials and their immutable index positions. Updates to the status list—such as revoking a credential—require issuing a new version of the Status List Credential with the appropriate bit flipped from 0 to 1, and potentially distributing its new identifier to verifiers. This trade-off favors simplicity and verifiability over real-time, sub-second status updates, making it ideal for use cases where immediate revocation is not critical.

A StatusList2021 entry is a bitstring—a sequence of bits (0s and 1s)—where each bit represents the status (e.g., revoked or valid) of a corresponding Verifiable Credential. The bitstring is encoded in Base64 format for efficient transmission and storage within a credential's credentialStatus property. The position of a bit within the string, known as its index, is used to look up the status of a specific credential, enabling a single list to manage the status of thousands of credentials with minimal data overhead.

The mechanism is defined by the StatusList2021 specification, a W3C Community Group standard. A credential issuer creates a single, centralized bitstring list and publishes its cryptographic digest (e.g., as a statusPurpose and statusListIndex) within each issued credential. To check a credential's status, a verifier uses the index to locate the relevant bit in the published list. A bit value of 1 typically indicates a revoked or suspended status, while 0 indicates the credential is valid, though the specific semantics are defined by the statusPurpose field.

The integrity and authenticity of the status list are guaranteed because the list's URI points to a verifiable credential itself—the StatusList2021Credential. This credential contains the encoded bitstring and is signed by the issuer. Therefore, a verifier must fetch and verify this status list credential just like any other, ensuring the status information is tamper-evident and originates from the trusted issuer. This design separates the status information from the credential payload, enabling efficient, scalable revocation without altering the original credential.