Neo4j Graph Data Platform

The Fastest Path to Graph

Neo4j gives developers and data scientists the most trusted and advanced tools to quickly build today’s intelligent applications and machine learning workflows. Available as a fully managed cloud service or self-hosted.

Get started in less than 60 seconds
  • Connections: Knowledge Graphs
    Join Us!
    Connections: Knowledge Graphs
    Wednesday, July 28
  • Free Graph Algorithms Book
    O'Reilly
    Graph Algorithms
    Download your free copy with updated code
  • Free Graph Database for Dummies Book
    Just Released!
    Graph Databases for Dummies
    Learn the basics of graph databases – from data modeling to deploying your first application
  • Neo4j Funding Announcement
    Series F
    Neo4j Raises Largest Funding in Database History

The Data Platform for Today's Intelligent Applications

Powered by native graph technology, Neo4j stores and manages data in its more natural, connected state, maintaining data relationships that deliver lightning-fast queries, deeper context for analytics, and a pain-free modifiable data model.

The Graph Technology Leader

Uncompromised Performance, Reliability, and Integrity

The creator and leader of the graph database category, Neo4j continues to expand the limits of graph technology, helping empower the largest active community of 220,000 developers, data scientists, and architects who are working to solve the world's most complex and valuable data problems.

MACHINE LEARNING INNOVATION

Revealing Richer Context to Drive Deeper Insights

Analysts and data scientists can incorporate network structures to infer meaning, increase ML accuracy, and drive contextual AI – making better predictions with that data they already have.

Neo4j is fueled by our vast, production-ready algorithm library and advanced, groundbreaking machine learning workflows not found anywhere else.

Learn about Graph Data Science

Battle-tested for performance

The Most Trusted. The Most Secure. The Most Deployed.

Neo4j is the only enterprise-strength graph database that combines native graph storage, advanced security, scalable speed-optimized architecture, and ACID compliance to ensure predictability and integrity of relationship-based queries. That’s why it’s deployed by hundreds of Fortune 500 companies, government agencies, and NGOs.

handshake, nodes and database

Delivering Value for the World’s Largest Organizations

Customer Story

Graph Developers Helped NASA Get to Mars Ahead of Schedule

Locked in decades of NASA project data is knowledge – but accessing that information was challenging due to silos between departments and individual groups. NASA leveraged a Neo4j knowledge graph to create their Lessons Learned Database to collect, store, and share information.

The Lessons Learned Database has generated significant value for NASA. As David Meza, Chief Knowledge Architect at NASA put it: "This has saved us at least a year and over $2 million in research and development toward our Mission to Mars planning."

space with a mars rover
Customer Story

One-Stop Shop for Data

Becoming a household name for online accommodations brought Airbnb rapid growth, with 3,500 employees across 20 offices worldwide. With Neo4j, Airbnb was able to tie together their entire data ecosystem and make it searchable, relevant, and trustworthy for even the newest employee.

“Why did we choose Neo4j as our graph database? Our data represents a graph, so it felt logical to use a graph database as well to store the data. It’s nimble. We wanted a really fast, performant system. It’s popular. It’s the world’s number one graph database. And finally, it integrates really well,” said John Bodley, Software Engineer at Airbnb.

trunk illustration
Customer Story

Panama Papers Investigation Fueled by Graph Technology

The Panama Papers leak surfaced 11.5 million documents. It would have taken years to make connections across 40 years of confidential emails, spreadsheets, and corporate records in six languages. The ICIJ loaded all of this information into Neo4j, empowering investigations that have enabled governments around the world to recoup more than $1 billion in taxes and winning the ICIJ a Pulitzer Prize for Explanatory Reporting.

Reporters could simply type in an individual’s name and instantly reveal their web of connections. “The graph allowed you to explore these networks in a very, very easy way. My journalists were amazed. We felt like we had superpowers,” said Mar Cabra, Data Editor, ICIJ.

papers flying in the air
Customer Story

Lifting Data Scientist Productivity by 30 Percent

Data is at the heart of every decision at Lyft. But data scientists spent a third of their valuable time just trying to find the right data and understand it. Lyft engineers built Amundsen on Neo4j to connect data in thousands of tables across data stores, offering insights into lineage and who uses the data, which drives trust.

The Neo4j-based tool saw immediate uptake by 90 percent of data scientists. “Amundsen has been really successful at Lyft. We currently have engineers, product managers and even customer service folks using Amundsen to find what they need,” said Tamika Tannis, Software Engineer at Lyft.

