Full import

Syntax

The syntax for importing a set of CSV files is:

neo4j-admin database import full [-h] [--expand-commands] [--verbose] [--auto-skip-subsequent-headers[=true|false]]
                                 [--compress[=true|false]] [--dry-run[=true|false]] [--ignore-empty-strings
                                 [=true|false]] [--ignore-extra-columns[=true|false]] [--legacy-style-quoting
                                 [=true|false]] [--normalize-types[=true|false]] [--overwrite-destination[=true|false]]
                                 [--profile[=true|false]] [--skip-bad-entries-logging[=true|false]]
                                 [--skip-bad-relationships[=true|false]] [--skip-duplicate-nodes[=true|false]] [--strict
                                 [=true|false]] [--trim-strings[=true|false]] [--additional-config=<file>]
                                 [--array-delimiter=<char>] [--bad-tolerance=<num>] [--delimiter=<char>]
                                 [--format=<format>] [--high-parallel-io=on|off|auto] [--id-type=string|integer|actual]
                                 [--input-encoding=<character-set>] [--input-type=csv|parquet]
                                 [--max-off-heap-memory=<size>] [--path-pattern-style=regex|glob|none]
                                 [--profile-results-path=<path>] [--property-shard-count=<propertyShardCount>]
                                 [--quote=<char>] [--read-buffer-size=<size>] [--report-file=<path>] [--schema=<path>]
                                 [--target-format=<format>] [--target-location=<path>] [--temp-path=<path>]
                                 [--threads=<num>] [--vector-delimiter=<char>] [--nodes=[<label>[:<label>]...=]
                                 <files>...]... [--relationships=[<type>=]<files>...]...
                                 [--multiline-fields=true|false|<path>[,<path>] [--multiline-fields-format=v1|v2]]
                                 <database>

Description

High-speed initial import of fault-free data from CSV files into a non-existent or empty database.

Parameters

Table 1. neo4j-admin database import full parameters
Parameter Description Default

<database>

Name of the database to import. If the database into which you import does not exist prior to importing, you must create it subsequently using CREATE DATABASE.

neo4j

Some of the options below are marked as Advanced. These options should not be used for experimentation.
For more information, contact Neo4j Professional Services.

Options

neo4j-admin import also supports the Parquet file format. You can use the parameter --input-type=csv|parquet to explicitly specify whether to use CSV or Parquet for the importer. If not defined, it defaults to CSV. The examples for CSV can also be used with Parquet.

Table 2. neo4j-admin database import full options
Option Description Default CSV Parquet

--additional-config=<file>[1]

Configuration file with additional configuration.

--array-delimiter=<char>

Delimiter character between array elements within a value in CSV data. Also accepts TAB and e.g. U+20AC for specifying a character using Unicode. For CSV data, this value must be different from the one specified in the --delimiter option. For Parquet data, this is only needed if the array is encoded as a string.

  • ASCII character — e.g. --array-delimiter=";".

  • \ID — Unicode character with ID, e.g. --array-delimiter="\59".

  • U+XXXX — Unicode character specified with 4 HEX characters, e.g. --array-delimiter="U+20AC".

  • \t — horizontal tabulation (HT), e.g. --array-delimiter="\t".

For horizontal tabulation (HT), use \t or the Unicode character ID \9.

Unicode character ID can be used if prepended by \.

;

--auto-skip-subsequent-headers[=true|false]

Automatically skip accidental header lines in subsequent files in file groups with more than one file.

false

--bad-tolerance=<num>

Number of bad entries before the import is aborted. The import process is optimized for error-free data. Therefore, cleaning the data before importing it is highly recommended. If you encounter any bad entries during the import process, you can set the number of bad entries to a specific value that suits your needs. However, setting a high value may affect the performance of the tool.

-1 Changed in 2025.12

--compress[=true|false][2]

Introduced in 2026.04 Request backup artifact to be compressed. Compression can yield a backup artefact many times smaller, but the exact reduction depends upon many factors, including the database format and the kind of data stored. If disabled, the size of the produced artifact will be approximately equal to the size of the backed-up database. The speed of the import operation is affected by compression, but which is faster depends upon the relative performance of CPU and storage. If import speed is important, consider evaluating both options - with compression enabled and disabled.

