Get started
About the official drivers
Neo4j provides official drivers for a number of popular programming languages. These drivers are supported by Neo4j.
Community drivers also exist for many languages, but vary greatly in terms of feature sets, maturity, and support. To find out more about community drivers, visit https://neo4j.com/developer/language-guides/.
The following languages and frameworks are officially supported by Neo4j:
Language/framework | Versions supported |
---|---|
.NET |
|
Go |
Go 1.10 |
Java |
Java 8+ (latest patch releases). |
JavaScript |
All LTS versions of Node.JS, specifically the 4.x and 6.x series runtimes (https://github.com/nodejs/LTS). |
Python |
CPython 3.5 and above. Note that Python 2 support has been deprecated and was discontinued in the 4.x series drivers. |
The driver API is intended to be topologically agnostic. This means that the underlying database topology — single instance, Causal Cluster, etc. — can be altered without requiring a corresponding alteration to application code. In the general case, only the connection URI needs to be modified when changes are made to the topology.
The official drivers do not support HTTP communication. If you need an HTTP driver, choose one of the community drivers. See also the HTTP API documentation. |
Driver versions and installation
Starting with Neo4j 4.0, the versioning scheme for the database, driver and protocol have all been aligned. This simplifies general compatibility concerns.
Cross-version compatibility is still available, and minimum support for current and previous versions between both server and driver is guaranteed. More specifically, this means that Neo4j 4.0 is guaranteed to be compatible with both 4.0 Drivers and 1.7 Drivers, and the 4.0 Drivers are guaranteed to be compatible with both Neo4j 4.0 and Neo4j 3.5. In cases where at least one peer is below version 4.0, communication will occur in fallback mode, limiting functionality to that available in the lowest-versioned component.
Drivers 1.7 do not support multiple databases and Neo4j Fabric, features introduced in Neo4j 4.0. To be able to run multiple databases online concurrently and to do distributed queries over them, you must upgrade Drivers from 1.7 to 4.0. For information, see For information, see Upgrade and Migration Guide → Drivers changes. |
Wherever possible, it is recommended to use the latest stable driver release available. This will provide the greatest degree of stability and will ensure that the full set of server functionality is available. The drivers, when used with Neo4j Enterprise Edition, come with full cluster routing support. The drivers make no explicit distinction between Enterprise Edition and Community Edition however, and simply operate with the functionality made available by Neo4j itself.
To install a driver or to find out more about which driver versions are available, use the relevant language distribution system, described below.
The .NET driver is distributed via the NuGet Gallery. To find out the latest version of the driver, visit https://www.nuget.org/packages/Neo4j.Driver/.
Dependencies
-
.NETStandard (^2.0)
-
System.Net.NameResolution (^4.3.0)
-
System.Net.Security (^4.3.2)
-
System.Net.Sockets (^4.3.0)
-
System.Runtime.InteropServices.RuntimeInformation (^ 4.3.0)
-
System.Runtime.Serialization.Primitives (^4.3.0)
-
System.Threading.Thread (^4.3.0)
-
System.ValueTuple (^4.5.0)
The .NET Reactive API is under package Neo4j.Driver.Reactive
.
It is built upon System.Reactive
.
There is no extra dependency required use .NET reactive API.
To install the latest version of the driver using NuGet in Visual Studio:
PM> Install-Package Neo4j.Driver
It is also an option to install a certain version of the driver.
PM> Install-Package Neo4j.Driver -Version $DOTNET_DRIVER_VERSION
The .Net driver uses asynchronous methods by default.
If you want to use blocking calls, the Neo4j.Driver.Simple
NuGet package contains a set of extensions.
This can be found at https://www.nuget.org/packages/Neo4j.Driver.Simple/.
The initial examples make use of these extensions.
In the following example we are installing driver version 4.0.1.
PM> Install-Package Neo4j.Driver -Version 4.0.1
The release notes for this driver are available here.
To find out the latest version of the driver, visit https://github.com/neo4j/neo4j-go-driver/releases
To install the latest version of the driver using go get
:
go get github.com/neo4j/neo4j-go-driver/v4@<latest tag>
Note that this requires that Go modules are enabled.
To use the Java driver, it is recommended employing a dependency manager, such as Maven or Gradle. To find out the latest version of the driver, visit the Maven Central Repository.
Dependencies
-
org.reactivestreams:reactive-streams
-
org.apache.logging.log4j:log4j (optional)
The driver is dependent on the Reactive Streams API, thus maintaining JDK 8 compatibility. To make optimal use of the reactive APIs, we suggest an additional framework like Project Reactor or RxJava2. Both implement the Reactive Streams API and provide an exhaustive set of operators.
When using Maven, add the following block to the pom.xml file. The driver version can either be declared as a property (as in the first example) or as an explicit version number (as in the second).
<dependencies>
<dependency>
<groupId>org.neo4j.driver</groupId>
<artifactId>neo4j-java-driver</artifactId>
<version>$JAVA_DRIVER_VERSION</version>
</dependency>
</dependencies>
In the following example, driver version 4.0.4 is added.
<dependencies>
<dependency>
<groupId>org.neo4j.driver</groupId>
<artifactId>neo4j-java-driver</artifactId>
<version>4.0.0</version>
</dependency>
</dependencies>
For Gradle, a compile line will be required. Again, this can use a property or an explicit version number.
compile 'org.neo4j.driver:neo4j-java-driver:$JAVA_DRIVER_VERSION'
In the following example, a driver version 4.0.4 is added.
compile 'org.neo4j.driver:neo4j-java-driver:4.0.4'
The release notes for this driver are available here.
To use the JavaScript driver, it is recommended employing npm
.
To find out the latest version of the driver, use:
npm show neo4j-driver@* version
Dependencies
-
Babel/Runtime (^7.5.5)
-
RxJS (^6.5.2)
-
text-encoding-utf-8 (^1.0.2)
-
URI-js (^4.2.2)
The JavaScript Reactive API is built and exposed via RxJs. A dependency of RxJs is automatically installed with the driver.
To install the latest version of the driver:
npm install neo4j-driver
It is also an option to install a certain version of the driver.
npm install neo4j-driver@$JAVASCRIPT-DRIVER-VERSION
In the following example, driver version 4.0.2 is installed.
npm install neo4j-driver@4.0.2
The release notes for this driver are available here.
To find out the latest stable version of the Python Driver, visit https://pypi.org/project/neo4j/
To find a list of all available releases, visit https://pypi.org/simple/neo4j/
To install the latest stable version of the Python Driver:
pip install neo4j
It is also an option to install a certain version of the driver.
The following is the syntax for installing a certain version of the Python Driver:
pip install neo4j==$PYTHON_DRIVER_VERSION
In the following example we are installing Python Driver version 4.0.
pip install neo4j==4.0
In the following example we get the latest version, including alphas:
pip install neo4j>=4.0.0a
In the following example we get the latest version, including betas:
pip install neo4j>=4.0.0b
In the following example we get the latest version, including release candidates:
pip install neo4j>=4.0.0rc
The release notes for the Python Driver are available here
NOTE: The pypi project name have changed from neo4j-driver to neo4j, the old project will coexist with the new.
A "Hello World" example
The example below shows the minimal configuration necessary to interact with Neo4j through a driver.
public class HelloWorldExample : IDisposable
{
private readonly IDriver _driver;
public HelloWorldExample(string uri, string user, string password)
{
_driver = GraphDatabase.Driver(uri, AuthTokens.Basic(user, password));
}
public void PrintGreeting(string message)
{
using (var session = _driver.Session())
{
var greeting = session.WriteTransaction(tx =>
{
var result = tx.Run("CREATE (a:Greeting) " +
"SET a.message = $message " +
"RETURN a.message + ', from node ' + id(a)",
new {message});
return result.Single()[0].As<string>();
});
Console.WriteLine(greeting);
}
}
public void Dispose()
{
_driver?.Dispose();
}
public static void Main()
{
using (var greeter = new HelloWorldExample("bolt://localhost:7687", "neo4j", "password"))
{
greeter.PrintGreeting("hello, world");
}
}
}
func helloWorld(uri, username, password string) (string, error) {
driver, err := neo4j.NewDriver(uri, neo4j.BasicAuth(username, password, ""))
if err != nil {
return "", err
}
defer driver.Close()
session := driver.NewSession(neo4j.SessionConfig{AccessMode: neo4j.AccessModeWrite})
defer session.Close()
greeting, err := session.WriteTransaction(func(transaction neo4j.Transaction) (interface{}, error) {
result, err := transaction.Run(
"CREATE (a:Greeting) SET a.message = $message RETURN a.message + ', from node ' + id(a)",
map[string]interface{}{"message": "hello, world"})
if err != nil {
return nil, err
}
if result.Next() {
return result.Record().Values[0], nil
}
return nil, result.Err()
})
if err != nil {
return "", err
}
return greeting.(string), nil
}
import org.neo4j.driver.AuthTokens;
import org.neo4j.driver.Driver;
import org.neo4j.driver.GraphDatabase;
import org.neo4j.driver.Session;
import org.neo4j.driver.Result;
import org.neo4j.driver.Transaction;
import org.neo4j.driver.TransactionWork;
import static org.neo4j.driver.Values.parameters;
public class HelloWorldExample implements AutoCloseable
{
private final Driver driver;
public HelloWorldExample( String uri, String user, String password )
{
driver = GraphDatabase.driver( uri, AuthTokens.basic( user, password ) );
}
@Override
public void close() throws Exception
{
driver.close();
}
public void printGreeting( final String message )
{
try ( Session session = driver.session() )
{
String greeting = session.writeTransaction( new TransactionWork<String>()
{
@Override
public String execute( Transaction tx )
{
Result result = tx.run( "CREATE (a:Greeting) " +
"SET a.message = $message " +
"RETURN a.message + ', from node ' + id(a)",
parameters( "message", message ) );
return result.single().get( 0 ).asString();
}
} );
System.out.println( greeting );
}
}
public static void main( String... args ) throws Exception
{
try ( HelloWorldExample greeter = new HelloWorldExample( "bolt://localhost:7687", "neo4j", "password" ) )
{
greeter.printGreeting( "hello, world" );
}
}
}
const driver = neo4j.driver(uri, neo4j.auth.basic(user, password))
const session = driver.session()
try {
const result = await session.writeTransaction(tx =>
tx.run(
'CREATE (a:Greeting) SET a.message = $message RETURN a.message + ", from node " + id(a)',
{ message: 'hello, world' }
)
)
const singleRecord = result.records[0]
const greeting = singleRecord.get(0)
console.log(greeting)
} finally {
await session.close()
}
// on application exit:
await driver.close()
from neo4j import GraphDatabase
class HelloWorldExample:
def __init__(self, uri, user, password):
self.driver = GraphDatabase.driver(uri, auth=(user, password))
def close(self):
self.driver.close()
def print_greeting(self, message):
with self.driver.session() as session:
greeting = session.write_transaction(self._create_and_return_greeting, message)
print(greeting)
@staticmethod
def _create_and_return_greeting(tx, message):
result = tx.run("CREATE (a:Greeting) "
"SET a.message = $message "
"RETURN a.message + ', from node ' + id(a)", message=message)
return result.single()[0]
if __name__ == "__main__":
greeter = HelloWorldExample("bolt://localhost:7687", "neo4j", "password")
greeter.print_greeting("hello, world")
greeter.close()