Linux executable (.tar)

Before you install Neo4j on Linux from a tarball and run it as a console application or a service, check System Requirements to see if your setup is suitable. If it is not already installed, get OpenJDK 21, ZuluJDK 21, or Oracle Java 21. Starting with Neo4j 2025.10, Java 25 is also supported.

Install Neo4j from a tarball

Download the latest Neo4j tarball from Neo4j Deployment Center and unpack it:
```
tar zxf neo4j-enterprise-2026.08.1-unix.tar.gz
```

Move the extracted files to your server’s /opt directory and create a symlink to it:

mv neo4j-enterprise-2026.08.1 /opt/
ln -s /opt/neo4j-enterprise-2026.08.1 /opt/neo4j

Create a neo4j user and group:

groupadd neo4j
useradd -g neo4j neo4j -s /bin/bash

Give the directory the correct ownership using one of the options:

Ubuntu

chown -R neo4j:adm /opt/neo4j-enterprise-2026.08.1

RedHat

chown -R neo4j /opt/neo4j-enterprise-2026.08.1

(Recommended) Change the default locations of the data, conf, certificates, licenses, and plugins (if you plan to use custom plugins) directories by setting the environment variable NEO4J_CONF and the respective server.directories.* settings to point to the desired locations.

Storing your Neo4j files outside NEO4J_HOME will simplify the upgrade process later because you will be able to replace the DBMS binaries without affecting the configuration and state. Otherwise, these Neo4j files will remain in the old installation folder and may be accidentally overwritten during an upgrade or deleted during a subsequent uninstall.

Enterprise Edition Accept either the commercial or the evaluation license agreement. If you are using Community Edition, you can skip this step.
- Use one of the following options to accept the commercial license agreement. See the Neo4j licensing page for details on the available agreements.
  - Set the environment variable NEO4J_ACCEPT_LICENSE_AGREEMENT=yes.
  - Run <NEO4J_HOME>/bin/neo4j-admin server license --accept-commercial
- Use one of the following options to accept the Neo4j Evaluation Agreement for Neo4j Software.
  - Set the environment variable NEO4J_ACCEPT_LICENSE_AGREEMENT=eval.
  - Run <NEO4J_HOME>/bin/neo4j-admin server license --accept-evaluation.
Before starting up the database for the first time, it is recommended to use the set-initial-password command of neo4j-admin to define the password for the native user neo4j.

If the password is not set explicitly using this method, it will be set to the default password neo4j. In that case, you will be prompted to change the default password at first login.
For more information, see Set an initial password.
Start Neo4j:
- To run Neo4j as a console application, use: $NEO4J_HOME/bin/neo4j console.
- To run Neo4j in a background process, use: $NEO4J_HOME/bin/neo4j start.

Configure Neo4j to start automatically on system boot

You can create a Neo4j service and configure it to start automatically on system boot.

Create the file /lib/systemd/system/neo4j.service with the following contents:

[Unit]
Description=Neo4j Graph Database
After=network-online.target
Wants=network-online.target

[Service]
ExecStart=/opt/neo4j/bin/neo4j console
Restart=on-abnormal
User=neo4j
Group=neo4j
Environment="NEO4J_CONF=/opt/neo4j/conf" "NEO4J_HOME=/opt/neo4j"
LimitNOFILE=60000
TimeoutSec=120

[Install]
WantedBy=multi-user.target

Reload systemctl to pick up the new service file:
```
systemctl daemon-reload
```
Configure Neo4j to start at boot time:
```
systemctl enable neo4j
```
Before starting up the database for the first time, it is recommended to use the set-initial-password command of neo4j-admin to define the password for the native user neo4j.

If the password is not set explicitly using this method, it will be set to the default password neo4j. In that case, you will be prompted to change the default password at first login.
For more information, see Set an initial password.
Start Neo4j:
```
systemctl start neo4j
```
Check the status of the newly created service:
```
systemctl status neo4j
```
Reboot the system (if desired) to verify that Neo4j restarts on boot:
```
reboot
```

For more information on operating the Neo4j system service, see Neo4j system service.

Setting the number of open files

Linux platforms impose an upper limit on the number of concurrently open files per user and session. To check your limit for the current session, run the command ulimit -n. The default value is 1024.

ulimit -n

However, if you experience exceptions on Too many open files or Could not stat() directory, you have to increase the limit to 40000 or more, depending on your usage patterns. This is especially true when many indexes are used, or the server installation sees too many open network connections or sockets.

A quick solution is the command ulimit -n <the-new-limit>, but it will set a new limit only for the root user and will affect only the current session. If you want to set the value system-wide, follow the instructions for your platform.

The following steps set the open file descriptor limit to 60000 for the user neo4j under Ubuntu 16.04 LTS, Debian 8, CentOS 7, or later versions.

Running Neo4j as a service