false

--delimiter=<char>

Delimiter character between values in CSV data. Also accepts TAB and e.g. U+002A for specifying a character using Unicode. Note that the delimiter character must be a single byte character in UTF-8.

  • ASCII character — e.g. --delimiter=",".

  • \ID — Unicode character with ID, e.g. --delimiter="\44".

  • U+XXXX — Unicode character specified with 4 HEX characters, e.g. --delimiter="U+20AC".

  • \t — horizontal tabulation (HT), e.g. --delimiter="\t".

For horizontal tabulation (HT), use \t or the Unicode character ID \9.

Unicode character ID can be used if prepended by \.

,

--dry-run[=true|false][3]

Introduced in 2026.02Flag used to indicate that a dry run of the import should be performed, i.e. no data will actually be imported, only the validation of the various arguments and estimation of size of the import will be performed and reported.

false

--expand-commands

Allow command expansion in config value evaluation.

--format=<format>

Name of database format. The imported database will be created in the specified format or use the format set in the configuration. Valid formats are standard, aligned, high_limit, and block.

-h, --help

Show this help message and exit.

--high-parallel-io=on|off|auto

Ignore environment-based heuristics and indicate if the target storage subsystem can support parallel IO with high throughput or auto detect. Typically this is on for SSDs, large raid arrays, and network-attached storage.

auto

--id-type=string|integer|actual

Each node must provide a unique ID. This is used to find the correct nodes when creating relationships.

Possible values are:

  • string — arbitrary strings for identifying nodes.

  • integer — arbitrary integer values for identifying nodes.

  • actual — (advanced) actual node IDs.

string

--ignore-empty-strings[=true|false]

Whether or not empty string fields, i.e. "" from input source are ignored, i.e. treated as null.

false

--ignore-extra-columns[=true|false]

If unspecified columns should be ignored during the import.

false

--input-encoding=<character-set>

Character set that input data is encoded in.

UTF-8

--input-type=csv|parquet

File type to import from. Can be csv or parquet. Defaults to csv.

--legacy-style-quoting[=true|false]

Whether or not a backslash-escaped quote e.g. \" is interpreted as an inner quote.

false

--max-off-heap-memory=<size>

Maximum off-heap memory that the command can use for page cache and various caching data structures to improve performance. Use this option to tune the command memory usage; the command does not use the server.memory.pagecache.size configuration setting for this purpose. Values can be plain numbers, such as 10000000, or, for example, 20G for 20 gigabytes, or 70%, which will amount to 70% of currently free memory on the machine.

90%

--multiline-fields=true|false|<path>[,<path>] [4]

In v1, whether or not fields from an input source can span multiple lines, i.e. contain newline characters. Setting --multiline-fields=true can severely degrade the performance of the importer. Therefore, use it with care, especially with large imports. In v2, this option will specify the list of files that contain multiline fields. Files can also be specified using regular expressions.

--multiline-fields-format=v1|v2

Controls the parsing of input source that can span multiple lines, i.e. contain newline characters. When set to v1, the value for --multiline-fields can only be true or false. When set to v2, the value for --multiline-fields should be the list of files that contain multiline fields.

v1

--nodes=[<label>[:<label>]…​=]<files>…​

Node CSV header and data.

  • Multiple files will be logically seen as one big file from the perspective of the importer.

  • The first line must contain the header.

  • Multiple data sources like these can be specified in one import, where each data source has its own header.

  • Files can also be specified using regular expressions.

It is possible to import files from AWS S3 buckets, Google Cloud storage buckets, and Azure buckets using the appropriate URI as the path.

For an example, see Import data from CSV files using regular expression.

--normalize-types[=true|false]

When true, non-array property values are converted to their equivalent Cypher types. For example, all integer values will be converted to 64-bit long integers.

true

--overwrite-destination[=true|false]

Delete any existing database files prior to the import.

false

--path-pattern-style=regex|glob|none[5]

Introduced in 2026.01 Pattern style to use for matching --nodes and --relationships files.

Possible values are:

  • glob — allows you to write patterns like /some/**/deep/**/nested/structure.*.

  • regex — allows you to write regular expressions, i.e. /some/nested/structure.*.

  • none — you have to enumerate all the file paths exactly, i.e. /some/content/structure1.csv,/some/content/structure2.csv.

