OrbitDB HTTP API – A Practical Guide

OrbitDB is the distributed, p2p database system which will revolutionize the way we store, replicate, and disseminate information and will become the cornerstone of any dApp which requires data storage.

Too much centralization has put control of the internet into the hands of a few. Web3 aims to decentralize the internet, providing a more democratized, distributed ecosystem.

Most of the hype is around cryptocurrencies and the freedoms they will bring, cutting out the middleman and putting control back in the hands of the people. However, there are a number of less “high-profile” but equally game changing projects which will reshape the internet as we know it.

This how-to briefly covers the basics of how to create an OrbitDB database and store data as well as introduce the most powerful feature of OrbitDB; replicating the data across multiple locations.

OrbitDB, the decentralized database

OrbitDB is a decentralized database system which uses IPFS for distributing stored data via P2P technologies. Storing data in OrbitDB ensures high availability and low latency due to the nature of distributed architectures such as IPFS.

Originally, OrbitDB was available as a Node.js library, so usage was limited to Node-based applications. However, with the recent release of the OrbitDB REST API, any language which supports REST calls can leverage this distributed database.

Setting up

Running an OrbitDB REST server is relatively straight-forward but some knowledge or working on the command line will be required. These steps assume you are running Linux or some other Unix-based operating system. For Windows users, you will need to translate the commands to your environment.


Firstly, this guide assumes you can use a command line and install software. You don’t need to know node.js or how peer-to-peer systems work but you will need to be able to execute commands in a terminal. In this guide, all commands will be run from the terminal and will be represented like so:

type commands at the command line

You will also need two machines running since we will be replicating a decentralized database. This can either be two physical computers, a couple of virtual machines or docker containers.

Lastly, because the OrbitDB server uses Node.js you will also need npm (bundled with Node.js) to install the dependencies. This tutorial will not cover the installation and configuration of these requirements.

Running IPFS

OrbitDB uses IPFS to distribute and replicate data stores. The OrbitDB HTTP server runs in one of two modes; local or api.

When run in Local mode, OrbitDB will run its own IPFS node. When run in api mode, OrbitDB will connect to an already-running IPFS node.

For this tutorial we will connect to a running IPFS daemon and will assume you already have this installed. You will also want to run IPFS daemon with pubsub enabled.

Start your first IPFS daemon by running:

ipfs daemon --enable-pubsub-experiment

Building the REST server

Now get a copy of the code. You can grab it via Github at https://github.com/orbitdb/orbit-db-http-api:

wget https://github.com/orbitdb/orbit-db-http-api.zip

Alternatively, you can clone the git repo:

git clone https://github.com/orbitdb/orbit-db-http-api.git

Install your dependencies:

npm install

Setting up the SSL certificates

The latest version of the OrbitDB HTTP API incorporates HTTP/2. Therefore, to run the server, you will need to generate SSL certificates.

There are a couple of options available for obtaining certificates; you can issue a certificate using a certificate authority such as Let’s Encrypt, or, you can become your own CA. For development environments, the second option may be better and a thorough overview on how to do this is covered by the tutorial Self-signed certificates with local root CA.

The rest of this guide will assume you have a trusted SSL certificate set up and that curl will use your trust store to validate the certificate. If not, you will need to tell curl to ignore the certificate verification by passing the -k flag:

curl -k -X GET ...

Up and Running

Starting the HTTP API server

Start up the OrbitDB server and connect to your running ipfs:

node src/cli.js api --ipfs-host localhost --orbitdb-dir ./orbitdb --https-key localhost.key --https-cert localhost.crt

The –https-key and –https-cert options above assume you are using the certificate and key generated from the tutorial Self-signed certificates with local root CA. If not, replace with your own certificate and key.

Consuming our first request

The REST server is now running. You can test this by running something simple (we are going to use cURL to run the rest of these command so make sure you have it installed):

curl -X GET http://localhost:3000/identity

This will return a JSON string representing your OrbitDB node’s identity information. This includes your public key (which we will use later).

Create a database

Creating a data store is very easy with the REST API and you can launch a store based on any of the supported types. For example, you can create a feed data store by running:

curl -X POST http://localhost:3000/db/my-feed --data 'create=true' --data 'type=feed'

You can also use JSON to specify the initial data store features:

curl -X POST http://localhost:3000/db/my-feed -H "Content-Type: application/json" --data '{"create":"true","type":"feed"}'

Add some data

Let’s add some data to our feed:

curl -X POST http://localhost:3000/db/my-feed/add --data-urlencode "A beginner's guide to OrbitDB REST API"

And viewing the data we have just added:

curl -X GET  http://localhost:3000/db/my-feed/all

["A beginner's guide to OrbitDB REST API"]

