OrbitDB is a serverless, distributed, peer-to-peer database for the decentralized web that stores its data in IPFS and syncs it with peers over Libp2p Pubsub, and it is aimed at developers building decentralized, blockchain, and local-first applications in JavaScript.

What it is

OrbitDB is an eventually consistent database written in JavaScript that runs both in browsers and in Node.js, with support for Linux, OS X, and Windows. It keeps no central server: IPFS provides the data storage and Libp2p Pubsub automatically syncs databases with peers, so every participant holds a replica rather than querying a remote host. Conflict resolution comes from Merkle-CRDTs, the structure formalized in the paper of the same name, which gives the database conflict-free writes and merges. Every database type is implemented on top of the project's own OpLog, an immutable, cryptographically verifiable, operation-based conflict-free replicated data structure for distributed systems. A Go implementation is developed and maintained separately by the Berty project at berty/go-orbit-db.

The concrete thing it replaces is the hosted database sitting behind an application. Where a conventional stack would run a database server in a data centre and have clients call it over the network, OrbitDB moves the database into the application itself, so each peer owns its copy of the data. That is what makes it usable for peer-to-peer and decentralized applications, blockchain applications, and local-first web applications, all of which need to keep reading and writing without a reachable backend. The project lives in the IPFS and Libp2p ecosystem, is licensed MIT, and carries 8,808 stars and 595 forks.

Key capabilities

• Four built-in database types: events (an immutable, append-only log with traversable history, useful for "latest N" cases or as a message queue), documents (JSON documents indexed by a specified key, useful for search indices or version controlling documents), keyvalue, and keyvalue-indexed (key-value data indexed in a Level key-value database).
• All data models sit on the OpLog, an immutable, cryptographically verifiable, operation-based CRDT, so writes merge across peers without a coordinating server.
• Synchronization over Libp2p Pubsub, configured with gossipsub and allowPublishToZeroTopicPeers: true, which is necessary to run a single peer.
• IPFS, via Helia, as the backing store; databases are opened by name or address and returned addresses take the form /orbitdb/zd....
• Custom data models: developers can implement and use their own database type by following docs/DATABASES.md#building-a-custom-database, inheriting the same properties as the default models.
• One JavaScript implementation covering both browsers and Node.js; in the browser it loads from the distributed orbitdb.min.js file, exposing the global OrbitDB namespace.
• A parallel Go implementation maintained by the Berty project at berty/go-orbit-db.

Who uses it and how

• Local-first web applications that must stay writable while offline and reconcile changes once peers reconnect.
• Peer-to-peer and decentralized applications that cannot assume a reachable backend for reads or writes.
• Blockchain-adjacent projects that need an off-chain, eventually consistent store shared across nodes.
• Teams that want the same database code running inside a browser tab and inside a Node.js service, from a single JavaScript implementation.
• Developers who want a fast path can follow the @orbitdb/quickstart module.

Getting started

Install with npm install @orbitdb/core helia, then create a Helia IPFS instance and call createOrbitDB({ ipfs }); opening a database without specifying a type defaults to events. The @orbitdb/quickstart module offers a shorter route to a running instance.

How it compares

No comparable products are named in the facts supplied for this entry, so OrbitDB stands alone in this registry. The only sibling implementation the facts identify is the Go port maintained by the Berty project, which follows the same design for non-JavaScript codebases rather than competing with it.

When to use it — and when not to

A self-hoster operates an IPFS node through Helia and Libp2p pubsub peers rather than a database server, which means less to run but also no managed service, no hosted option, and no vendor support behind it. It is the wrong choice for teams that need strong consistency, multi-statement transactions, or a formal service-level agreement, because OrbitDB is explicitly eventually consistent and resolves conflicts through CRDT merge rather than locking. The project is actively maintained, with a last push on 2026-05-14, an MIT licence, and 25 open issues, so the main caution is architectural rather than a question of abandonment.

npm install @orbitdb/core helia

import { createHelia } from 'helia'
import { createOrbitDB } from '@orbitdb/core'
import { gossipsub } from "@chainsafe/libp2p-gossipsub";
import { identify } from "@libp2p/identify";
import { createLibp2p } from 'libp2p'

const Libp2pOptions = {
  services: {
    pubsub: gossipsub({
      // neccessary to run a single peer
      allowPublishToZeroTopicPeers: true
    }),
    identify: identify()
  }
}

;(async function () {
  const libp2p = await createLibp2p({ ...Libp2pOptions })
  const ipfs = await createHelia({libp2p})
  const orbitdb = await createOrbitDB({ ipfs })

  // Create / Open a database. Defaults to db type "events".
  const db = await orbitdb.open("hello")
  
  const address = db.address
  console.log(address)
  // "/orbitdb/zdpuAkstgbTVGHQmMi5TC84auhJ8rL5qoaNEtXo2d5PHXs2To"
  // The above address can be used on another peer to open the same database

  // Listen for updates from peers
  db.events.on("update", async entry => {
    console.log(entry)
    const all = await db.all()
    console.log(all)
  })

  // Add an entry
  const hash = await db.add("world")
  console.log(hash)

  // Query
  for await (const record of db.iterator()) {
    console.log(record)
  }
  
  await db.close()
  await orbitdb.stop()
  await ipfs.stop()
})()

npm run test

npm run build

node benchmarks/orbitdb-events.js

npm run build:docs