Go Driver

Connect to Traverse from Go using the official Neo4j Bolt driver.

Install

go get github.com/neo4j/neo4j-go-driver/v6

Connect

package main

import (
    "context"
    "fmt"
    "github.com/neo4j/neo4j-go-driver/v6/neo4j"
)

func main() {
    ctx := context.Background()

    driver, err := neo4j.NewDriver(
        "bolt://localhost:7690",
        neo4j.NoAuth(),
    )
    if err != nil {
        panic(err)
    }
    defer driver.Close(ctx)

    // With authentication
    driver, _ = neo4j.NewDriver(
        "bolt://localhost:7690",
        neo4j.BasicAuth("admin", "s3cret", ""),
    )
}

Run Queries

result, err := neo4j.ExecuteQuery(ctx, driver,
    "MATCH (n:Person) WHERE n.age > $minAge RETURN n.name, n.age",
    map[string]any{"minAge": 25},
    neo4j.EagerResultTransformer,
)
if err != nil {
    panic(err)
}

for _, record := range result.Records {
    name, _ := record.Get("n.name")
    age, _ := record.Get("n.age")
    fmt.Println(name, age)
}

Select a Database

result, err := neo4j.ExecuteQuery(ctx, driver,
    "MATCH (n) RETURN count(n) AS count",
    nil,
    neo4j.EagerResultTransformer,
    neo4j.ExecuteQueryWithDatabase("mydb"),
)

Write Data

_, err := neo4j.ExecuteQuery(ctx, driver,
    "CREATE (p:Person {name: $name, age: $age})",
    map[string]any{"name": "Alice", "age": 30},
    neo4j.EagerResultTransformer,
)
if err != nil {
    panic(err)
}

Session-Based Queries

session := driver.NewSession(ctx, neo4j.SessionConfig{
    DatabaseName: "mydb",
})
defer session.Close(ctx)

result, err := session.Run(ctx,
    "MATCH (n:Person) RETURN n.name",
    nil,
)
if err != nil {
    panic(err)
}

for result.Next(ctx) {
    name, _ := result.Record().Get("n.name")
    fmt.Println(name)
}

Transactions

session := driver.NewSession(ctx, neo4j.SessionConfig{})
defer session.Close(ctx)

// Transaction function (recommended — auto-retries on transient errors)
_, err := session.ExecuteWrite(ctx,
    func(tx neo4j.ManagedTransaction) (any, error) {
        _, err := tx.Run(ctx,
            "CREATE (p:Person {name: $name, age: $age})",
            map[string]any{"name": "Dave", "age": 28},
        )
        return nil, err
    },
)

// Explicit transaction
tx, err := session.BeginTransaction(ctx)
if err != nil {
    panic(err)
}
tx.Run(ctx, "CREATE (p:Person {name: 'Bob'})", nil)
tx.Run(ctx, "CREATE (p:Person {name: 'Carol'})", nil)
tx.Commit(ctx)

Graph Types

result, _ := neo4j.ExecuteQuery(ctx, driver,
    "MATCH (n:Person)-[r:KNOWS]->(m) RETURN n, r, m LIMIT 1",
    nil, neo4j.EagerResultTransformer,
)
record := result.Records[0]

nodeVal, _ := record.Get("n")
node := nodeVal.(neo4j.Node)
fmt.Println(node.Labels)           // [Person]
fmt.Println(node.Props["name"])    // property access

relVal, _ := record.Get("r")
rel := relVal.(neo4j.Relationship)
fmt.Println(rel.Type)              // KNOWS

Close the Driver

driver.Close(ctx)