Be aware that there are two different endpoints for sending data to the store, and which endpoint you use will depend on the store’s type. For example you will need to call /put when adding data to a docstore.


Replicating is where the real power of distribution lies with OrbitDB. Replication is as simple as running an OrbitDB REST node on another machine.

Assuming you have a second computer which is accessible over your intranet or via Docker or a virtual machine, you can replicate the my-feed feed data store.

Getting ready to replicate

Before you replicate your feed data store, you will need to make a note of its address. You can do this by querying the data store’s details:

curl http://localhost:3000/db/my-feed


Copy the id. We’re going to use it in the next step.

Running another copy of the data store

On your second machine, make sure you have IPFS running and the OrbitDB REST server installed and running.

Replicating the my-feed data simply requires you query the first machine’s my-feed data store using the full address. Using the address of the my-feed data store I queried earlier, request the data:

curl http://localhost:3000/db/zdpuAzCDGmFKdZuwQzCZEgNGV9JT1kqt1NxCZtgMb4ZB4xijw%2Fmy-feed/all

["A beginner's guide to OrbitDB REST API"]

You may need to run the curl call a couple of time; OrbitDB will take a small amount of time to replicate the data over.

There are two important things to note about the address; 1) we drop the /orbitdb/ prefix and 2) we need to url encode the /. The html encoded value of / is %2F.

And that’s it. You have successfully created a new OrbitDB data store on one machine and replicated across another.

Let’s test it out. Back on your first machine, add another entry to the feed data store:

curl -X POST http://localhost:3000/db/my-feed/add --data-urlencode "Learning about IPFS"

On your second machine, retrieve the feed list again:

curl http://localhost:3000/db/zdpuAzCDGmFKdZuwQzCZEgNGV9JT1kqt1NxCZtgMb4ZB4xijw%2Fmy-feed/all

["A beginner's guide to OrbitDB REST API","Learning about IPFS"]

Adding data in a decentralized environment

What happens if you want to add more entries to the my-feed data store from your second machine:

curl -X POST http://localhost:3000/db/my-feed/add --data-urlencode "Adding an item from the second OrbitDB REST peer."
{"statusCode":500,"error":"Internal Server Error","message":"Error: Could not append entry, key \"03cc598325319e6c07594b50880747604d17e2be36ba8774cd2ccce44e125da236\" is not allowed to write to the log"}

If you check the output from your REST server you will see a permissions error. By default, any replicating node will not be able to write back to the data store. Instead, we have tell the originating OrbitDB instance that the second instance can also write to the my-feed data store. To do this, we must manually add the public key of the second OrbitDB instance to the first instance.

It is important to note that the data store must be created with an access controller pre-specified. Start by deleting the data store on the first machine:

curl -X DELETE http://localhost:3000/db/my-feed

We must now set up the my-feed database again and add some data:

curl -X POST http://localhost:3000/db/feed.new -H "Content-Type: application/json" --data '{"create":"true","type":"feed","accessController":{"type": "orbitdb","write": ["048161d9685991dc87f3e049aa04b1da461fdc5f8a280ed6234fa41c0f9bc98a1ce91f07494584a45b97160ac818e100a6b27777e0b1b09e6ba4795dcc797a6d8b"]}}'

Note the accessController property; this specify the controller type and the key which can write to the database. In this case it is the first machine’s public key, which can be retrieved by running:

curl http://localhost:3000/identity

On the second machine, retrieve the public key:

curl http://localhost:3000/identity

Grab the publicKey value. We will now enable write access to the my-feed database:

curl -X PUT http://localhost:3000/db/feed.new/access/write --data 'publicKey=04072d1bdd0e5e43d9e10619d997f6293f4759959e19effb958785b7f08413fb81501496a043385c245dedc952ee01c06bc9c654afe79b11dd5f130796baf8d2da'

publicKey will be the publicKey of the second machine. We must execute this request from the first machine because only the first machine currently has write permissions to the data store.

With the second machine’s publickey added, we can go ahead and add a new my-feed from the second machine:

curl -X POST http://localhost:3000/db/my-feed/add --data-urlencode "Adding an item from the second OrbitDB REST peer."


This brief introduction to the new OrbitDB HTTP API will hopefully provide some insights into how OrbitDB functions and will hopefully highlight some of the benefits a distributed database system brings to the decentralized web.

We have only scratched the surface of what is possible with OrbitDB. You could go ahead and add other machines to my-feed’s write access controller or create different data stores for storing data in different formats. Also the HTTP API is only in its infancy and there are a number of new features being actively developed.

This new chapter in OrbitDB’s brief history is going to bring a lot of new development and providing access to other languages will expand its usability.

Leave a Reply

Your email address will not be published. Required fields are marked *