Ceramic Network is a decentralized data network that enables storing, updating, and retrieving mutable data on the decentralized web. It's the infrastructure layer that makes composable Web3 applications and portable identity possible.
Think of Ceramic as a decentralized database - where data can be updated, versioned, and accessed by any application, while remaining user-controlled.
Core Concept
Traditional Database vs Ceramic
Traditional:
- Centralized server
- Company controls data
- Data locked to app
- Single point of failure
Ceramic:
- Decentralized network
- User controls data
- Data portable across apps
- No single point of failure
Copy link
Key Components
1. Streams
The fundamental data unit in Ceramic
Mutable : Can be updated over time
Versioned : Full history preserved
Verifiable : Cryptographically signed
Replicated : Stored across network
2. StreamTypes
Predefined schemas for data structures
Common StreamTypes :
TileDocument : General-purpose documents
CAIP-10 Link : Blockchain account links
DID Data Store : Identity data storage
3. ComposeDB
GraphQL API layer on Ceramic
Query data easily
Relationships between streams
Real-time subscriptions
Developer-friendly
4. 3ID DID
Decentralized identifiers on Ceramic
Multi-chain identity
Key rotation support
Linked to blockchain accounts
Portable across apps
5. Data Models
Standardized schemas for common use cases
Profile data
Social connections
Credentials
Application state
Why Ceramic Matters
The Data Problem in Web3
Challenge Traditional Solution Ceramic Solution Mutable Data Store off-chain (centralized) Decentralized mutable streams User Control Company owns data User signs all updates Composability API integrations Direct stream access Portability Export/import Native cross-app Versioning Application logic Built into
What Ceramic Enables
Portable Identity
User profiles that work everywhere
Social graphs that span apps
Credentials you own and control
Composable Data
Apps build on each other's data
No API integrations needed
Permissionless innovation
User-Controlled Data
You sign every update
Choose who can access
Revoke access anytime
How Ceramic Works
Stream Lifecycle
1. Create Stream
- Define schema
- Initial content
- Signed by controller (user)
2. Update Stream
- New content
- Signed by controller
- New commit created
3. Replication
- Stream stored on nodes
- P2P network (libp2p)
- Available globally
4. Query Stream
- Any app can query
- Get current state
- Or full history
Copy link
Technical Architecture
Application Layer (ComposeDB, apps)
↓
Stream Layer (Streams, StreamTypes)
↓
Network Layer (libp2p, IPFS)
↓
Storage Layer (Ceramic nodes)
Copy link
Data Flow
User Action
↓
App creates/updates stream
↓
User signs with DID
↓
Stream committed to network
↓
Nodes replicate stream
↓
Other apps can query
Copy link
Use Cases
1. User Profiles
Portable identity across apps:
User creates profile on App A
↓
Profile stored as Ceramic stream
↓
User visits App B
↓
App B reads profile from Ceramic
↓
Same profile everywhere
Copy link
Example : Self.ID, multiple Web3 apps
2. Social Graphs
Decentralized social connections:
User follows someone on App A
↓
Follow stored in Ceramic
↓
App B reads follows
↓
Social graph portable
Copy link
Example : Orbis, Sapien
3. Credentials & Achievements
User-owned credentials:
User completes course
↓
Credential issued to Ceramic stream
↓
User controls credential
↓
Can prove to any app
Copy link
Example : Rabbithole, Layer3
4. Application Data
Decentralized app state:
User interacts with app
↓
State stored in Ceramic
↓
No centralized database
↓
Data always accessible
Copy link
Example : Various Web3 apps
5. Content Publishing
Decentralized content:
Author writes article
↓
Published to Ceramic stream
↓
Content immutable (or updatable)
↓
Available on any platform
Copy link
Example : Mirror, Paragraph
6. DID Documents
Identity infrastructure:
User creates DID
↓
DID document in Ceramic
↓
Links to blockchain accounts
↓
Portable identity
Copy link
ComposeDB
GraphQL interface for Ceramic:
Why ComposeDB?
Developer-Friendly : GraphQL API
Relational Data : Model relationships
Real-Time : Subscriptions
Indexing : Fast queries
Example Query
query {
node(id: "stream-id") {
... on TileDocument {
content
controllers
}
}
}
Copy link
Example Mutation
mutation {
createTileDocument(input: {
content: { name: "Alice", bio: "Web3 builder" }
controller: "did:3:..."
}) {
document {
id
content
}
}
}
Copy link
Data Models
Standardized schemas for common data:
Core Data Models
1. Basic Profile
{
"name": "Alice",
"description": "Web3 builder",
"emoji": "🚀",
"background": "#000000"
}
Copy link
2. Crypto Accounts
{
"eth": "0x742d35Cc...",
"btc": "bc1qxy2k..."
}
Copy link
3. Social Connections
{
"following": ["did:3:...", "did:3:..."],
"followers": [...]
}
Copy link
4. Also Known As
{
"accounts": [
{ "service": "twitter", "username": "alice" },
{ "service": "github", "username": "alice" }
]
}
Copy link
Ceramic vs Other Solutions
Feature Ceramic IPFS Arweave Traditional DB Mutability Yes No (new CID) No Yes Decentralized Yes Yes Yes No Versioning Built-in Via CIDs No Custom
Benefits
For Users
Data Ownership : You control your data
Portability : Works across all apps
Interoperability : No lock-in
Privacy Control : Choose who sees what
For Developers
No Backend : Don't need your own database
Composability : Build on existing data
User Acquisition : Users bring their data
Interoperability : Works with other apps
Standards : Common data models
Innovation : Permissionless building
Network Effects : More data = more value
Censorship Resistance : No central control
Limitations & Challenges
Scalability
Challenge : Network can be slow
Impact : Not suitable for high-frequency updates
Mitigation : Caching, optimistic updates, L2s
Complexity
Challenge : Learning curve for developers
Impact : Barrier to adoption
Mitigation : Better docs, tools, ComposeDB
Reliability
Challenge : Node availability
Impact : Data may be temporarily unavailable
Mitigation : More nodes, pinning services
Cost
Challenge : No token economics yet
Impact : Free now, may cost later
Mitigación : Still early, economics evolving
Getting Started
For Users
Self.ID :
Visit self.id
Connect wallet
Create profile
Link accounts
Use across apps
For Developers
1. Install SDK
npm install @ceramicnetwork/cli @ceramicnetwork/http-client
Copy link
2. Create Client
import { CeramicClient } from '@ceramicnetwork/http-client'
const ceramic = new CeramicClient('https://ceramic-clay.3boxlabs.com')
Copy link
3. Create Stream
const stream = await ceramic.createTile(
{ name: 'Alice', bio: 'Web3 builder' },
{ schema: schemaCommitId },
{ controller: did }
)
Copy link
4. Update Stream
await stream.update({ name: 'Alice Smith', bio: 'Web3 builder' })
Copy link
5. Query Stream
const stream = await ceramic.loadStream(streamId)
console.log(stream.content)
Copy link
Network Options
Status : Live
Use : Production apps
Cost : Free (for now)
Status : Test network
Use : Development/testing
Cost : Free
Local Node
Status : Self-hosted
Use : Development
Cost : Free
Ecosystem
Identity & Profiles
Self.ID : User profiles
Orbis : Social platform
Sapien : Social network
Credentials
Rabbithole : Learning credentials
Layer3 : Quest platform
Infrastructure
ComposeDB : GraphQL layer
3ID Connect : Auth
IDX : Data index
Applications
Mirror : Blogging
Paragraph : Newsletter
Disourse : Forums
Future Roadmap
Technical
Scalability : Better performance
Privacy : Zero-knowledge options
Economics : Token model
Governance : Decentralized governance
Ecosystem
More Data Models : Standard schemas
Better Tooling : Developer experience
More Apps : Adoption
Enterprise : Business solutions
Resources
See Also