Contact Us

Trusted by


NebulaGraph v3.8.0 released !

Introduced the SINGLE SHORTEST PATH statement

Why choose NebulaGraph Database

Proudly open source

 Flexible deployment

Flexible deployment

Take NebulaGraph Database wherever you want, on-premises, public cloud, hybrid deployment, or even on macOS/Windows. Plus, with easy-to-use browser-based visualization toolkits, you can take graph technology to the next level.

High-speed data processing

High-speed data processing

NebulaGraph's powerful native graph engine enables lightning-fast QPS and TPS with millisecond latency. With high concurrency, efficient graph traversals, and optimized memory usage, you can process sheer volumes of graph data blazingly fast.

Intuitive efficiency

Intuitive efficiency

NebulaGraph simplifies data queries with nGQL, a query language that is easy to learn and use, efficiently transforming complex SQL queries into brief graph queries. And with compatibility for openCypher and ISO-GQL, you can cut down learning and migration costs while maximizing efficiency.

High Availability

Edges and Vertices

Queries Per Second


A graph database made for the cloud

The graph database following the cloud-native way

Highly performant

NebulaGraph leverages the powerful storage engine RocksDB to provide low-latency read and write and high throughput. It uses a state-of-the-art design that delivers highly concurrent access, fast graph traversals, and efficient use of memory. NebulaGraph is the only open source graph database that can store and process graphs with trillions of edges and vertices.

Learn more
Highly performant

Native GQL support

NebulaGraph Enterprise v5.0 stands as the first distributed graph database to offer native GQL. Unlike systems that are just compatible or adapted to GQL, it has been built on and designed for GQL at the overall architecture level. This enhancement offers superior data compatibility and interoperability, thereby amplifying the business value of graph databases across various scenarios.

Learn more
Native GQL support

Horizontally scalable

With a shared-nothing distributed architecture, NebulaGraph offers linear scalability, meaning that you can add more nodes or services to the cluster without affecting performance. It also means that if you want to horizontally scale out NebulaGraph, you don’t need to change the configuration of the existing nodes. As long as the network bandwidth is sufficient, you can add more nodes without changing anything else.

Learn more
Horizontally scalable

Resilient to failures

With horizontal scalability and a snapshot feature, NebulaGraph guarantees high availability even in case of failures. The snapshot feature allows users to take snapshots of a NebulaGraph instance at any point in time so that they can use them to restore data at that specific time. If a disaster occurs, NebulaGraph can be recovered from snapshots without data loss. When an instance fails, NebulaGraph will first remove this instance from the cluster and create a new one based on the snapshot to replace this failed instance. This process is fully automatic and transparent to clients.

Learn more
Resilient to failures

Production ready

NebulaGraph is mature, stable, and production-ready. NebulaGraph has been widely used in production by enterprises worldwide including Snap, Akulaku, GrowingIO, BIGO, and IRL. These companies are using NebulaGraph in their production environments for real-world applications like knowledge graph, recommendation systems, and fraud detection.

Learn more
Production ready

NebulaGraph FAQ

What is a graph database, and why is it useful?

A graph database stores and queries data as graphs, using vertices for entities and edges for relationships. It's useful for efficiently handling complex, interconnected data, offering superior performance for queries involving deep relationships.

What are graph databases good for?

Graph databases are well-suited for use cases like social networks, recommendation engines, fraud detection, cyber security and network analysis, among others. They are designed to efficiently solve problems that require traversing relationships between data points.

What makes NebulaGraph stand out in terms of performance?

NebulaGraph boasts a powerful native graph engine that ensures lightning-fast QPS and TPS with millisecond latency. It also offers high concurrency, efficient graph traversals, and optimized memory usage. It offers unique features and performance advantages, especially for super large-scale graphs.

How user-friendly is NebulaGraph?

NebulaGraph offers an intuitive graph query language called nGQL, which simplifies data queries. It's easy to learn and use, efficiently transforming complex SQL queries into brief graph queries. Additionally, it's compatible with openCypher.