road with a car
Customer Story

Creating a Chatbot That Gets You

eBay wanted a smart chatbot. But most chatbot frameworks are rules-based, unsuitable for billions of items. Using a Neo4j knowledge graph, eBay engineers built eBay for Google Assistant, which uses natural language understanding to infer context. eBay sees this exercise of tapping into human intent as the “holy grail” of conversational commerce.

Neo4j not only provided high resiliency and availability with millisecond response time, but also AI capabilities. “For us, technically, the graph is not just a database. For us, it’s a store that is used as a cache for a machine-learning knowledge graph,” said Ajinkya Kale, former Senior Staff Applied Researcher at eBay.

bike, speaker and guitar
Customer Story

Natural Language Processing at a Mind-Blowing Scale

Caterpillar has over 27 million documents tracking vehicle repairs and maintenance, including manuals and technicians’ documents that chronicle the complaint, problem analysis, and the solution for every repair. Caterpillar built a knowledge graph in Neo4j that pulls in all relevant text, enriches it, makes it voice searchable, and recommends next best actions.

To get from natural language to graph query results, the team created a data architecture that ingests text via a Python-based NLP toolkit. “The topic of natural language dialogue between people and machines is probably going to be analytics, and the mechanism to make that happen is natural language processing – a perfect fit with graph databases,” said Ryan Chandler, Senior Data Scientist, Caterpillar, Inc.

construction site with a big machinary

Zero-admin, always-on graph database

Launch Fast with Neo4j’s Fully Managed Cloud Service

Neo4j Aura is a fast, reliable, scalable, and completely automated Neo4j graph database, provided as a cloud service. Aura lets you to focus on your strengths – creating rich, data-driven applications – rather than spend time managing databases.

Learn more about Aura
Fully automated, with zero administration
On-demand scalability without restarting
Always-on, secure, durable, and reliable
Simple, consumption-based, predictable pricing
cloud and database

Cypher: The graph Query Language

No More Complex JOINs

Cypher is a powerful, intuitive, graph-optimized query language that understands, and takes advantage of, data connections. It’s user-friendly, easy to learn, and follows connections – in any direction – to reveal previously unknown relationships and clusters.

When trying to find patterns or insights within data, Cypher queries are much simpler and easier to write than massive SQL JOINs. Since Neo4j doesn’t have tables, there are no JOINs to worry about. Compare the Cypher query at the left with its equivalent in SQL.

Learn more about Cypher
Cypher 122 char
MATCH (p:Product)-[:CATEGORY]->(l:ProductCategory)-[:PARENT*0..]->(:ProductCategory {name:"Dairy Products"})
RETURN p.name
SQL 518 char
SELECT p.ProductName
FROM Product AS p
JOIN ProductCategory pc ON (p.CategoryID = pc.CategoryID AND pc.CategoryName = "Dairy Products")

JOIN ProductCategory pc1 ON (p.CategoryID = pc1.CategoryID)
JOIN ProductCategory pc2 ON (pc1.ParentID = pc2.CategoryID AND pc2.CategoryName = "Dairy Products")

JOIN ProductCategory pc3 ON (p.CategoryID = pc3.CategoryID)
JOIN ProductCategory pc4 ON (pc3.ParentID = pc4.CategoryID)
JOIN ProductCategory pc5 ON (pc4.ParentID = pc5.CategoryID AND pc5.CategoryName = "Dairy Products");

Use Your Favorite Programming Languages

We aim to make the Neo4j experience fast, natural, and fun for developers. Neo4j supports GraphQL and drivers for .Net, Java, Node.js, Python, and more. Our community of contributors provide many more drivers, including PHP, Ruby, R. Erlang, and Clojure.

Learn more about Drivers
// npm install --save neo4j-driver
// node example.js
const neo4j = require("neo4j-driver");
const driver = neo4j.driver("bolt://<HOST>:<BOLTPORT>", neo4j.auth.basic("<USERNAME>", "<PASSWORD>"), {
	/* encrypted: 'ENCRYPTION_OFF' */
});

const query = `
  MATCH (p:Product)-[:PART_OF]->(:Category)-[:PARENT*0..]->
  (:Category {categoryName:$category})
  RETURN p.productName as product
  `;

const params = { category: "Dairy Products" };

const session = driver.session({ database: "neo4j" });

session
	.run(query, params)
	.then((result) => {
		result.records.forEach((record) => {
			console.log(record.get("product"));
		});
		session.close();
		driver.close();
	})
	.catch((error) => {
		console.error(error);
	});
