StreamID

A StreamID is a globally unique identifier that points to a stream of mutable data on the Ceramic Network. Unlike a traditional pointer, a StreamID is content-addressed, meaning its value is derived from the cryptographic hash of the stream's initial state and metadata. This ensures the identifier is immutable and verifiable, even as the data it points to can be updated over time. The structure typically includes the stream type (e.g., tile), the CommitID of its genesis commit, and a network identifier.

The primary function of a StreamID is to provide a permanent, decentralized reference for mutable documents. When an application requests data using a StreamID, the Ceramic protocol can deterministically locate the current state of the stream across the peer-to-peer network. This is crucial for building applications with user-controlled data, as it allows for versioning, forking, and secure updates without relying on a central registry or database. Each update creates a new commit, but the StreamID remains constant, acting as a stable pointer to the evolving document.

Technically, a StreamID is represented as a multicodec string, such as kjzl6cwe1jw14.... It is composed of several encoded parts: a multicodec prefix indicating the stream type, the CID (Content Identifier) of the stream's genesis commit, and an optional multibase prefix for the encoding. This standardized format ensures interoperability across different tools and clients in the ecosystem. Developers interact with StreamIDs through Ceramic's APIs to create, update, and query streams.

StreamIDs are foundational to Ceramic's data model, enabling use cases like decentralized social graphs, user profiles, and dynamic application settings. For example, a user's profile might be stored in a stream, and its StreamID can be used as a DID (Decentralized Identifier) or linked from other streams. This creates a web of interconnected, user-owned data where references are secure and resilient to central points of failure. The integrity of these references is guaranteed by the underlying content addressing.

In practice, working with StreamIDs involves understanding related concepts like StreamState, which represents the current data and metadata of a stream, and CommitID, which pins a specific historical version. While a StreamID always points to the tip of the stream (the latest state), a CommitID points to a fixed point in its history. This architecture supports complex data interactions, allowing developers to build applications with the flexibility of mutable data and the security guarantees of immutable content addressing.

A StreamID is a Uniform Resource Name (URN) that uniquely and permanently identifies a stream—a mutable data structure—on the Ceramic Network. It is composed of several encoded components: a StreamType, the StreamID itself (a CommitID for the genesis commit), and an optional commit reference. This structure allows any client to deterministically locate and verify the entire history of a stream's data, starting from its creation. Unlike a simple hash, a StreamID points to a living document that can be updated over time by its controller.

The core components of a StreamID are derived from the stream's initial state. When a stream is created, its first operation is a genesis commit. The hash of this commit, known as the StreamID, becomes the immutable root identifier. The StreamID is then combined with a StreamType (e.g., tile or caip10-link) to form the complete URN, following the format: ceramic://<stream-type>/<stream-id>. This design ensures global uniqueness and allows the network to route requests to the correct stream type handler for state resolution and validation.

To interact with a stream, clients use the StreamID to query the Ceramic network. Nodes use the StreamID to fetch the stream state, which is reconstructed by replaying the cryptographic chain of signed commits stored on the decentralized ledger. The StreamID itself does not change when the stream is updated; instead, updates are appended as new commits referenced by their CommitID. This mechanism separates the permanent identity of the stream from its evolving content, which is a fundamental pattern for versioned, decentralized data.

CommitIDs are closely related to StreamIDs. A CommitID is a URN that pinpoints a specific version (commit) within a stream's history, formatted as ceramic://<stream-type>/<stream-id>?commit=<commit-hash>. While a StreamID always resolves to the current state, a CommitID is immutable and resolves to a historical state. This enables powerful features like data provenance, version control, and cacheable references to specific snapshots, all anchored to the stream's primary StreamID.

In practice, developers encounter StreamIDs when creating new streams, loading existing data, or sharing references to ceramic documents. For example, a decentralized social profile might have a StreamID like ceramic://kjzl6cwe1.... Any application can use this ID to fetch the latest profile data, verify all updates were signed by the correct DID, and display it. This interoperable addressing system is foundational for building composable, user-centric applications where data is owned by users and shared across platforms.

A StreamID is a Uniform Resource Name (URN) that uniquely and permanently identifies a specific data stream on the Streamr Network. Its canonical format is urn:streamr:<network>:<chain>/<path>, where the <path> is a hierarchical namespace, often represented as a human-readable domain-like string (e.g., /eth/mainnet/price/eth/usd). This structure allows for logical organization and discovery of streams. The identifier is immutable; once a stream is created with a given StreamID, it cannot be changed, ensuring a permanent reference for publishers and subscribers.

Under the hood, a StreamID resolves to a stream's metadata and its partitioning scheme. The core technical component is the stream's public key, which is derived from the owner's private key during creation. This public key is hashed to form part of the identifier, providing cryptographic proof of ownership and enabling secure permission management. The StreamID is therefore not just a label but a verifiable claim that links the data to its creator, forming the foundation for access control and data provenance on the network.

From a developer's perspective, the StreamID is the primary handle used in all Streamr client libraries (e.g., JavaScript, Python) to publish data to, subscribe to, or query the history of a stream. It decouples the logical stream from its underlying storage and transport mechanisms, allowing the network to handle scalability and redundancy transparently. When a subscriber requests a StreamID, the network locates the relevant broker nodes and storage nodes that host the stream's data partitions, facilitating efficient and decentralized data delivery.