Is NebulaGraph a cloud-native graph database?

Yes, NebulaGraph follows a cloud-native approach, ensuring high performance, resilience to failures, and horizontal scalability. It's designed to work seamlessly in the cloud, providing benefits like low-latency reads/writes and high throughput.

How does NebulaGraph ensure data resilience and recovery?

NebulaGraph is resilient to failures. It offers a snapshot feature that allows users to take snapshots of a NebulaGraph instance at any point in time. In case of a disaster, NebulaGraph can be recovered from these snapshots without data loss.

Who uses NebulaGraph in production?

NebulaGraph is production-ready and has been adopted by companies in the following categories: Internet companies: Snap, IRL, Meituan, Tencent Fintech:Airwallex, Akulaku Network Security: reversingLabs,

Is NebulaGraph available for free?

Yes, it’s open-source; but the enterprise edition is recommended for production use.

Is NebulaGraph available on cloud?

Yes, NebulaGraph is currently available on AWS and Azure. The introduction of NebulaGraph Cloud is available here https://www.nebula-graph.io/cloud.

How can developers integrate with NebulaGraph?

NebulaGraph supports various programming languages, such as C++, Python, Java, Node.js, Go, allowing developers to integrate using their preferred language. It also offers a range of client libraries and connectors for easy integration.

What tools and features are available for Data Scientists using NebulaGraph?

Data scientists can benefit from powerful data visualization and graph exploration tools, deploy the NebulaGraph database on their local computers, use an SQL-like query language, and connect to platforms like Spark and Flink using the NebulaGraph Spark/Flink Connector.

How does NebulaGraph cater to DevOps & DBA professionals?

NebulaGraph provides a visualized graph database and cluster management tool, effortless scaling options, enterprise-grade security, and automatic disaster recovery without downtime. It can be deployed on both single machines and clusters.

Distributed graph database system


Use your favorite programming languages

Welcome to NebulaGraph Community

#include <atomic>
#include <chrono>
#include <thread>

#include <nebula/client/Config.h>
#include <nebula/client/ConnectionPool.h>
#include <common/Init.h>