Open the neo4j.service file with root privileges.
```
sudo systemctl edit neo4j.service
```
Append the following to the [Service] section, created in Configure Neo4j to start automatically on system boot:
```
[Service]
...
LimitNOFILE=60000
```

Running Neo4j as an interactive user (e.g., for testing purposes)

Open the user.conf file with root privileges in a text editor. This example uses Vim:
```
sudo vi /etc/systemd/user.conf
```
Uncomment and define the value of DefaultLimitNOFILE, found in the [Manager] section.
```
[Manager]
...
DefaultLimitNOFILE=60000
```
Open the /etc/security/limits.conf file.
```
sudo vi /etc/security/limits.conf
```

Define the following values:

neo4j	soft	nofile	60000
neo4j	hard	nofile	60000

Reload the systemd settings.
```
sudo systemctl daemon-reload
```
Reboot your machine.

Access Neo4j

By default, Neo4j Community Edition does not include graph tools such as visualization, data exploration, and monitoring. However, you can use the Neo4j Aura console to access these features for free. No subscription is required.

Sign up or log in to the Aura Console.
On the Instances page, click the Self-managed tab and then + Add deployment button.
Select URL Connection.
Provide a Name and Connection URL. If you have installed Neo4j locally on your system, you can connect either via bolt://localhost:7687, neo4j://localhost:7687, or using the secure https://localhost:7473.

For more information about the Neo4j ports, see Ports.
Click the Connect dropdown to launch various graph tools such as Query, Explore, and Dashboards.
Type the username neo4j and your password or the default password neo4j. You will be prompted to change the latter upon first login.

You are now connected and can use the Aura Console to run Cypher queries, visualize graphs, and optionally monitor your local Neo4j database in Neo4j Aura. For details, see Get started with Neo4j.

Alternatively, you can use the Neo4j Browser, a web-based user interface for interacting with Neo4j that is included with the Neo4j installation. To access the Neo4j Browser, open a web browser and navigate to http://localhost:7474. Connect using the username neo4j with your password or the default password neo4j. If the default password is used, you will be prompted to change it upon first login.

Uninstall Neo4j

Follow these steps to uninstall Neo4j on Linux:

(Optional) Create a backup to avoid losing your data.

Stop all Neo4j running services:

sudo systemctl stop neo4j
sudo systemctl disable neo4j

Delete NEO4J_HOME and the file /lib/systemd/system/neo4j.service:
```
rm /lib/systemd/system/neo4j.service
rm -rf NEO4J_HOME
```

Glossary