regex

--profile[=true|false]

Introduced in 2026.02Capture a java flight recording for the entire duration of the import.

false

--profile-results-path=<path>

Introduced in 2026.02Provide a path where to store java flight recordings captured with the --profile option. Requires --profile or --profile=true to be set to have an effect.

--property-shard-count=<propertyShardCount>[2]

Introduced in 2025.12Infinigraph Number of shards of property data that will be created, each shard will be its own database. When this value is 0, it is the equivalent of running just a FULL import.

0

--quote=<char> [6]

Character to treat as a quotation mark for values in CSV data.

For example, quotes can be escaped as per RFC 4180 by doubling them. Thus "" would be interpreted as a literal ".

You cannot escape using \. For CSV data, this value must be different from the one specified in the --delimiter option.

"

--read-buffer-size=<size>

Size of each buffer for reading input data.

It has to be at least large enough to hold the biggest single value in the input data. The value can be a plain number or a byte units string, e.g. 128k, 1m.

4194304

--relationships=[<type>=]<files>…​

Relationship CSV header and data.

  • Multiple files will be logically seen as one big file from the perspective of the importer.

  • The first line must contain the header.

  • Multiple data sources like these can be specified in one import, where each data source has its own header.

  • Files can also be specified using regular expressions.

It is possible to import files from AWS S3 buckets, Google Cloud storage buckets, and Azure buckets using the appropriate URI as the path.

For an example, see Import data from CSV files using regular expression.

--report-file=<path>

File in which to store the report of the csv-import.

The location of the import log file can be controlled using the --report-file option. If you run large imports of CSV files that have low data quality, the import log file can grow very large. For example, CSV files that contain duplicate node IDs, or that attempt to create relationships between non-existent nodes, could be classed as having low data quality. In these cases, you may wish to direct the output to a location that can handle the large log file.

If you are running on a UNIX-like system and you are not interested in the output, you can get rid of it altogether by directing the report file to /dev/null.

If you need to debug the import, it might be useful to collect the stack trace. This is done by using the --verbose option.

--schema=<path>

Introduced in 2025.02 Enterprise edition Path to the file containing the Cypher commands for creating indexes and constraints during data import. It is possible to load commands from AWS S3 buckets, Google Cloud storage buckets, and Azure buckets using the appropriate URI as the path.

--skip-bad-entries-logging[=true|false]

When set to true, the details of bad entries are not written in the log. Disabling logging can improve performance when the data contains lots of faults. Cleaning the data before importing it is highly recommended because faults dramatically affect the tool’s performance even without logging.

false

--skip-bad-relationships[=true|false]

Whether or not to skip importing relationships that refer to missing node IDs, i.e. either start or end node ID/group referring to a node that was not specified by the node input data.

Skipped relationships will be logged if they are within the limit of entities specified by --bad-tolerance and the --skip-bad-entries-logging option is disabled.

false

--skip-duplicate-nodes[=true|false]

Whether or not to skip importing nodes that have the same ID/group.

In the event of multiple nodes within the same group having the same ID, the first encountered will be imported, whereas consecutive such nodes will be skipped.

Skipped nodes will be logged if they are within the limit of entities specified by --bad-tolerance and the --skip-bad-entries-logging option is disabled.

false

--strict[=true|false]

Whether or not the lookup of nodes referred to from relationships needs to be checked strict. If disabled, most but not all relationships referring to non-existent nodes will be detected. If enabled all those relationships will be found but at the cost of lower performance.

false

--target-format=<format>[2]

Introduced in 2025.12Enterprise edition Target format can be either a plain database directory/files structure (database) or a backup artifact (backup). Uses the --temp-path location to keep any intermediate state.

database

--target-location=<path>[2]

Introduced in 2025.12Enterprise edition Location for target backup artifact data. Used together with --target-format=backup.

--temp-path=<path>

Introduced in 2025.04 Provide a path where to store temporary files that are created and deleted during import. If not specifically provided, the default temp path will be created inside the database directory of the imported database.

--threads=<num>