int main(int argc, char* argv[]) {
    nebula::init(&argc, &argv);
    auto address = "";
    if (argc == 2) {
        address = argv[1];
    std::cout << "Current address: " << address << std::endl;
    nebula::ConnectionPool pool;
    pool.init({address}, nebula::Config{});
    auto session = pool.getSession("root", "nebula");
    if (!session.valid()) {
        return -1;

    auto result = session.execute("SHOW HOSTS");
    if (result.errorCode != nebula::ErrorCode::SUCCEEDED) {
        std::cout << "Exit with error code: " << static_cast<int>(result.errorCode) << std::endl;
        return static_cast<int>(result.errorCode);
    std::cout << *result.data;

    std::atomic_bool complete{false};
    session.asyncExecute("SHOW HOSTS", [&complete](nebula::ExecutionResponse&& cbResult) {
        if (cbResult.errorCode != nebula::ErrorCode::SUCCEEDED) {
            std::cout << "Exit with error code: " << static_cast<int>(cbResult.errorCode)
                      << std::endl;
        std::cout << *cbResult.data;

    while (!complete.load()) {

    return 0;
import (

	nebula "github.com/vesoft-inc/nebula-go/v3"

const (
	address = ""
	// The default port of NebulaGraph 2.x is 9669.
	// 3699 is only for testing.
	port     = 3699
	username = "root"
	password = "nebula"

// Initialize logger
var log = nebula.DefaultLogger{}

func main() {
	hostAddress := nebula.HostAddress{Host: address, Port: port}
	hostList := []nebula.HostAddress{hostAddress}
	// Create configs for connection pool using default values
	testPoolConfig := nebula.GetDefaultConf()

	// Initialize connection pool
	pool, err := nebula.NewConnectionPool(hostList, testPoolConfig, log)
	if err != nil {
		log.Fatal(fmt.Sprintf("Fail to initialize the connection pool, host: %s, port: %d, %s", address, port, err.Error()))
	// Close all connections in the pool
	defer pool.Close()

	// Create session
	session, err := pool.GetSession(username, password)
	if err != nil {
		log.Fatal(fmt.Sprintf("Fail to create a new session from connection pool, username: %s, password: %s, %s",
			username, password, err.Error()))
	// Release session and return connection back to connection pool
	defer session.Release()

	checkResultSet := func(prefix string, res *nebula.ResultSet) {
		if !res.IsSucceed() {
			log.Fatal(fmt.Sprintf("%s, ErrorCode: %v, ErrorMsg: %s", prefix, res.GetErrorCode(), res.GetErrorMsg()))

		// Prepare the query
		createSchema := "CREATE SPACE IF NOT EXISTS basic_example_space(vid_type=FIXED_STRING(20)); " +
			"USE basic_example_space;" +
			"CREATE TAG IF NOT EXISTS person(name string, age int);" +
			"CREATE EDGE IF NOT EXISTS like(likeness double)"

		// Excute a query
		resultSet, err := session.Execute(createSchema)
		if err != nil {
		checkResultSet(createSchema, resultSet)
	// Drop space
		query := "DROP SPACE IF EXISTS basic_example_space"
		// Send query
		resultSet, err := session.Execute(query)
		if err != nil {
		checkResultSet(query, resultSet)

	log.Info("Nebula Go Client Basic Example Finished")
NebulaPoolConfig nebulaPoolConfig = new NebulaPoolConfig();
List<HostAddress> addresses = Arrays.asList(new HostAddress("", 9669),
        new HostAddress("", 9670));
NebulaPool pool = new NebulaPool();
pool.init(addresses, nebulaPoolConfig);
Session session = pool.getSession("root", "nebula", false);
session.execute("SHOW HOSTS;");
from nebula3.gclient.net import ConnectionPool
from nebula3.Config import Config

# define a config
config = Config()
config.max_connection_pool_size = 10
# init connection pool
connection_pool = ConnectionPool()
# if the given servers are ok, return true, else return false
ok = connection_pool.init([('', 9669)], config)

# option 1 control the connection release yourself
# get session from the pool
session = connection_pool.get_session('root', 'nebula')

# select space
session.execute('USE nba')

# show tags
result = session.execute('SHOW TAGS')

# release session

# option 2 with session_context, session will be released automatically
with connection_pool.session_context('root', 'nebula') as session:
    session.execute('USE nba')
    result = session.execute('SHOW TAGS')

# close the pool
// ESM
import { createClient } from '@nebula-contrib/nebula-nodejs'

// CommonJS
// const { createClient } = require('@nebula-contrib/nebula-nodejs')

// Connection Options
const options = {
  servers: ['ip-1:port','ip-2:port'],
  userName: 'xxx',
  password: 'xxx',
  space: 'space name',
  poolSize: 5,
  bufferSize: 2000,
  executeTimeout: 15000,
  pingInterval: 60000

// Create client
const client = createClient(options)

// Execute command
// 1. return parsed data (recommend)
const response = await client.execute('GET SUBGRAPH 3 STEPS FROM -7897618527020261406')
// 2. return nebula original data
const responseOriginal = await client.execute('GET SUBGRAPH 3 STEPS FROM -7897618527020261406', true)

NebulaGraph is for you

Whether you are a DBA, architect, or data scientist

DevOps & DBA

  • Visualized graph database and cluster management tool
  • Effortless scale in and scale out
  • Enterprise-grade security
  • Automatic disaster recovery without downtime
  • Deploy in single machines or clusters


  • Integrations with popular languages and tools
  • No cloud vendor lock-in
  • Shared-nothing architecture
  • Low-latency read and write and high throughput
  • Open source under Apache 2.0.

Data scientist

  • Powerful data visualization and graph exploration tools
  • Deploy in your local computer
  • SQL-like query language
  • Visualized data import tools
  • Connect to GraphX and Flink using NebulaGraph Connector