• Python 3.7 and above


Use the following command to install the Neo4j Python Driver using pip:

pip install neo4j

Code example

import logging

from neo4j import GraphDatabase
from neo4j.exceptions import Neo4jError

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(database="neo4j") 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
        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 Neo4jError 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(database="neo4j") 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__":
    # Aura queries use an encrypted connection using the "neo4j+s" URI scheme
    uri = "neo4j+s://<Bolt url for Neo4j Aura instance>"
    user = "<Username for Neo4j Aura instance>"
    password = "<Password for Neo4j Aura instance>"
    app = App(uri, user, password)
    app.create_friendship("Alice", "David")

Running the example

Follow the steps below to run the example code:

  1. Copy and paste the code above into a file named

  2. Enter the information for the AuraDB instance you want to connect to by replacing:

    • <Bolt url for Neo4j Aura instance> with the URI.

    • <Username for Neo4j Aura instance> with the username.

    • <Password for Neo4j Aura instance> with the password.

  3. Use the following command to run the example code:


Example walkthrough

The example imports GraphDatabase and basic_auth to connect to the Neo4j AuraDB instance and ServiceUnavailable for error handling.

The Main function calls the following two functions:

  • create_friendship creates two 'Person' nodes, Alice and David, and a 'KNOWS' relationship between them using a write transaction.

  • find_person finds Alice using a read transaction.

Developing with Neo4j Aura requires the use of Transaction Functions. Transaction Functions enable automatic recovery from transient network errors and enable load balancing.

Make sure to log queries and data sent from your application as it is useful when you encounter errors and can help with debugging.