allocator: A component in the cluster that allocates databases to servers according to the topology constraints specified and an allocation strategy.
asynchronous replication: Asynchronous replication is used by secondary copies to poll for new transactions, which means they cannot be guaranteed to have received the most recent transactions. This enables efficient scale-out of read-performance.
Aura instance: A fully-managed DBMS represented by a single instance ID, that is running in the Neo4j Aura cloud.
auto-commit transaction: An automatically committed transaction that contains a single query.
Bolt protocol: Bolt is a protocol used for interaction between Neo4j instances and drivers.
bookmark: A marker the client can request from the cluster to ensure that it is able to read its own writes so that the application’s state is consistent and only databases that have a copy of the bookmark are permitted to respond.
category (Bloom): A category is based on a node label and is defined in a Perspective as a way of visually distinguishing nodes with the same label(s).
causal consistency: All servers in a cluster agree on the order in which transactions take place. The position of a server on the causal chain can be guaranteed using a bookmark.
cluster: A Neo4j DBMS that spans multiple servers working together to increase fault tolerance and/or read scalability. Databases on a cluster may be configured to replicate across servers in the cluster thus achieving read scalability or high availability.
client application: Software that interacts with a Neo4j server.
commit: A commit is the successful completion of a transaction, which ensures durability of any changes made. For more details, visit Operations Manual → Transaction management.
composite database: Composite databases are the means to access partitioned graph data with a single Cypher query.
constraint: Constraints are sets of data modeling rules that ensure the data is consistent and reliable.
Cypher®: Neo4j’s graph query language.
data model: A data model defines how information is organized in a database. A good data model will make querying and understanding your data easier. In Neo4j, the data models have a graph structure.
database: A database is a container used by the DBMS to manage and store graph data. The physical structure of data is controlled by the database.
database vs graph: Databases are the physical containers of graph data. Graphs are the logical structure of data in Neo4j.
Database Management System: Database Management System, or DBMS, capable of managing multiple databases. A DBMS may run on a single server, or span several servers configured as a cluster.
database schema: The prescribed property existence and datatypes for nodes and relationships.
deallocate: An act of removing a database from a server or a server from a cluster without loss of data or reduced fault tolerance.
degree (of a node): The number of relationships of a specific node; loops are counted twice.
disaster recovery: A manual intervention to restore availability of a cluster, or databases within a cluster.
driver: A software library that provides access to Neo4j from a particular programming language.
election: In the event that the Raft leader becomes unresponsive, followers automatically trigger an election and vote for a new leader.
entity: A node or a relationship.
expression (Cypher): A component of a Cypher query which produces values. It may be used in projections, as a predicate, or when setting properties on graph elements.
fabric: Fabric is the architectural design of a unified system that provides a single access point to local or distributed graph data.
fault tolerance: A guarantee that a cluster can maintain a database’s persistence and availability in the event of one or more servers failing.
follower: A primary copy of a database acting as a follower, receives and acknowledges synchronous writes from the leader.
Generative AI (GenAI): A type of artificial intelligence (AI) system that generates text, images, or other media in response to prompts.
graph: A logical representation of a set of nodes where some pairs are connected by relationships.
index: Data structure that improves read performance of a database.
knowledge graph: A specific type of graph that has an organizing principle so that a user (or a computer system) can reason about the underlying data. The organizing principle provides an additional layer of structure that adds context to support knowledge discovery.
label: Marks a node as a member of a named and indexed subset. A node may be assigned zero or more labels.
leader: A single primary copy of a database is designated as the leader. It receives all write transactions from clients and replicates writes synchronously to followers and asynchronously to secondary copies of the database.
main database: In terms of Neo4j Enterprise Studio, the database(s) containing the user’s data. Can exist in the same Neo4j deployment as the tool asset database.
motif: A description of a specific pattern within a graph.
node: A node represents an entity or discrete object in your graph data model. Nodes can be connected by relationships, hold data in properties, and are classified by labels.
operator: A symbol representing a mathematical or logical operation.
parameter: Named value provided when running a Cypher statement.
path: A sequence of nodes and the relationships connecting them, that does not contain duplicate relationships. Several paths can match a pattern.
pattern: A specific arrangement of nodes and relationships that can be matched in a graph. A pattern follows a motif.
perspective (Bloom): A Perspective defines a certain business view or domain that can be found in the target Neo4j graph. A single Neo4j graph can be viewed through different Perspectives, each tailored for a different business purpose.
primary: A copy of the database that is able to process write transactions and is eligible to be elected as a leader. It participates in fault tolerant writes as it is part of the majority required to acknowledge and commit write transactions.
primary vs secondary: In a cluster, databases can operate in either primary or secondary mode. Primary databases are able to process write and read transactions, ensuring fault tolerance. Secondary databases are replicated asynchronously from primaries, and their main purpose is to provide read scaling within the cluster.
project (Aura): An isolated environment in the unified Aura console that contains its own database instances, configurations, and resources. Preceded by tenant in the classic Aura console.
property: Properties are key-value pairs that are used for storing data on nodes and relationships.
query (Cypher): A statement that retrieves or writes information to a database.
Raft group: A group of servers that are participating in hosting a particular database in primary mode.
Raft group member: A server that is participating in a Raft group. A server can be a member of one or more groups.
Raft log: A shared log between all Raft group members that is guaranteed to be consistently updated and viewed by those members. The log contains both database data and operational state of the Raft group.
Raft protocol: The networking mechanism that enables a database to replicate its data across multiple servers to give high availability for accessing the data and high durability to the data stored.
read scaling: Distributing query load by creating additional database copies hosted in secondary mode (read-only).
relationship: A relationship represents a connection between nodes in your graph data model. Relationships connect a source node to a target node, hold data in properties, and are classified by type.
secondary: An asynchronously replicated copy of the database that provides read scaling within the cluster.
seed: A seed is a database dump or a full backup used to create a database on a cluster. This is sometimes called seeding.
server: A physical machine, a virtual machine, or a container running an instance of Neo4j. Servers can be standalone or part of a cluster.
session: A causally linked sequence of transactions.
session consistency: An alternative name for Neo4j’s causal consistency.
standalone: A single server running Neo4j and not part of a cluster.
synchronous replication: Synchronous replication requires the leader primary to replicate a transaction and block the commit until a quorum of the follower primaries acknowledges that the transaction is successfully replicated. Once the transaction is replicated, the commit is allowed to proceed. This ensures data durability and consistency within the cluster.
system database: A database used by Neo4j to store system information.
tenant (Aura): An isolated environment in the classic Aura console that contains its own database instances, configurations, and resources. Replaced by project in the unified Aura console.
tool asset database: In terms of Neo4j Enterprise Studio, the database where tools' assets are stored. This can be in the same Neo4j deployment as the main database(s) or in a separate deployment.
topology: A configuration that describes how the copies of a database should be spread across the servers in a cluster, see primary mode and secondary mode.
transaction: A transaction comprises a unit of work performed against a database. It is treated in a coherent and reliable way, independent of other transactions. Transactions comply with the ACID consistency model (atomic, consistent, isolated, and durable).