Neo4j Python Driver 5.9

The Official Neo4j Driver for Python.

Neo4j versions supported:

  • Neo4j 5.0 - 5.9

  • Neo4j 4.4

Python versions supported:

  • Python 3.11 (added in driver version 5.3.0)

  • Python 3.10

  • Python 3.9

  • Python 3.8

  • Python 3.7



To install the latest stable release, use:

python -m pip install neo4j

To install the latest pre-release, use:

python -m pip install --pre neo4j


It is always recommended to install python packages for user space in a virtual environment.

Virtual Environment

To create a virtual environment named sandbox, use:

python -m venv sandbox

To activate the virtual environment named sandbox, use:

source sandbox/bin/activate

To deactivate the current active virtual environment, use:


Quick Example

Creating nodes and relationships.

from neo4j import GraphDatabase

URI = "neo4j://localhost:7687"
AUTH = ("neo4j", "password")

def create_person(tx, name):"CREATE (a:Person {name: $name})", name=name)

def create_friend_of(tx, name, friend):"MATCH (a:Person) WHERE = $name "
           "CREATE (a)-[:KNOWS]->(:Person {name: $friend})",
           name=name, friend=friend)

with GraphDatabase.driver(URI, auth=AUTH) as driver:
    with driver.session() as session:
        session.execute_write(create_person, "Alice")
        session.execute_write(create_friend_of, "Alice", "Bob")
        session.execute_write(create_friend_of, "Alice", "Carl")

Finding nodes.

from neo4j import GraphDatabase

URI = "neo4j://localhost:7687"
AUTH = ("neo4j", "password")

def get_friends_of(tx, name):
    friends = []
    result ="MATCH (a:Person)-[:KNOWS]->(f) "
                    "WHERE = $name "
                    "RETURN AS friend", name=name)
    for record in result:
    return friends

with GraphDatabase.driver(URI, auth=AUTH) as driver:
    with driver.session() as session:
        friends = session.execute_read(get_friends_of, "Alice")
        for friend in friends:

Example Application

import logging
from neo4j import GraphDatabase
from neo4j.exceptions import ServiceUnavailable

class App:

    def __init__(self, uri, user, password):
        self.driver = GraphDatabase.driver(uri, auth=(user, password))

    def close(self):
        # Don't forget to close the driver connection when you are finished with it

    def create_friendship(self, person1_name, person2_name):
        with self.driver.session() as session:
            # Write transactions allow the driver to handle retries and transient errors
            result = session.execute_write(
                self._create_and_return_friendship, person1_name, person2_name)
            for record in result:
                print("Created friendship between: {p1}, {p2}".format(
                    p1=record['p1'], p2=record['p2']))

    def _create_and_return_friendship(tx, person1_name, person2_name):

        # To learn more about the Cypher syntax,
        # see

        # The Reference Card is also a good resource for keywords,
        # see

        query = (
            "CREATE (p1:Person { name: $person1_name }) "
            "CREATE (p2:Person { name: $person2_name }) "
            "CREATE (p1)-[:KNOWS]->(p2) "
            "RETURN p1, p2"
        result =, person1_name=person1_name, person2_name=person2_name)
            return [{"p1": record["p1"]["name"], "p2": record["p2"]["name"]}
                    for record in result]
        # Capture any errors along with the query and data for traceability
        except ServiceUnavailable as exception:
            logging.error("{query} raised an error: \n {exception}".format(
                query=query, exception=exception))

    def find_person(self, person_name):
        with self.driver.session() as session:
            result = session.execute_read(self._find_and_return_person, person_name)
            for record in result:
                print("Found person: {record}".format(record=record))

    def _find_and_return_person(tx, person_name):
        query = (
            "MATCH (p:Person) "
            "WHERE = $person_name "
            "RETURN AS name"
        result =, person_name=person_name)
        return [record["name"] for record in result]

if __name__ == "__main__":
    # See for Aura specific connection URL.
    scheme = "neo4j"  # Connecting to Aura, use the "neo4j+s" URI scheme
    host_name = ""
    port = 7687
    url = f"{scheme}://{host_name}:{port}"
    user = "<Username for Neo4j database>"
    password = "<Password for Neo4j database>"
    app = App(url, user, password)
        app.create_friendship("Alice", "David")

Other Information