Neo4j Graph Database Fundamentals · Lesson

Performing CRUD Operations Programmatically

Execute Cypher queries from your application to create, read, update, and delete graph data dynamically.

Performing CRUD Operations Programmatically is a free Neo4j Graph Database Fundamentals lesson on CoddyKit — lesson 2 of 4. You can read the complete lesson below for free — then practise it hands-on in the browser with a built-in code editor and a 24/7 AI tutor. It is part of the Neo4j Graph Database Fundamentals learning path, one of 4 lessons in the course, and your progress syncs across the web and the CoddyKit app.

CRUD from Your Application

When building applications, you'll often need to interact with your Neo4j database programmatically. This means writing code that sends Cypher queries to create, read, update, and delete data.

These fundamental operations are often referred to as CRUD:

Create: Adding new data (nodes, relationships).
Read: Retrieving existing data.
Update: Modifying existing data.
Delete: Removing data.

Connecting to Neo4j (Review)

Before performing any CRUD operations, your application needs to connect to the Neo4j database. As we learned previously, the official Neo4j Python Driver simplifies this.

You'll use a GraphDatabase.driver object to manage connections and then create a session to execute queries.

from neo4j import GraphDatabase

URI = "bolt://localhost:7687"
AUTH = ("neo4j", "password") # Use your credentials

def main():
    driver = GraphDatabase.driver(URI, auth=AUTH)
    with driver.session() as session:
        # Your Cypher queries will go here
        print("Connected to Neo4j!")
    driver.close()

if __name__ == "__main__":
    main()

Creating New Nodes

To add new entities to your graph, you use the Cypher CREATE clause. Programmatically, you pass your Cypher query string and any parameters to the session.run() method.

Using parameters (like $name, $age) is crucial for security and prevents Cypher injection.

from neo4j import GraphDatabase

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

def main():
    driver = GraphDatabase.driver(URI, auth=AUTH)
    with driver.session() as session:
        query = (
            "CREATE (p:Person {name: $name, age: $age}) "
            "RETURN p.name AS name"
        )
        result = session.run(query, name="Charlie", age=25)
        print(f"Created: {result.single()['name']}")
    driver.close()

if __name__ == "__main__":
    main()

Creating Relationships

Relationships connect nodes and are essential for graph structures. To create a relationship, you first need to identify the nodes you want to connect, usually with MATCH, and then use CREATE.

