neo4j.com Open in urlscan Pro
2600:9000:225e:7c00:6:ae26:4c0:93a1  Public Scan

Form analysis
0 forms found in the DOM

Text Content

This website uses cookies

We use cookies to offer you a better browsing experience, analyze site traffic,
personalize content and serve targeted ads.  Learn about how we use cookies and
how you can control them in Cookie Settings. By using our site. you consent to
our use of cookies. 

Accept CookiesUse necessary cookies only

Menu
Close
 * Products
   * Platform Overview
   * Graph Database
     * Neo4j Graph Database
     * Neo4j AuraDB
   * Graph Data Science
     * Neo4j Graph Data Science
     * Neo4j AuraDS
   * User Tools
     * Neo4j Developer Tools
     * Cypher Query Language
     * Neo4j GraphQL Library
     * Neo4j Data Connectors
     * Neo4j Bloom
   * Download Center
   * Pricing
 * Solutions
   * Use Cases
   * Case Studies
   * Customers
   * Professional Services
 * Learn
   * Resources
     * Who Uses Neo4j?
     * Executive Insights
     * GraphAcademy
     * Neo4j Blog
     * Videos
     * Books
     * Resource Library
   * Events
     * GraphConnect
     * GraphSummit
     * Connections
     * Events Calendar
     * Live Demos
     * Webinars
 * Developers
   * Developer Home
   * Documentation
   * Download Center
   * Developer Blog
   * Community
   * Online Meetups
 * Data Scientists
   * Graph Data Science Home
   * Data Science Documentation
   * GraphAcademy for Data Science
   * Data Science Guides
   * Data Science Community
   * Get Started with Graph Data Science
 * Sign In
   * Neo4j Aura
   * Neo4j Sandbox
 * Get Started
   * Neo4j AuraDB
   * Neo4j Sandbox
   * Neo4j Desktop
   * Neo4j AuraDS


 * Partners
    * Find a Partner
    * Become a Partner
    * Solution Partners
    * OEM Partners
    * Technology Partners
    * Partner Portal Login

 * Company
    * About Us
    * Newsroom
    * Awards and Honors
    * Graphs4Good
    * Careers
    * Culture
    * Diversity
    * Leadership

 * Contact Us
 * Support
 * 

 * Products
   Platform Overview → Neo4j graph technology products help the world make sense
   of data.
   Graph Database Neo4j Graph Database Self-managed, deploy anywhere Neo4j
   AuraDB Fully managed graph database as a service
   Graph Data Science Neo4j Graph Data Science Graph analytics and modeling
   platform Neo4j AuraDS New! Fully managed graph data science as a service
   
   --------------------------------------------------------------------------------
   
   Download Center
   Graph Database • Graph Data Science
   Pricing
   Graph Database • Graph Data Science
   User Tools Neo4j Developer Tools Desktop, Browser, and Data Importer Cypher
   Query Language Powerful, intuitive, and graph-optimized Neo4j GraphQL Library
   Low-code, open source API library Neo4j Data Connectors Apache Kafka, Apache
   Spark, and BI tools Neo4j Bloom Easy graph visualization and exploration

 * Solutions
    * Use Cases Fraud detection, knowledge graphs and more
      
      Knowledge Graphs Knowledge graphs are the force multiplier of smart data
      management and analytics use cases. Learn More
      
      --------------------------------------------------------------------------------
      
      By Application
      Analytics and Data Science
      Fraud Detection
      Knowledge Graphs
      Real Time Recommendations
      Supply Chain Management
      Identity and Access Management
      Master Data Management
      Network and IT Operations
      Data Privacy, Risk and Compliance
      Social Networking
      By Industry
      Financial Services
      Retail
      Life Sciences
      Telecommunications
      Government
    * Case Studies In-depth looks at customer success stories
    * Customers Companies, governments and NGOs using Neo4j
    * Professional Services The world’s best graph database consultants

 * Learn
   Resources Who Uses Neo4j? 75 percent of Fortune 100 companies Executive
   Insights Get to Know Graph Technology GraphAcademy Free online courses and
   certifications Neo4j Blog Daily reads on general Neo4j topics Videos
   Up-to-date, searchable archive Books Learn in depth with free books Resource
   Library White papers, data sheets and more
   Events GraphConnect Live! June 6-8, Austin TX GraphSummit Live events in EMEA
   and APAC Connections Our marquee digital event series Events Calendar Live
   online events, trainings and demos Live Demos Weekly demos with Neo4j experts
   Webinars Upcoming live and on-demand webinars

 * Developers
    * Developer Home Best practices, how-to guides and tutorials
    * Documentation Manuals for Neo4j products, Cypher and drivers
    * Download Center Get Neo4j products, tools and integrations
    * Developer Blog Deep dives into more technical Neo4j topics
    * Community A global forum for online discussion
    * Online Meetups Global developer conferences and workshops

 * Data Scientists
    * Graph Data Science Home Learn what Neo4j offers for data science
    * Data Science Documentation Manual for the Graph Data Science library
    * GraphAcademy for Data Science Free online courses and certifications for
      data scientists
    * Data Science Guides Deep dives & how-tos on more technical topics
    * Data Science Community A global forum for online discussion
    * Get Started with Graph Data Science Download our software or get started
      in Sandbox today!

 * Sign In
    * Neo4j Aura Fully managed, cloud-native graph service
    * Neo4j Sandbox Learn graph databases and graph data science

 * Get Started
    * Neo4j AuraDB Start Free Start your fully managed Neo4j cloud database
    * Neo4j Sandbox Learn and use Neo4j for data science & more
    * Neo4j Desktop Manage multiple local or remote Neo4j projects
    * Neo4j AuraDS New! Fully managed graph data science, starting at $1/hour


