OPEN-SOURCE GRAPH DATABASE & DOCUMENT STORE
An in-memory, distributed, and open-source document graph database for people who want the convenience of documents with the query power of graph relationships. For people who want data to be the star of their builds.
A document-oriented graph database with version control & collaboration model
TerminusDB is an immutable database, storing changes as deltas. Immutability enables collaboration workflows, version control, diff and patch, time travel, and the ability to branch, clone, and merge your database. Use TerminusDB to model and build data-intensive, collaborative applications. Its features include:
Faster Time to Market
TerminusDB & TerminusX are fast – really fast. Build an application MVP in a single sprint.
Schema First
The flexible and extendable JSON schema syntax acts as a blueprint to model data and develop scalable applications.
Customizable
Automatically generate UIs and forms that have data validation as standard.
Like Git for Data
A versioning first database, fork, clone, branch, and merge, just like Git, to collaborate with colleagues, time travel, and develop with the safety of undo.
Document Oriented
Work with JSON documents and build relationships between documents in a powerful knowledge graph.
Easy
Quick to install, start building your apps in minutes.














Document store &
graph database
TerminusDB is the easiest way to build a knowledge graph. The schema connects JSON documents into a graph. With numerous features and several programming interfaces, TerminusDB is the right database for data-intensive, immutable, and synchronized applications. Its collaboration model provides Git-like operations such as workflows, time travel, and version control to help you build and to use as app functionality.
# Create database
terminusdb db create admin/philosophers
# Add a schema
echo '{ "@type" : "Class",
"@id" : "Philosopher",
"name" : "xsd:string" }' | terminusdb doc insert admin/philosophers -g schema
# Add a JSON document
echo '{ "name": "Socrates" }' | terminusdb doc insert admin/philosophers
# Get the document back
terminusdb doc get admin/philosophers
# Prove that it works, Socrates is there!
# Branch the database
terminusdb branch create admin/philosophers/local/branch/changes --origin admin/philosophers
# Add more philosophers to new branch
echo '{ "name": "Plato" }' | terminusdb doc insert admin/philosophers/local/branch/changes
echo '{ "name": "Aristotle" }' | terminusdb doc insert admin/philosophers/local/branch/changes
# Look at the difference between branches
terminusdb diff admin/philosophers --before-commit main --after-commit changes | jq
# Apply the differences to main
terminusdb apply admin/philosophers --before-commit main --after-commit changes
# Look at the difference again
terminusdb diff admin/philosophers --before-commit main --after-commit changes | jq
#!/usr/bin/env python3
from terminusdb_client import Client
from random import random
client = Client("http://localhost:6363", account="admin", team="admin", key="root")
client.connect()
db_name = "philosophers" + str(random())
client.create_database(db_name)
client.connect(db=db_name)
# Add a philosopher schema
schema = {"@type": "Class",
"@id": "Philosopher",
"name": "xsd:string"
}
# Add schema and Socrates
client.insert_document(schema, graph_type="schema")
client.insert_document({"name": "Socrates"})
# Verify that it added in the DB
print(list(client.get_all_documents()))
# Create new branch and switch to it
client.create_branch("changes")
client.branch = "changes"
# Add more philosophers
client.insert_document({"name": "Plato"})
client.insert_document({"name": "Aristotle"})
# Diff the branches
diff = client.diff_version("main", "changes")
print(diff)
# Apply the differences to main with apply
applied = client.apply("main", "changes", branch='main')
print("Applied:")
print(applied)
# Diff again
diff_again = client.diff_version("main", "changes")
print("Second diff:")
print(diff_again)
const Client = require('@terminusdb/terminusdb-client');
const client = new Client.WOQLClient(
'http://127.0.0.1:6363',
{
user: 'admin',
key: 'root',
},
);
async function main() {
// Create a database
await client.createDatabase('philosophers', {
label: 'Philosophers',
comment: 'Philosophers by name',
schema: true,
});
// Add the philosopher type
const schema = {
'@type': 'Class',
'@id': 'Philosopher',
name: 'xsd:string',
};
await client.addDocument(schema, { graph_type: 'schema' });
// Add Socrates
await client.addDocument({ name: 'Socrates' });
// Get back all documents
const doc = await client.getDocument({ as_list: true });
console.log(doc);
// Create a branch
await client.branch('changes');
// Add more philosophers to the new branch
await client.addDocument({ name: 'Plato' });
await client.addDocument({ name: 'Aristotle' });
// Look at the differences between branches
const diffs = await client.getVersionDiff('main', 'changes');
console.log(diffs);
// Apply the differences to main
client.checkout('main');
await client.apply('main', 'changes', 'apply changes');
// Check the for any remaining differences between branches
const remaining_diffs = await client.getVersionDiff('main', 'changes');
console.log(remaining_diffs);
}
main();
TerminusDB - Build data-intensive apps fast
The TerminusDB schema language connects JSON documents into a graph. It is a distributed database with a collaboration model, designed to be like Git, but for data. Model your data and schema, store data as JSON, and use graph relationships within your queries to build data-first apps.
TerminusX - The Beta Builder
TerminusX is TerminusDB as a service. SOC 2 certified cloud hosting. Get your beta and MVPs to market fast. Featuring all of the Git-like collaboration features of TerminusDB to model data and build data-intensive apps. The easiest path to use a knowledge graph to build with intelligent data.
TerminusX: Beta Builder
TerminusX is TerminusDB as a service. SOC 2 certified hosting. Build your beta and get to market fast. Scale up and deploy your own instance. With the simplicity of JSON combined with the power of knowledge graphs, TerminusX is the easiest way to build a graph.
Set up your document properties,
XSD types, and create linked
properties to set the edges of
your graph.
Create data products and set up
organizations and teams to
collaboratively work on them.
Time travel through the data
product, and connect to a client
of your choice.
Visually build your schema by adding
documents, subdocuments, and enums
to blueprint your applications.
Use the data product tools to branch
your data product, view, edit, and add
data, and to build and test queries.
Data Consultancy
READY TO GET STARTED?
Start building today with TerminusDB. Follow the link below to the installation documentation. Alternatively, try TerminusX the Beta Builder to get your MVP up and running fast.