(advanced) Max number of worker threads used by the importer. Defaults to the number of available processors reported by the JVM. There is a certain amount of minimum threads needed so for that reason there is no lower bound for this value. For optimal performance, this value should not be greater than the number of available processors.

--trim-strings[=true|false]

Whether or not strings should be trimmed for whitespaces.

false

--vector-delimiter=<char>

Introduced in 2025.10 Delimiter character between vector coordinates within a value in CSV data. Also accepts TAB and e.g. U+20AC for specifying a character using Unicode. For CSV data, this value must be different from the one specified in the --delimiter option. For Parquet data, this is only needed if the vector is encoded as a string.

;

--verbose

Enable verbose output.

1. See Neo4j Admin and Neo4j CLI → Configuration for details.
2. For using this option with sharded property databases, see Property Sharding → Data import.
3. See Perform a dry run before importing data for details.
4. The option’s value depends on --multiline-fields-format. For details, see Importing data that spans multiple lines.
5. See Using pattern style for matching nodes and relationships files for details.
6. To escape quotation marks in the CSV data, you should double the configured character.

Tips and limitations

The following tips and limitations apply to the neo4j-admin database import full command:

Heap size for the import

If you want to set the maximum heap size to a relevant value for the import, define the HEAP_SIZE environment parameter before starting the import. For example, 2G is an appropriate value for smaller imports.

If doing imports in the order of magnitude of 100 billion entities, 20G will be an appropriate value.

Record format

If your import data results in a graph that is larger than 34 billion nodes, 34 billion relationships, or 68 billion properties, you will need to configure the importer to use the block format. This is achieved by using the format option of the import command and setting the value to block:

bin/neo4j-admin database import full \
--format=block

The block format is available in Enterprise Edition only. See Store formats for more information on the block format.

Providing arguments in a file

All options can be provided in a file and passed to the command using the @ prefix. This is useful when the command line becomes too long to manage. For example, the following command:

bin/neo4j-admin database import full \
@/path/to/your/<args-filename> \
databasename

For more information, see Picocli → AtFiles official documentation.

Using both a multi-value option and a positional parameter

When using both a multi-value option, such as --nodes and --relationships, and a positional parameter (for example, in --additional-config neo4j.properties --nodes 0-nodes.csv mydatabase), the --nodes option acts "greedy" and the next option, in this case, mydatabase, is pulled in via the nodes convertor.

This is a limitation of the underlying library, Picocli, and is not specific to Neo4j Admin. For more information, see Picocli → Variable Arity Options and Positional Parameters official documentation.

To resolve the problem, use one of the following solutions:

  • Put the positional parameters first. For example, mydatabase --nodes 0-nodes.csv.

  • Put the positional parameters last, after -- and the final value of the last multi-value option. For example, nodes 0-nodes.csv — mydatabase.

Examples

The following examples show how to import data from CSV files into a Neo4j database. For in-depth examples of using the command neo4j-admin database import full, refer to the Tutorials → Full data import.

Importing data into an existing database does not work unless you use the --overwrite-destination option, which deletes any existing database files prior to the import. If you import data into a non-existent database, you must subsequently create it using CREATE DATABASE.

Assume that you have formatted your data as per CSV header format so that you have it in six different files:

  1. movies_header.csv

  2. movies.csv

  3. actors_header.csv

  4. actors.csv

  5. roles_header.csv

  6. roles.csv

Perform a dry run before importing data
Introduced in 2026.02

Before performing the actual import, you can run a dry run to validate the input files and estimate the size of the import. The command does not write any data to the database.

bin/neo4j-admin database import full \
--dry-run=true \
--nodes=import/movies_header.csv,import/movies.csv \
--nodes=import/actors_header.csv,import/actors.csv \
--relationships=import/roles_header.csv,import/roles.csv
Example output
Neo4j version: 2026.08.1
Checking the contents of the following files:
Nodes:
  /path/to/neo4j-enterprise-2026.08.1/import/movies_header.csv
  /path/to/neo4j-enterprise-2026.08.1/import/movies.csv
  /path/to/neo4j-enterprise-2026.08.1/import/actors_header.csv
  /path/to/neo4j-enterprise-2026.08.1/import/actors.csv