WARNING: JAVASCRIPT IS DISABLED ON YOUR BROWSER. PARTS OF NEO4J.COM WILL NOT
WORK PROPERLY.

June 6 — June 8, 2022 | Austin, TX


CONNECT YOUR DATA.
BUILD THE FUTURE.

Register Today
   
 * 
 * 
 * 




BLAZING-FAST GRAPH. PETABYTE SCALE.

Start Free for Developers
Start Free for Data Scientists


THE GRAPH DATA PLATFORM FOR TODAY'S INTELLIGENT APPLICATIONS

Powered by a native graph database, 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.

Learn more about Performance


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 the 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.

See Our Customers


NEO4J AS A SERVICE


NEO4J AURA: THE FULLY
MANAGED CLOUD SERVICE

Neo4j Aura is a fast, scalable, always on and fully automated graph platform,
offered as a cloud service. Aura lets you focus on your core innovation rather
than spending time managing infrastructure.

Neo4j Aura includes AuraDB, the graph database as a service for developers
building intelligent applications and AuraDS, the graph data science as a
service for data scientists building predictive models and analytics workflows.

LEARN MORE

AuraDB AuraDS
Fully automated provisioning, upgrades and backups
Always-on, Secure, Reliable and ACID compliant
Scalable, on-demand without interruption
Simple Consumption-Based pricing


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

MATCH (p:Product)-[:CATEGORY]->(l:ProductCategory)-[:PARENT*0..]->(:ProductCategory {name:"Dairy Products"})
RETURN p.name

SQL

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
 * NodeJS
 * Python
 * Go
 * .NET
 * Java

// 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
}

// install dotnet core on your system
// dotnet new console -o .
// dotnet add package Neo4j.Driver
// paste in this code into Program.cs
// dotnet run

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using Neo4j.Driver;
  
namespace dotnet {
  class Example {
  static async Task Main() {
    var driver = GraphDatabase.Driver("bolt://<HOST>:<BOLTPORT>", 
                    AuthTokens.Basic("<USERNAME>", "<PASSWORD>"));

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

    var session = driver.AsyncSession(o => o.WithDatabase("neo4j"));
    var result = await session.ReadTransactionAsync(async tx => {
      var r = await tx.RunAsync(cypherQuery, 
              new { category="Dairy Products"});
      return await r.ToListAsync();
    });

    await session?.CloseAsync();
    foreach (var row in result)
      Console.WriteLine(row["product"].As<string>());
	  
    }
  }
}

// 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 FOR FREE WITH AURADB

Start Free on AuraDB
Products
 * Platform Overview
 * Neo4j Graph Database
 * Neo4j AuraDB
 * Neo4j Graph Data Science
 * Neo4j AuraDS
 * Download Center
 * Pricing

Learn
 * Resources
 * Events

Solutions
 * Use Cases
 * Case Studies
 * Customers
 * Partners
 * Professional Services

About
 * Company
 * Newsroom
 * Awards and Honors
 * Careers
 * Leadership
 * Support

Contact Us →
 * US: 1-855-636-4532
 * Sweden: +46 171 480 113
 * UK: +44 20 3868 3223
 * France: +33 (0) 1 73 23 56 07


© 2022 Neo4j, Inc.
Terms | Privacy | Sitemap
Neo4j®, Neo Technology®, Cypher®, Neo4j® Bloom™ and Neo4j® AuraDB™ are
registered trademarks of Neo4j, Inc. All other marks are owned by their
respective companies.