Quick wins for a faster PC:
Clear out junk files and repair common Windows errorsFree Scan →Fix the driver behind crashes, sound loss and screen glitchesFind Drivers →Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.
Neo4j Aura Graph Analytics is an on-demand, ephemeral compute service for Neo4j Graph Data Science (GDS). It runs graph algorithms and machine-learning workloads in isolated sessions rather than turning the analytics service itself into a permanent database. You project data into a session, run GDS, stream or write results, and then delete the session or let it expire.
That makes it a strong fit for bursty analytics, external data, and workloads that should not compete directly with a production AuraDB instance. It is not the same product as the AuraDB Graph Analytics plugin or persistent AuraDS.
What Neo4j Aura Graph Analytics does
Aura Graph Analytics separates graph-analytics compute from the database that stores operational data. The typical workflow is:
- Connect to AuraDB, self-managed Neo4j, or supported external data.
- Project the required nodes, relationships, and properties into an in-memory GDS graph.
- Run algorithms or train a graph machine-learning model.
- Stream results, mutate the in-memory graph, write results back, export data, or retain a trained model.
- Delete the session when finished.
Neo4j describes the service as on-demand and serverless-style, but it is not unlimited or configuration-free. You select memory, manage session lifetime, observe plan limits, and pay for usage outside eligible free tiers. See the official Aura Graph Analytics documentation.
#1 Best Overall
How the architecture works
AuraDB or another source
|
| remote projection or client loading
v
Aura Graph Analytics session
|
+-- GDS algorithms and graph ML
+-- in-memory graph catalog
+-- model catalog
|
+-- stream, write back, or exportThe projected graph is an in-memory analytical representation. It is not the same object as the source database graph. Isolated algorithm compute does not mean zero source impact: projection reads from the source, and write-back creates database activity.
Session types
| Session | Source | Best use |
|---|---|---|
| Attached | AuraDB | Run analytics against an Aura-hosted operational graph. |
| Self-managed | Self-managed Neo4j DBMS | Use Aura compute without installing and operating GDS locally. |
| Standalone | Non-Neo4j data | Load supported external data, including client-managed Pandas workflows. |
External sources still require a supported loading workflow. “Any data source” does not mean that Aura automatically connects to every warehouse or relational database without integration work.
Aura Graph Analytics vs. the alternatives
| Option | Compute model | Best fit | Main trade-off |
|---|---|---|---|
| AuraDB Graph Analytics plugin | Uses shared AuraDB resources | Light exploration | Analytics can compete with transactional workloads. |
| Aura Graph Analytics | Ephemeral, isolated sessions | Bursty or production analytics | Projection, session lifetime, and per-minute consumption must be managed. |
| AuraDS | Persistent managed analytics instance | Shared, continuous analytics and model-serving environments | Persistent instance billing can be inefficient for occasional jobs. |
| Self-managed GDS | Customer-operated infrastructure | Maximum control, private networking, or data-locality requirements | You manage infrastructure, upgrades, operations, and applicable licensing. |
Use the Aura deployment comparison for current product and plan details.
Do these 3 things before closing this tab:
1Scan for outdated or missing drivers - takes under a minute2Repair Windows errors before they cause bigger problems3Fix the driver behind crashes, sound loss and screen glitchesPlans, memory, and session lifetime
For AuraDB-attached use, the documented supported tiers are AuraDB Free, Pro Trial, Professional, Business Critical, and Virtual Dedicated Cloud. The source database must use Neo4j 5 or later.
Documented session memory choices are 2GB, 4GB, 8GB, 16GB, 24GB, 32GB, 48GB, 64GB, 96GB, 128GB, 192GB, 256GB, 384GB, and 512GB. Your organization administrator and plan determine which choices are available.
Rank #2
| AuraDB tier | Maximum documented session memory | Concurrent GDS sessions |
|---|---|---|
| Free | 2 GB | 1 |
| Pro Trial | 8 GB | 3 |
| Professional | Up to 128 GB | Up to 100 |
| Business Critical | Up to 128 GB | Up to 100 |
| VDC | Up to 512 GB | Up to 100 |
The default inactive-session TTL is one hour and the maximum configurable TTL is seven days. A session also has a seven-day maximum overall lifetime, even if it remains active. Free-tier sessions have a more restrictive 30-minute default and maximum TTL. Expired sessions are deleted automatically and do not continue consuming session time.
Interfaces
- Cypher API: Useful for attached AuraDB workflows and supported through the Aura Query tool in applicable configurations.
- Neo4j Graph Data Science Python client: Preferable for self-managed sources, external data, notebooks, automation, and export workflows.
- Neo4j Bloom: Can use Aura Graph Analytics when its AuraDB data source is configured accordingly.
Cypher availability is not universal. The documented AuraDB-attached Cypher API support is limited to Professional, Business Critical, and Virtual Dedicated Cloud configurations, with plan-specific limits. External client workflows require suitable Aura API credentials and connectivity. Client communication uses Apache Arrow Flight.
What’s actually slowing this PC down?
Pick the symptom - the matching free tool is one click away.
First workload with Cypher
The following example follows Neo4j’s documented quickstart. Run it against a suitable AuraDB source.
1. Create sample data
CREATE
(a:User {name: 'Alice', age: 23}),
(b:User {name: 'Bridget', age: 34}),
(c:User {name: 'Charles', age: 45}),
(d:User {name: 'Dana', age: 56}),
(e:User {name: 'Eve', age: 67}),
(f:User {name: 'Fawad', age: 78}),
(a)-[:LINK {weight: 0.5}]->(b),
(b)-[:LINK {weight: 0.2}]->(a),
(a)-[:LINK {weight: 4}]->(c),
(c)-[:LINK {weight: 2}]->(e),
(e)-[:LINK {weight: 1.1}]->(d),
(e)-[:LINK {weight: -2}]->(f);2. Project the graph remotely
CALL gds.graph.project(
'myGraph',
'*',
'*',
{
nodeProperties: ['age'],
relationshipProperties: ['weight'],
memory: '2GB',
ttl: toString(duration({minutes: 30}))
}
)
YIELD graphName, nodeCount, relationshipCount;The example should return a graph named myGraph with six nodes and six relationships. The memory setting is required in the documented remote-projection example; ttl is optional.
For real workloads, replace the wildcard projection with only the labels, relationship types, and properties required by the algorithms. Projection is a data-loading operation into the session’s graph catalog, not merely a query against AuraDB.
Rank #3
3. Inspect the graph
CALL gds.graph.list()
YIELD graphName, nodeCount, relationshipCount
RETURN graphName, nodeCount, relationshipCount;4. Run PageRank in mutate mode
CALL gds.pageRank.mutate(
'myGraph',
{mutateProperty: 'pageRank'}
)
YIELD ranIterations, nodePropertiesWritten
RETURN ranIterations, nodePropertiesWritten;mutate adds pageRank to the in-memory graph. It does not create a durable property in AuraDB.
5. Use the result in another algorithm
CALL gds.fastRP.mutate(
'myGraph',
{
featureProperties: ['pageRank'],
relationshipWeightProperty: 'weight',
iterationWeights: [1, 1, 1]
}
)
YIELD nodePropertiesWritten;This works because the projection included the weight relationship property and PageRank created the pageRank node property. Algorithm configuration must match the projected graph.
6. Stream, mutate, or write results
GDS modes have different outcomes:
streamreturns results to the client.mutatechanges the session-local in-memory graph.writepersists supported results to the source database.- Export can create a separate analytical Neo4j database through supported Python-client functionality.
Write procedures vary by algorithm and GDS version, so check the current procedure signature for the algorithm you are using before adding a production write-back step. Delete the session explicitly through the console or the interface used to create it when the job finishes.
What remains after a session ends?
| Item | Durability |
|---|---|
| Source database graph | Durable according to the source database. |
| Projected GDS graph | Session-local and lost when the session is deleted or expires. |
| Mutated algorithm property | Session-local until written elsewhere. |
| Written result | Stored in the source database where supported. |
| Trained model | Can be stored in the model catalog for reuse within its permitted scope. |
| Exported database | Separate output created through supported export workflows. |
Models are scoped to the user and Aura project and associated with the cloud provider and region where they are stored. They cannot be freely accessed across regions or cloud providers. Graph export to a new Neo4j database is documented for the Python client, not currently as a Cypher procedure or function.
Pricing and sizing
Aura Graph Analytics uses pay-as-you-go billing per session minute, with a documented minimum billed duration of 10 minutes. The Free and Pro Trial tiers are shown as not billed for Aura Graph Analytics, subject to their limits.
Rank #4
A practical cost model is:
analytics cost ≈ session runtime × rate for the selected session sizeDo not confuse this with the cost of the source AuraDB instance. Neo4j’s pricing page lists AuraDB Professional from $65 per GB per month in the displayed configuration, but that is a database price, not an Aura Graph Analytics session rate. The applicable analytics rate can depend on session size, cloud, region, plan, contract, and billing arrangement. Check Neo4j pricing, Aura billing, and payment options.
Start with the smallest session that comfortably fits the projected graph. Source database size alone does not predict GDS memory requirements: projected properties, relationship structure, algorithm overhead, and graph representation all matter.
Independent reader supportYour contribution helps us test, update, and keep practical guides available for everyone.Common failure modes
Projection runs out of memory
Project fewer labels, relationship types, and properties; increase session memory within the organization limit; or split the workload into meaningful subgraphs. If repeated large projections are normal, compare AuraDS or self-managed GDS.
Results seem to disappear
You probably used mutate. Stream the results or use the algorithm’s supported write mode to persist them.
The session expires mid-workflow
Set a suitable TTL, break long pipelines into stages, persist intermediate results or models, and build automation that detects expiration, recreates the session, and reprojects the graph. No session can exceed the seven-day hard lifetime.
Production performance is affected
Projection and write-back still use the source database. Schedule heavy operations outside peak periods, write only required properties, monitor the source, and avoid projecting from a cluster leader where Neo4j advises against it.
The Cypher API is unavailable
Check the AuraDB tier, session type, Neo4j version, organization limits, and current interface documentation. Use the Python client where it is the better-supported path.
External data will not connect
Check Aura API credentials, network and firewall rules, Arrow Flight/client configuration, and whether the chosen data-loading workflow is supported.
The Tool Desk
Outbyte PC Repair FREEClear out junk files and repair common Windows errorsFree Scan →Outbyte Driver Updater FREEScan for outdated or missing drivers - takes under a minuteDriver Scan →Production checklist
- Choose the session type based on the actual source.
- Project only required labels, relationships, and properties.
- Estimate graph memory rather than using source database size as a proxy.
- Set a deliberate TTL and delete sessions after successful jobs.
- Separate projection time from algorithm time when measuring workloads.
- Monitor source-database load during projection and write-back.
- Persist important results instead of relying on session-local mutation.
- Keep model training and reuse within the same user, project, cloud, and region scope.
- Account for the 10-minute billing minimum and concurrent-session limits.
- Build retry logic that can recreate an expired session and reproject data.
Who should use Aura Graph Analytics?
Choose it for intermittent or bursty GDS workloads, isolated analytics against AuraDB, self-managed Neo4j sources, external-data experiments, and teams that want managed GDS capabilities without installing GDS or managing its infrastructure.
Choose the AuraDB plugin for lightweight exploration where shared database resources are acceptable. Choose AuraDS when the analytics environment must remain available for a team, repeated experiments, or persistent model-serving work. Choose self-managed GDS when infrastructure control, private networking, data residency, or predictable dedicated capacity outweighs the operational convenience of Aura.
For most organizations, the decision is simple: small exploration means the plugin; bursty isolated analytics means Aura Graph Analytics; persistent shared analytics means AuraDS; maximum control means self-managed GDS.
Quick Recap
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
Recommended Free Tools