# pip3 install neo4j-driver
# python3 example.py

from neo4j import GraphDatabase, basic_auth

driver = GraphDatabase.driver(
  "bolt://<HOST>:<BOLTPORT>", 
  auth=basic_auth("<USERNAME>", "<PASSWORD>"))

cypher_query = '''
MATCH (p:Product)-[:PART_OF]->(:Category)-[:PARENT*0..]->
(:Category {categoryName:$category})
RETURN p.productName as product
'''

with driver.session(database="neo4j") as session:
  results = session.read_transaction(
    lambda tx: tx.run(cypher_query,
      category="Dairy Products").data())

  for record in results:
    print(record['product'])

driver.close()
// go mod init main
// go run example.go
package main
import (
	"fmt"
	"github.com/neo4j/neo4j-go-driver/neo4j" //Go 1.8
)
func main() {
	s, err := runQuery("bolt://<HOST>:<BOLTPORT>", "<USERNAME>", "<PASSWORD>")
	if err != nil {
		panic(err)
	}
	fmt.Println(s)
}
func runQuery(uri, username, password string) ([]string, error) {
	configForNeo4j4 := func(conf *neo4j.Config) { conf.Encrypted = false }
	driver, err := neo4j.NewDriver(uri, neo4j.BasicAuth(username, password, ""), configForNeo4j4)
	if err != nil {
		return nil, err
	}
	defer driver.Close()
	sessionConfig := neo4j.SessionConfig{AccessMode: neo4j.AccessModeRead, DatabaseName: "neo4j"}
	session, err := driver.NewSession(sessionConfig)
	if err != nil {
		return nil, err
	}
	defer session.Close()
	results, err := session.ReadTransaction(func(transaction neo4j.Transaction) (interface{}, error) {
		result, err := transaction.Run(
			`
			MATCH (p:Product)-[:PART_OF]->(:Category)-[:PARENT*0..]->
			(:Category {categoryName:$category})
			RETURN p.productName as product
			`, map[string]interface{}{
				"category": "Dairy Products",
			})
		if err != nil {
			return nil, err
		}
		var arr []string
		for result.Next() {
			value, found := result.Record().Get("product")
			if found {
			  arr = append(arr, value.(string))
			}
		}
		if err = result.Err(); err != nil {
			return nil, err
		}
		return arr, nil
	})
	if err != nil {
		return nil, err
	}
	return results.([]string), err
}
// Add your the driver dependency to your pom.xml build.gradle etc.
// Java Driver Dependency: http://search.maven.org/#artifactdetails|org.neo4j.driver|neo4j-java-driver|4.0.1|jar
// Reactive Streams http://search.maven.org/#artifactdetails|org.reactivestreams|reactive-streams|1.0.3|jar
// download jars into current directory
// java -cp "*" Example.java

import org.neo4j.driver.*;
import static org.neo4j.driver.Values.parameters;

public class Example {

  public static void main(String...args) {

    Driver driver = GraphDatabase.driver("bolt://<HOST>:<BOLTPORT>",
              AuthTokens.basic("<USERNAME>","<PASSWORD>"));

    try (Session session = driver.session(SessionConfig.forDatabase("neo4j"))) {

      String cypherQuery =
        "MATCH (p:Product)-[:PART_OF]->(:Category)-[:PARENT*0..]->" +
        "(:Category {categoryName:$category})" +
        "RETURN p.productName as product";

      var result = session.readTransaction(
        tx -> tx.run(cypherQuery, 
                parameters("category","Dairy Products"))
            .list());

      for (Record record : result) {
        System.out.println(record.get("product").asString());
      }
    }
    driver.close();
  }
}

Helpful Tools for Modern App & Web Development

Neo4j provides an array of tools, libraries, and frameworks to make development faster and easier. Developer tools like Neo4j Desktop, Browser, and Sandbox make it simple to learn and develop graph apps.

The new Neo4j GraphQL Library translates GraphQL queries into Cypher, making it easier for GraphQL users to use Neo4j. It also streamlines integration of Neo4j with React, Vue, and other open source frameworks.

Neo4j Desktop
For local database management
Download Desktop
GraphQL Library
For API driven modern applications
Learn More
Grandstack.io
To build apps with React, GraphQL and Apollo
Get Started
Ready to get started with Neo4j?

Get started while your coffee is still brewing

Get Started for Free

  • Launch free Neo4j sandboxes in less than 60 seconds
  • Pick from over 12 selected datasets with built-in guides to get you started quickly.