The example connects 'Charlie' (created above) to 'Alice' (we'll ensure she exists for this demo).

from neo4j import GraphDatabase

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

def main():
    driver = GraphDatabase.driver(URI, auth=AUTH)
    with driver.session() as session:
        # Ensure Alice exists for the demo
        session.run("MERGE (:Person {name: 'Alice', age: 30})")

        query = (
            "MATCH (a:Person {name: $name1}), "
            "(b:Person {name: $name2}) "
            "CREATE (a)-[r:KNOWS]->(b) "
            "RETURN type(r) AS relType"
        )
        result = session.run(query, name1="Charlie", name2="Alice")
        print(f"Relationship created: {result.single()['relType']}")
    driver.close()

if __name__ == "__main__":
    main()

Reading Nodes (MATCH & RETURN)

Retrieving data is done using the MATCH clause to find patterns and RETURN to specify what data you want back. You can fetch entire nodes or specific properties.

The session.run() method returns a result object you can iterate over.

from neo4j import GraphDatabase

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

def main():
    driver = GraphDatabase.driver(URI, auth=AUTH)
    with driver.session() as session:
        query = "MATCH (p:Person) RETURN p.name AS name, p.age AS age"
        print("All People:")
        for record in session.run(query):
            print(f"- {record['name']} ({record['age']} years old)")
    driver.close()

if __name__ == "__main__":
    main()

Reading Connected Patterns

Graph databases excel at querying connected data. You can match complex patterns of nodes and relationships and retrieve specific parts of that pattern.

This example finds people who know 'Alice' and returns their names.

from neo4j import GraphDatabase

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

def main():
    driver = GraphDatabase.driver(URI, auth=AUTH)
    with driver.session() as session:
        query = (
            "MATCH (p:Person)-[:KNOWS]->(a:Person {name: $targetName}) "
            "RETURN p.name AS knowsAlice"
        )
        result = session.run(query, targetName="Alice")
        print("People who know Alice:")
        for record in result:
            print(f"- {record['knowsAlice']}")
    driver.close()

if __name__ == "__main__":
    main()

Updating Node Properties

To modify existing data, you use MATCH to find the node(s) or relationship(s) and then the SET clause to change their properties.

Here, we'll update 'Charlie's age to 26.

from neo4j import GraphDatabase

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

def main():
    driver = GraphDatabase.driver(URI, auth=AUTH)
    with driver.session() as session:
        query = (
            "MATCH (p:Person {name: $name}) "
            "SET p.age = $newAge "
            "RETURN p.name AS name, p.age AS newAge"
        )
        result = session.run(query, name="Charlie", newAge=26)
        record = result.single()
        print(f"Updated {record['name']}'s age to {record['newAge']}")
    driver.close()

if __name__ == "__main__":
    main()

Updating Relationship Properties

Just like nodes, relationships can also have properties. You can update these using MATCH to find the relationship and SET to modify its properties.

Let's add a since property to the KNOWS relationship between Charlie and Alice.

from neo4j import GraphDatabase

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

def main():
    driver = GraphDatabase.driver(URI, auth=AUTH)
    with driver.session() as session:
        query = (
            "MATCH (p1:Person {name: $name1})" 
            "-[r:KNOWS]->" 
            "(p2:Person {name: $name2}) "
            "SET r.since = $year "
            "RETURN p1.name, p2.name, r.since AS sinceYear"
        )
        result = session.run(query, name1="Charlie", name2="Alice", year=2022)
        record = result.single()
        print(f"{record['p1.name']} knows {record['p2.name']} since {record['sinceYear']}")
    driver.close()

if __name__ == "__main__":
    main()

Deleting Graph Data

To remove nodes and relationships, you use the DELETE clause. If a node has relationships, you must use DETACH DELETE to remove both the node and its relationships simultaneously.

Using just DELETE on a node with relationships will result in an error.

from neo4j import GraphDatabase

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

def main():
    driver = GraphDatabase.driver(URI, auth=AUTH)
    with driver.session() as session:
        query = (
            "MATCH (p:Person {name: $name}) "
            "DETACH DELETE p"
        )
        result = session.run(query, name="Charlie")
        print("Charlie and related data deleted.")
    driver.close()

if __name__ == "__main__":
    main()

Quick Check: CRUD Operations

You've learned how to perform all fundamental CRUD operations. Let's test your understanding.

Recap: Programmatic CRUD

Great job! In this lesson, you've learned how to perform essential CRUD operations on your Neo4j graph database directly from a Python application:

Create: Use CREATE to add nodes and relationships.
Read: Use MATCH and RETURN to retrieve data.
Update: Use MATCH and SET to modify properties.
Delete: Use MATCH and DETACH DELETE to remove data.

Mastering these operations is key to building dynamic and interactive graph applications.

Frequently asked questions

Is the “Performing CRUD Operations Programmatically” lesson free?

Yes — the full text of “Performing CRUD Operations Programmatically” is free to read here on the web, and the Neo4j Graph Database Fundamentals course includes 4 lessons in total. To practise it interactively (a built-in code editor and a 24/7 AI tutor) and unlock the rest of the Neo4j Graph Database Fundamentals course, upgrade to CoddyKit PRO.

What will I learn in “Performing CRUD Operations Programmatically”?

Execute Cypher queries from your application to create, read, update, and delete graph data dynamically. You practise Neo4j Graph Database Fundamentals with hands-on code you run directly in the browser, and a 24/7 AI tutor answers your questions as you work through the lesson.

Do I need any experience to start Neo4j Graph Database Fundamentals?

No prior experience is required. Neo4j Graph Database Fundamentals on CoddyKit is structured for beginners through advanced learners; this is — lesson 2 of 4, so you can start here or from the beginning and move at your own pace.

How long does the “Performing CRUD Operations Programmatically” lesson take?

Most CoddyKit lessons take about 5–10 minutes. Each one is bite-sized and interactive, so you make steady progress and pick up exactly where you left off across the web and the app.

Can I write and run code in this Neo4j Graph Database Fundamentals lesson?

Yes. Every Neo4j Graph Database Fundamentals lesson includes a built-in code editor, so you write and run real code right in your browser and get instant AI feedback — no local setup required.

All lessons in this course

Connecting with the Python Driver
Performing CRUD Operations Programmatically
Handling Transactions and Sessions
Connection Pooling and Error Handling

← Back to Neo4j Graph Database Fundamentals