Debian-based distributions (.deb)

You can install Neo4j on Debian, and Debian-based distributions like Ubuntu, using the Neo4j Debian package.

Java prerequisites

Neo4j 2025.x requires the Java 21 runtime (default). Starting with Neo4j 2025.10, Java 25 is also supported.

OpenJDK Java 21

Most of the supported Linux distributions have OpenJDK Java 21 available by default. Consequently, no extra setup is required if you are using OpenJDK Java, the correct Java dependency will be installed by the package manager when installing Neo4j.

Oracle JDK, Zulu JDK, or Corretto JDK

If you wish to use a non-default JDK, it must be installed before starting the Neo4j installation. Otherwise, your package manager installs the default Java distribution for your operating system, usually OpenJDK.

Java download and installation instructions can be found on the manufacturer’s website:

Dealing with multiple installed Java versions

You must configure your default Java version to point to Java 21 or Java 25 (starting with Neo4j 2025.10), or Neo4j 2026.08.1 will be unable to start. Do so with the update-java-alternatives command.

List all your installed versions of Java with update-java-alternatives --list.

Your results may vary, but this is an example of the output:

java-1.25.0-openjdk-amd64 2511 /usr/lib/jvm/java-1.25.0-openjdk-amd64
java-1.21.0-openjdk-amd64 2111 /usr/lib/jvm/java-1.21.0-openjdk-amd64
java-1.17.0-openjdk-amd64 1711 /usr/lib/jvm/java-1.17.0-openjdk-amd64

Identify your Java 21 version (default) from the list of installed Javas. In this case, it is java-1.21.0-openjdk-amd64.
Set Java 21 as the default by replacing <java21name> with its name:
```
sudo update-java-alternatives --jre --set <java21name>
```
Confirm which version of Java is the default using java -version.

Installation

To install Neo4j using the Debian package manager apt, you need to add the Neo4j repository to your system’s list of package sources, and then install the desired Neo4j package. The Debian package is available from https://debian.neo4j.com.

Add the repository

Run the following commands as a sudo user to add the Neo4j repository to the package manager:

Create the keyrings directory for the Neo4j GPG key if it does not already exist:
```
sudo mkdir -p /etc/apt/keyrings
```

Download and install the Neo4j GPG key:

wget -O - https://debian.neo4j.com/neotechnology.gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/neotechnology.gpg > /dev/null

Ensure the key file is world-readable:

sudo chmod a+r /etc/apt/keyrings/neotechnology.gpg

Add the Neo4j APT repository:

echo 'deb [signed-by=/etc/apt/keyrings/neotechnology.gpg] https://debian.neo4j.com stable latest' | sudo tee -a /etc/apt/sources.list.d/neo4j.list > /dev/null

Update package lists:
```
sudo apt-get update
```

Once the repository has been added to apt, you can verify which Neo4j versions are available by running:

apt list -a neo4j

In Ubuntu server installations, you also need to make sure that the universe repository is enabled. If the universe repository is not present, the Neo4j installation will fail with the error Depends: daemon but it is not installable.

This can be fixed by running the command:

sudo add-apt-repository universe

Install Neo4j

To install Neo4j, run one of the following commands depending on which version you want to install. Note that the version includes an epoch version component (1:), following the Debian policy on versioning.

Neo4j Community Edition (CE):
```
sudo apt-get install neo4j=1:2026.08.1
```
Neo4j Enterprise Edition (EE):
```
sudo apt-get install neo4j-enterprise=1:2026.08.1
```
You will be prompted to accept either the commercial or the evaluation license agreement before the installation begins. Your answer to the license agreement prompt will be remembered for future installations on the same system.

To forget the stored answer, and trigger the license agreement prompt on subsequent installation, use debconf-communicate to purge the stored answer:
```
echo purge | sudo debconf-communicate neo4j-enterprise
```
If you require non-interactive installation of Neo4j Enterprise Edition, you can indicate that you have read and accepted the license agreement using debconf-set-selections:
```
echo "neo4j-enterprise neo4j/accept-license select Accept commercial license" | sudo debconf-set-selections
```

Offline installation

If you cannot reach https://debian.neo4j.com, perhaps due to a firewall, you need to obtain Neo4j via an alternative machine that has the relevant access, and then move the package manually.

It is important to note that using this method means that the offline machine will not receive the dependencies that are normally downloaded and installed automatically when using apt for installing Neo4j, Cypher Shell, and Java (if not installed already):

The Cypher Shell package can be downloaded from Neo4j Deployment Center.
For information on supported versions of Java, see System requirements.

Run the following to download the required Debian software package:
- Neo4j Community Edition:
  curl -O https://dist.neo4j.org/deb/neo4j_2026.08.1_all.deb
- Neo4j Enterprise Edition:
  curl -O https://dist.neo4j.org/deb/neo4j-enterprise_2026.08.1_all.deb
  To list all files that the Debian software package (.deb file) installs:
  
  dpkg --contents neo4j_2026.08.1_all.deb
Manually move the downloaded Debian package to the offline machine.
Run the following on the offline machine to install Neo4j:
```
sudo dpkg -i <deb file name>
```

File locations

File locations for all Neo4j packages are documented here.

Operation

Most Neo4j configuration goes into neo4j.conf.

For operating systems using systemd, some package-specific options are set in neo4j.service and can be edited using systemctl edit neo4j.service.

System V (SysV) init scripts, located in /etc/rc.d/init.d/ or /etc/init.d, are included with the Neo4j package installation. However, starting with Neo4j 2026.01, they are considered deprecated and will be removed in a future release.

For operating systems that are not using systemd, some package-specific options are set in /etc/default/neo4j.

Environment variable	Default value	Details
NEO4J_SHUTDOWN_TIMEOUT	120	Timeout in seconds when waiting for Neo4j to stop. If it takes longer than this then the shutdown is considered to have failed. This may need to be increased if the system serves long-running transactions.
NEO4J_ULIMIT_NOFILE	60000	Maximum number of file handles that can be opened by the Neo4j process.

Environment variable

Default value

Details

NEO4J_SHUTDOWN_TIMEOUT

120

Timeout in seconds when waiting for Neo4j to stop. If it takes longer than this then the shutdown is considered to have failed. This may need to be increased if the system serves long-running transactions.

NEO4J_ULIMIT_NOFILE

60000

Maximum number of file handles that can be opened by the Neo4j process.

Starting the service automatically on system start

On Debian-based distributions, run the following command to ensure that Neo4j starts automatically at boot time:

sudo 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.

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

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:

(Optional) Create a backup to avoid losing your data.
Uninstall Neo4j by running the following command:
```
sudo apt remove neo4j
```

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).