Relationships:
  null:
  /path/to/neo4j-enterprise-2026.08.1/import/roles_header.csv
  /path/to/neo4j-enterprise-2026.08.1/import/roles.csv


Available resources:
  Total machine memory: 32.00GiB
  Free machine memory: 81.34MiB
  Max heap memory : 7.111GiB
  Max worker threads: 10
  Configured max memory: 88.11MiB
  High parallel IO: true

Cypher type normalization is enabled (disable with --normalize-types=false):
  Property type of 'year' normalized from 'int' --> 'long' in /path/to/neo4j-enterprise-2026.08.1/import/movies_header.csv
Estimated entity counts / sizes:
  Nodes: 6
    Labels: 8
    Total property count: 15
    Total properties size: 237B
  Relationships: 9
    Total property count: 9
    Total properties size: 108B

Import data from multiple CSV files

The following command imports the three datasets:

bin/neo4j-admin database import full \
--nodes=import/movies_header.csv,import/movies.csv \
--nodes=import/actors_header.csv,import/actors.csv \
--relationships=import/roles_header.csv,import/roles.csv

Import data from CSV files using regular expression

Assume that you want to include a header and then multiple files that match a pattern, e.g. containing numbers. In this case, a regular expression can be used. It is guaranteed that groups of digits will be sorted in numerical order, as opposed to lexicographic order.

For example:

bin/neo4j-admin database import full \
--nodes=import/node_header.csv,import/node_data_\d+\.csv

In many scripting languages, you must use double backslashes (\\) when defining regular expression patterns inside string literals. This is because a single backslash (\) is treated as an escape character.

Import data from CSV files using a more complex regular expression

For regular expression patterns containing commas, which is also the delimiter between files in a group, the pattern can be quoted to preserve the pattern.

For example:

bin/neo4j-admin database import full \
--nodes=import/node_header.csv,'import/node_data_\d{1,5}.csv' \
databasename

Importing files from a cloud storage

In Neo4j 2025.03, new cloud integration settings are introduced to provide better support for deployment and management in cloud ecosystems. For details, refer to Configuration settings → Cloud storage integration settings.

The following examples show how to import data stored in a cloud storage bucket using the --nodes and --relationships options.

Neo4j uses the AWS SDK v2 to call the APIs on AWS using AWS URLs. Alternatively, you can override the endpoints so that the AWS SDK can communicate with alternative storage systems, such as Ceph, Minio, or LocalStack, using the system variables aws.endpointUrls3, aws.endpointUrlS3, or aws.endpointUrl, or the environments variables AWS_ENDPOINT_URL_S3 or AWS_ENDPOINT_URL.

  1. Install the AWS CLI by following the instructions in the AWS official documentation — Install the AWS CLI version 2.

  2. Create an S3 bucket and a directory to store the backup files using the AWS CLI:

    aws s3 mb --region=us-east-1 s3://myBucket
aws s3api put-object --bucket myBucket --key myDirectory/

    For more information on how to create a bucket and use the AWS CLI, see the AWS official documentation — Use Amazon S3 with the AWS CLI and Use high-level (s3) commands with the AWS CLI.

  3. Verify that the ~/.aws/config file is correct by running the following command:

    cat ~/.aws/config

    The output should look like this:

    [default]
region=us-east-1

  4. Configure the access to your AWS S3 bucket by setting the aws_access_key_id and aws_secret_access_key in the ~/.aws/credentials file and, if needed, using a bucket policy. For example:

    1. Use aws configure set aws_access_key_id aws_secret_access_key command to set your IAM credentials from AWS and verify that the ~/.aws/credentials is correct:

      cat ~/.aws/credentials

      The output should look like this:

      [default]
aws_access_key_id=this.is.secret
aws_secret_access_key=this.is.super.secret

    2. Additionally, you can use a resource-based policy to grant access permissions to your S3 bucket and the objects in it. Create a policy document with the following content and attach it to the bucket. Note that both resource entries are important to be able to download and upload files.

      {
    "Version": "2012-10-17",
    "Id": "Neo4jBackupAggregatePolicy",
    "Statement": [
        {
            "Sid": "Neo4jBackupAggregateStatement",
            "Effect": "Allow",
            "Action": [
                "s3:ListBucket",
                "s3:GetObject",
                "s3:PutObject",
                "s3:DeleteObject"
            ],
            "Resource": [
                "arn:aws:s3:::myBucket/*",
                "arn:aws:s3:::myBucket"
            ]
        }
    ]
}

  5. Run the neo4j-admin database import command to import your data from your AWS S3 storage bucket. The example assumes that you have data stored in the myBucket/data folder in your bucket.

    bin/neo4j-admin database import full \
--nodes=s3://myBucket/data/nodes.csv \
--relationships=s3://myBucket/data/relationships.csv \
databasename

  1. Ensure you have a Google account and a project created in the Google Cloud Platform (GCP).

    1. Install the gcloud CLI by following the instructions in the Google official documentation — Install the gcloud CLI.

    2. Create a service account and a service account key using Google official documentation — Create service accounts and Creating and managing service account keys.

    3. Download the JSON key file for the service account.

    4. Set the GOOGLE_APPLICATION_CREDENTIALS and GOOGLE_CLOUD_PROJECT environment variables to the path of the JSON key file and the project ID, respectively:

      export GOOGLE_APPLICATION_CREDENTIALS="/path/to/keyfile.json"
export GOOGLE_CLOUD_PROJECT=YOUR_PROJECT_ID

    5. Authenticate the gcloud CLI with the e-mail address of the service account you have created, the path to the JSON key file, and the project ID:

      gcloud auth activate-service-account [email protected] --key-file=$GOOGLE_APPLICATION_CREDENTIALS --project=$GOOGLE_CLOUD_PROJECT

      For more information, see the Google official documentation — gcloud auth activate-service-account.

    6. Create a bucket in the Google Cloud Storage using Google official documentation — Create buckets.

    7. Verify that the bucket is created by running the following command:

      gcloud storage ls

      The output should list the created bucket.

  2. Run the neo4j-admin database import command to import your data from your Google storage bucket. The example assumes that you have data stored in the myBucket/data folder in your bucket.

    bin/neo4j-admin database import full \
--nodes=gs://myBucket/data/nodes.csv \
--relationships=gs://myBucket/data/relationships.csv \
databasename

  1. Ensure you have an Azure account, an Azure storage account, and a blob container.

    1. You can create a storage account using the Azure portal.
      For more information, see the Azure official documentation on Create a storage account.

    2. Create a blob container in the Azure portal.
      For more information, see the Azure official documentation on Quickstart: Upload, download, and list blobs with the Azure portal.

  2. Install the Azure CLI by following the instructions in the Azure official documentation — Azure official documentation.

  3. Authenticate the neo4j or neo4j-admin process against Azure using the default Azure credentials.
    See the Azure official documentation on default Azure credentials for more information.

    az login

    Then you should be ready to use Azure URLs in either neo4j or neo4j-admin.

  4. To validate that you have access to the container with your login credentials, run the following commands:

    # Upload a file:
az storage blob upload --file someLocalFile  --account-name accountName - --container someContainer --name remoteFileName  --auth-mode login

# Download the file
az storage blob download  --account-name accountName --container someContainer --name remoteFileName --file downloadedFile --auth-mode login

# List container files
az storage blob list  --account-name someContainer --container someContainer  --auth-mode login

  5. Run the neo4j-admin database import command to import your data from your Azure blob storage container. The example assumes that you have data stored in the myStorageAccount/myContainer/data folder in your container.

    bin/neo4j-admin database full \
--nodes=azb://myStorageAccount/myContainer/data/nodes.csv \
--relationships=azb://myStorageAccount/myContainer/data/relationships.csv \
databasename

Importing compressed files

You can import files compressed with zip or gzip. Each compressed file must contain a single file.

For example, the following command imports compressed files, where actors.csv.zip is a zip file and movies.csv.gz and roles.csv.gz are gzip files:

neo4j_home$ ls import
actors-header.csv  actors.csv.zip  movies-header.csv  movies.csv.gz  roles-header.csv  roles.csv.gz
bin/neo4j-admin database import full \
--nodes=import/movies-header.csv,import/movies.csv.gz \
--nodes=import/actors-header.csv,import/actors.csv.zip \
--relationships=import/roles-header.csv,import/roles.csv.gz

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