PHPackages                             laudis/neo4j-php-client - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [HTTP & Networking](/categories/http)
4. /
5. laudis/neo4j-php-client

ActiveLibrary[HTTP & Networking](/categories/http)

laudis/neo4j-php-client
=======================

Neo4j-PHP-Client is the most advanced PHP Client for Neo4j

3.4.3(1mo ago)184616.9k—9%41[11 issues](https://github.com/neo4j-php/neo4j-php-client/issues)[3 PRs](https://github.com/neo4j-php/neo4j-php-client/pulls)20MITPHPPHP ^8.1CI passing

Since Dec 7Pushed 1mo ago11 watchersCompare

[ Source](https://github.com/neo4j-php/neo4j-php-client)[ Packagist](https://packagist.org/packages/laudis/neo4j-php-client)[ RSS](/packages/laudis-neo4j-php-client/feed)WikiDiscussions main Synced 1mo ago

READMEChangelog (10)Dependencies (48)Versions (106)Used By (20)

Neo4j PHP Client and Driver
===========================

[](#neo4j-php-client-and-driver)

[![GitHub](https://camo.githubusercontent.com/dd673ced53c5462e9b706367301c97ab680038da9220a330d442b2ef6229aa83/68747470733a2f2f696d672e736869656c64732e696f2f6769746875622f6c6963656e73652f6e656f346a2d7068702f6e656f346a2d7068702d636c69656e74)](https://github.com/laudis-technologies/neo4j-php-client/blob/main/LICENSE)[![Packagist PHP Version Support (custom server)](https://camo.githubusercontent.com/d8989e9a5e04aab83909f97ff1b0a9fc6bb703769a5ccf02e5d706d1b428fec2/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f7068702d762f6c61756469732f6e656f346a2d7068702d636c69656e74)](https://packagist.org/packages/laudis/neo4j-php-client)[![Latest Stable Version](https://camo.githubusercontent.com/bec009a2a3b03612b0b9bd2cb5d7e2d83ad0986559c590b0a2eb12d6fd7ee69f/68747470733a2f2f706f7365722e707567782e6f72672f6c61756469732f6e656f346a2d7068702d636c69656e742f76)](https://packagist.org/packages/laudis/neo4j-php-client)

[![Packagist Downloads](https://camo.githubusercontent.com/a3c4736fd967a5ea8372755c4b5fa07532a1c1ca4f3a3366ebe8a47daad87629/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f64742f6c61756469732f6e656f346a2d7068702d636c69656e74)](https://packagist.org/packages/laudis/neo4j-php-client/stats)[![Packagist Downloads](https://camo.githubusercontent.com/4cec0644f5dc01e0436cfb60fd9740782990ee063fb33b66907cfd65f5af19a2/68747470733a2f2f696d672e736869656c64732e696f2f7061636b61676973742f646d2f6c61756469732f6e656f346a2d7068702d636c69656e74)](https://packagist.org/packages/laudis/neo4j-php-client/stats)

Control to worlds' most powerful graph database
-----------------------------------------------

[](#control-to-worlds-most-powerful-graph-database)

- Pick and choose your drivers with easy configuration
- Intuitive API
- Extensible
- Designed, built and tested under close supervision with the official neo4j driver team
- Validated with [testkit](https://github.com/neo4j-drivers/testkit)
- Fully typed with [psalm](https://psalm.dev/)
- Bolt, HTTP and auto routed drivers available

See the driver in action
------------------------

[](#see-the-driver-in-action)

- [An implementation of the class movie database](https://github.com/neo4j-examples/movies-neo4j-php-client). It uses Slim and neo4j-php-client to build an API for the classic movie's example of neo4j.
- [An complete implementation of the realworld example](https://github.com/neo4j-examples/php-laravel-neo4j-realworld-example). It uses Laravel to implement the [real world example](https://github.com/gothinkster/realworld) project, *the mother of all demo apps*.
- [The friends api](https://github.com/neo4j-examples/friends-php-client) for the world's most corny example project leveraging the power of Neo4j.

For some more detailed write-ups you can refer to these blogposts:

- [How to build a JSON RESTful API with Neo4j, PHP and Open API](https://medium.com/neo4j/how-to-build-a-json-restful-api-with-neo4j-php-and-openapi-e45bf0a8956)
- [Building a Web App with Neo4j, AuraDB and PHP](https://medium.com/neo4j/building-a-web-app-with-neo4j-auradb-and-php-990deca0d213)
- [Connect to Neo4j with PHP](https://medium.com/neo4j/connect-to-neo4j-with-php-e10e24afedff)
- [Enterprise level PHP and Neo4j](https://medium.com/neo4j/enterprise-level-php-and-neo4j-e467a789e6b4)

Or watch any of these [videos](https://www.youtube.com/watch?v=qwz5XVtbfSY&list=PL9Hl4pk2FsvViI9wmdDpRS7tZ8V6j4uJs).

Start your driving experience in three easy steps
-------------------------------------------------

[](#start-your-driving-experience-in-three-easy-steps)

### Step 1: install via composer

[](#step-1-install-via-composer)

```
composer require laudis/neo4j-php-client
```

Find more details [here](#in-depth-requirements)

### Step 2: create a client

[](#step-2-create-a-client)

```
use Laudis\Neo4j\Authentication\Authenticate;
use Laudis\Neo4j\ClientBuilder;

$client = ClientBuilder::create()
    ->withDriver('bolt', 'bolt+s://user:password@localhost') // creates a bolt driver
    ->withDriver('https', 'https://test.com', Authenticate::basic('user', 'password')) // creates an http driver
    ->withDriver('neo4j', 'neo4j://neo4j.test.com?database=my-database', Authenticate::oidc('token')) // creates an auto routed driver with an OpenID Connect token
    ->withDefaultDriver('bolt')
    ->build();
```

You have now created a client with **bolt, HTTPS and neo4j drivers**. The default driver that the client will use is **bolt**.

Read more about the URLs and how to use them to configure drivers [here](#in-depth-configuration).

### Step 3: run a transaction

[](#step-3-run-a-transaction)

```
use Laudis\Neo4j\Contracts\TransactionInterface;

$result = $client->writeTransaction(static function (TransactionInterface $tsx) {
    $result = $tsx->run('MERGE (x {y: "z"}:X) return x');
    return $result->first()->get('x')['y'];
});

echo $result; // echos 'z'
```

Decide how to send your Cypher queries
--------------------------------------

[](#decide-how-to-send-your-cypher-queries)

You can control the driver using three different approaches:

- *Auto committed queries* (easiest and most intuitive)
- *Transaction functions* (most portable)
- *Unmanaged transactions* (for the highest degree of control)

### Auto committed queries

[](#auto-committed-queries)

Auto committed queries are the most straightforward and most intuitive but have many drawbacks when running complex business logic or within a high availability environment.

#### Run a simple cypher query

[](#run-a-simple-cypher-query)

```
$client->run(
    'MERGE (user {email: $email})', //The query is a required parameter
    ['email' => 'abc@hotmail.com'],  //Requests can be optionally added
    'backup' //The default connection can be overridden
);
```

#### Run a statement object:

[](#run-a-statement-object)

```
use Laudis\Neo4j\Databags\Statement;

$statement = new Statement('MERGE (user {email: $email})', ['email' => 'abc@hotmail.com']);
$client->runStatement($statement, 'default');
```

#### Running multiple queries at once

[](#running-multiple-queries-at-once)

The `runStatements` method will run all the statements at once. This method is an essential tool to reduce the number of database calls, especially when using the HTTP protocol.

```
use Laudis\Neo4j\Databags\Statement;

$results = $client->runStatements([
    Statement::create('MATCH (x) RETURN x LIMIT 100'),
    Statement::create('MERGE (x:Person {email: $email})', ['email' => 'abc@hotmail.com'])
]);
```

### Transaction functions

[](#transaction-functions)

Transaction functions are the **de facto** standard when using the driver. It is the most portable as it is resistant to a lot of the pitfalls when first developing with high availability solutions such as [Neo4j aura](https://neo4j.com/blog/neo4j-aura-enterprise-ga-release/) or a [cluster](https://neo4j.com/docs/operations-manual/current/clustering/).

The driver manages transaction functions:

- It **re-executes** the function in case of a [transient error](https://neo4j.com/docs/status-codes/current/#_classifications).
- It **commits** the transaction on successful execution
- It **rolls back** the transaction in case of a timeout.
- It **routes** the execution to a relevant follower or leader server when the neo4j protocol is enabled.

> ATTENTION: Because of the automatic retry functionality, the function should produce the same result on subsequent recalls, or in more technical terms: should be **idempotent**. Always remember this when designing the execution logic within the function.

Some examples:

```
use Laudis\Neo4j\Contracts\TransactionInterface;

// Do a simple merge and return the result
$result = $client->writeTransaction(static function (TransactionInterface $tsx) {
    $result = $tsx->run('MERGE (x {y: "z"}:X) return x');
    return $result->first()->get('x')['y'];
});

// Will result in an error
$client->readTransaction(static function (TransactionInterface $tsx) {
    $tsx->run('MERGE (x {y: "z"}:X) return x');
});

// This is a poorly designed transaction function
$client->writeTransaction(static function (TransactionInterface $tsx) use ($externalCounter) {
    $externalCounter->incrementNodesCreated();
    $tsx->run('MERGE (x {y: $id}:X) return x', ['id' => Uuid::v4()]);
});

// This achieves the same effect but is safe in case it should be retried. The function is now idempotent.
$id = Uuid::v4();
$client->writeTransaction(static function (TransactionInterface $tsx) use ($id) {
    $tsx->run('MERGE (x {y: $id}:X) return x', ['id' => $id]);
});
$externalCounter->incrementNodesCreated();
```

### Unmanaged transactions

[](#unmanaged-transactions)

If you need lower-level access to the drivers' capabilities, then you want unmanaged transactions. They allow for completely controllable commits and rollbacks.

#### Opening a transaction

[](#opening-a-transaction)

The `beginTransaction` method will start a transaction with the relevant driver.

```
use Laudis\Neo4j\Databags\Statement;

$tsx = $client->beginTransaction(
    // This is an optional set of statements to execute while opening the transaction
    [Statement::create('MERGE (x:Person({email: $email})', ['email' => 'abc@hotmail.com'])],
    'backup' // This is the optional connection alias
);
```

> Note that `beginTransaction` only returns the transaction object, not the results of the provided statements.

#### Running statements within a transaction

[](#running-statements-within-a-transaction)

The transaction can run statements just like the client object as long as it is still open.

```
$result = $tsx->run('MATCH (x) RETURN x LIMIT 100');
$result = $tsx->runStatement(Statement::create('MATCH (x) RETURN x LIMIT 100'));
$results = $tsx->runStatements([Statement::create('MATCH (x) RETURN x LIMIT 100')]);
```

#### Finish a transaction

[](#finish-a-transaction)

Rollback a transaction:

```
$tsx->rollback();
```

Commit a transaction:

```
$tsx->commit([Statement::create('MATCH (x) RETURN x LIMIT 100')]);
```

Accessing the results
---------------------

[](#accessing-the-results)

Results are returned in a standard format of rows and columns:

```
// Results are a CypherList
$results = $client->run('MATCH (node:Node) RETURN node, node.id AS id');

// A row is a CypherMap
foreach ($results as $result) {
    // Returns a Node
    $node = $result->get('node');

    echo $node->getProperty('id');
    echo $result->get('id');
}
```

Cypher values and types map to these php types and classes:

CypherPhpnull\* `null`string\* `string`integer\* `int`float\* `float`boolean\* `bool`Map\* `\Laudis\Neo4j\Types\CypherMap`List\* `\Laudis\Neo4j\Types\CypherList`Point\* `\Laudis\Neo4j\Contracts\PointInterface` \*\*Date\* `\Laudis\Neo4j\Types\Date`Time\* `\Laudis\Neo4j\Types\Time`LocalTime\* `\Laudis\Neo4j\Types\LocalTime`DateTime\* `\Laudis\Neo4j\Types\DateTime`DateTimeZoneId\* `\Laudis\Neo4j\Types\DateTimeZoneId`LocalDateTime\* `\Laudis\Neo4j\Types\LocalDateTime`Duration\* `\Laudis\Neo4j\Types\Duration`Node`\Laudis\Neo4j\Types\Node`Relationship`\Laudis\Neo4j\Types\Relationship`Path`\Laudis\Neo4j\Types\Path`Vector`\Laudis\Neo4j\Types\Vector` \*\*\*(\*) These items can also be used as parameters in the bolt protocol and will automatically be converted by the driver, so they can be used in Cypher.

(\*\*\*) Vector (e.g. embedding) is only produced when decoding results from the server; it is not supported as a query parameter.

Besides these examples, `\DateTimeInterface` will map to `DateTimeZoneId` in Cypher. An empty or list-type `array` will be converted to a cypher `List`, and an `associative array` will be converted to a `map`.

(\*\*) A point can be one of four types implementing PointInterface: `\Laudis\Neo4j\Types\CartesianPoint` `\Laudis\Neo4j\Types\Cartesian3DPoint` `\Laudis\Neo4j\Types\WGS84Point` `\Laudis\Neo4j\Types\WGS843DPoint`

Diving Deeper
-------------

[](#diving-deeper)

### Differentiating between parameter type

[](#differentiating-between-parameter-type)

Cypher has lists and maps. This notion can be problematic as the standard php arrays encapsulate both. When you provide an empty array as a parameter, it will be impossible to determine an empty list or map.

The `ParameterHelper` class is the ideal companion for this:

```
use Laudis\Neo4j\ParameterHelper;

$client->run('MATCH (x) WHERE x.slug in $listOrMap RETURN x', ['listOrMap' => ParameterHelper::asList([])]); // will return an empty CypherList
$client->run('MATCH (x) WHERE x.slug in $listOrMap RETURN x', ['listOrMap' => ParameterHelper::asMap([])]); // will error
$client->run('MATCH (x) WHERE x.slug in $listOrMap RETURN x', ['listOrMap' => []]); // will return an empty CypherList
```

### Version compatibility matrix

[](#version-compatibility-matrix)

**Driver Version****PHP Version****Neo4j Version**^2.87.4, ^8.0^3.5, ^4.0^3.0^8.0^4.0, ^5.0### Neo4j Feature Support

[](#neo4j-feature-support)

**Feature****Supported?**AuthenticationYesTransactionsYesHttp ProtocolYesBolt ProtocolYesClusterYesAuraYesJolt ProtocolYesBookmarksYesIn-depth requirements
---------------------

[](#in-depth-requirements)

- PHP >= 7.4
- A Neo4j database (minimum version 3.5)
- ext-bcmath \*
- ext-json \*\*
- ext-sockets \*\*\*

(\*) Needed to implement the bolt protocol

(\*\*) Needed to implement the http protocol

(\*\*\*) Can be installed for optimal bolt protocol performance

If you plan on using the HTTP drivers, make sure you have [psr-7](https://www.php-fig.org/psr/psr-7/), [psr-17](https://www.php-fig.org/psr/psr-17/) and [psr-18](https://www.php-fig.org/psr/psr-18/) implementations included into the project. If you don't have any, you can install them via composer:

```
composer require nyholm/psr7 nyholm/psr7-server kriswallsmith/buzz
```

Result formats/hydration
------------------------

[](#result-formatshydration)

In order to make the results of the bolt protocol and the http uniform, the driver provides and summarizes the results.

The default formatter is the `\Laudis\Neo4j\Formatters\SummarizedResultFormatter`, which is explained extensively in [the result format section](#accessing-the-results).

`\Laudis\Neo4j\Formatter\SummarizedResultFormatter` adds an extensive result summary.

The client builder provides an easy way to change the formatter:

```
$client = \Laudis\Neo4j\ClientBuilder::create()->build();

/**
 * The client will now return a result, decorated with a summary.
 *
 * @var \Laudis\Neo4j\Databags\SummarizedResult $results
 */
$summarisedResult = $client->run('MATCH (x) RETURN x');

// The summary contains extensive information such as counters for changed values in the database,
// information on the database, potential notifications, timing, a (profiled) plan, the type of query
// and information on the server itself.
$summary = $summarisedResult->getSummary();
// The result is exactly the same as the default.
$result = $summarisedResult->getResult();
```

Concepts
--------

[](#concepts)

The driver API described [here](https://neo4j.com/docs/driver-manual/current/) is the main target of the driver. Because of this, the client is nothing more than a driver manager. The driver creates sessions. A session runs queries through a transaction.

Because of this behaviour, you can access each concept starting from the client like this:

```
use Laudis\Neo4j\ClientBuilder;

// A builder is responsible for configuring the client on a high level.
$builder = ClientBuilder::create();
// A client manages the drivers as configured by the builder.
$client = $builder->build();
// A driver manages connections and sessions.
$driver = $client->getDriver('default');
// A session manages transactions.
$session = $driver->createSession();
// A transaction is the atomic unit of the driver where are the cypher queries are chained.
$transaction = $session->beginTransaction();
// A transaction runs the actual queries
$transaction->run('MATCH (x) RETURN count(x)');
```

If you need complete control, you can control each object with custom configuration objects.

### Client

[](#client)

A **client** manages **drivers** and routes the queries to the correct drivers based on preconfigured **aliases**.

### Driver

[](#driver)

The **driver** object is the thread-safe backbone that gives access to Neo4j. It owns a connection pool and can spawn **sessions** for carrying out work.

```
use Laudis\Neo4j\Basic\Driver;
use Laudis\Neo4j\Databags\DriverConfiguration;

$driver = Driver::create(
    uri: 'neo4j://user:mypassword@Localhost:7687',
    configuration: DriverConfiguration::create()->withUserAgent('MyApp/1.0.0')
);
```

### Session

[](#session)

**Sessions** are lightweight containers for causally chained sequences of **transactions**. They borrow **connections** from the connection pool as required and chain transactions using **bookmarks**.

```
use Laudis\Neo4j\Databags\SessionConfiguration;
use Laudis\Neo4j\Enum\AccessMode;

$session = $driver->createSession(SessionConfiguration::create()
    ->withDatabase('my-database')
    ->withAccessMode(AccessMode::READ())
);
```

### Transaction

[](#transaction)

**Transactions** are atomic units of work that may contain one or more **query**. Each transaction is bound to a single **connection** and is represented in the causal chain by a **bookmark**.

### Statement

[](#statement)

**Queries** are executable units within **transactions** and consist of a Cypher string and a keyed parameter set. Each query outputs a **result** that may contain zero or more **records**.

### Result

[](#result)

A **result** contains the output from a **query**, made up of header metadata, content **records** and summary metadata. In Neo4j 4.0 and above, applications have control over the flow of result data.

In-depth configuration
----------------------

[](#in-depth-configuration)

### Url Schemes

[](#url-schemes)

The URL scheme is the easiest way to configure the driver.

Configuration format:

```
'://:@:?database='

```

Default configuration:

```
bolt://localhost:7687?database=neo4j

```

#### Scheme configuration matrix

[](#scheme-configuration-matrix)

This library supports three drivers: bolt, HTTP and neo4j. The scheme part of the url determines the driver.

driverschemevalid certificateself-signed certificatefunctionneo4jneo4jneo4j+sneo4j+sscClient side routing over boltboltboltbolt+sbolt+sscSingle server over bolthttphttphttpsconfigured through PSR Client implementationSingle server over HTTP### Configuration objects

[](#configuration-objects)

A driver, session and transaction can be configured using configuration objects. An overview of the configuration options can be found here:

nameconceptdescriptionclassuser agentdriverThe user agent used to identify the client to the neo4j server.`DriverConfiguration`Http PSR BindingsdriverThe relevant PSR implementation used by the driver when using the HTTP protocol.`DriverConfiguration`databasesessionThe database to connect to.`SessionConfiguration`fetch sizesessionThe amount of rows to fetch at once.`SessionConfiguration`access modesessionThe default mode when accessing the server.`SessionConfiguration`bookmarkssessionThe bookmarks used in the session. (experimental)`SessionConfiguration`metadatatransactionThe metadata used during the transaction. (experimental)`TransactionConfiguration`timeouttransactionThe maximum amount of time before timing out.`TransactionConfiguration`Code Example:

```
use \Laudis\Neo4j\Databags\DriverConfiguration;
use Laudis\Neo4j\Databags\SessionConfiguration;
use Laudis\Neo4j\Databags\TransactionConfiguration;

$client = \Laudis\Neo4j\ClientBuilder::create()
    ->withDefaultDriverConfiguration(DriverConfiguration::default()->withUserAgent('MyApp/1.0.0'))
    ->withDefaultSessionConfiguration(SessionConfiguration::default()->withDatabase('app-database'))
    ->withDefaultTransactionConfiguration(TransactionConfiguration::default()->withTimeout(5.0))
    ->build();

// The client will run the query on a driver with the provided config,
// which spawns a session with the provided session config
// and runs the query in a transaction with the provided transaction config
$client->run('MATCH (x) RETURN count(x) AS count');

// More granular control can be achieved by requesting the concepts yourself:
$tsx = $client->getDriver('default')
    ->createSession(SessionConfiguration::default()->withDatabase('management-database'))
    ->beginTransaction(null, TransactionConfiguration::default()->withTimeout(200));

$tsx->run('SOME REALLY LONG MANAGEMENT QUERY');

$tsx->commit();
```

###  Health Score

69

—

FairBetter than 100% of packages

Maintenance88

Actively maintained with recent releases

Popularity56

Moderate usage in the ecosystem

Community40

Growing community involvement

Maturity79

Established project with proven stability

 Bus Factor1

Top contributor holds 85.5% of commits — single point of failure

How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window.

**Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores.

**Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement.

**Maturity (30%)** — Project age, version count, PHP version support, and release stability.

###  Release Activity

Cadence

Every ~26 days

Recently: every ~77 days

Total

75

Last Release

59d ago

Major Versions

1.3.5 → 2.0.02021-06-18

2.8.3 → 3.0.02023-03-24

0.5.0 → 3.0.32023-06-06

PHP version history (3 changes)1.0.0PHP ^7.4 || ^8.0

3.0.0PHP ^8.0

3.1.0PHP ^8.1

### Community

Maintainers

![](https://www.gravatar.com/avatar/9cb8ab20866bd4fb9928742bc2321fcfe89d5e8560d4abfdd52ba139072b487b?d=identicon)[transitive](/maintainers/transitive)

---

Top Contributors

[![transistive](https://avatars.githubusercontent.com/u/16435930?v=4)](https://github.com/transistive "transistive (1038 commits)")[![exaby73](https://avatars.githubusercontent.com/u/50555895?v=4)](https://github.com/exaby73 "exaby73 (83 commits)")[![p123-stack](https://avatars.githubusercontent.com/u/183799192?v=4)](https://github.com/p123-stack "p123-stack (21 commits)")[![stefanak-michal](https://avatars.githubusercontent.com/u/5502917?v=4)](https://github.com/stefanak-michal "stefanak-michal (21 commits)")[![pratikshazalte69](https://avatars.githubusercontent.com/u/123250052?v=4)](https://github.com/pratikshazalte69 "pratikshazalte69 (13 commits)")[![Mulkave](https://avatars.githubusercontent.com/u/2647333?v=4)](https://github.com/Mulkave "Mulkave (12 commits)")[![lcp0578](https://avatars.githubusercontent.com/u/10859621?v=4)](https://github.com/lcp0578 "lcp0578 (5 commits)")[![tim-hanssen](https://avatars.githubusercontent.com/u/11192051?v=4)](https://github.com/tim-hanssen "tim-hanssen (3 commits)")[![wgevaert](https://avatars.githubusercontent.com/u/56224691?v=4)](https://github.com/wgevaert "wgevaert (3 commits)")[![satdeveloping](https://avatars.githubusercontent.com/u/80039573?v=4)](https://github.com/satdeveloping "satdeveloping (2 commits)")[![GinoPane](https://avatars.githubusercontent.com/u/3897579?v=4)](https://github.com/GinoPane "GinoPane (2 commits)")[![zorac](https://avatars.githubusercontent.com/u/1845517?v=4)](https://github.com/zorac "zorac (1 commits)")[![evan-duncan](https://avatars.githubusercontent.com/u/5282872?v=4)](https://github.com/evan-duncan "evan-duncan (1 commits)")[![imanghafoori1](https://avatars.githubusercontent.com/u/6961695?v=4)](https://github.com/imanghafoori1 "imanghafoori1 (1 commits)")[![JeroenDeDauw](https://avatars.githubusercontent.com/u/146040?v=4)](https://github.com/JeroenDeDauw "JeroenDeDauw (1 commits)")[![jonathan-rowley](https://avatars.githubusercontent.com/u/50716090?v=4)](https://github.com/jonathan-rowley "jonathan-rowley (1 commits)")[![joseraul](https://avatars.githubusercontent.com/u/676681?v=4)](https://github.com/joseraul "joseraul (1 commits)")[![malberts](https://avatars.githubusercontent.com/u/1428594?v=4)](https://github.com/malberts "malberts (1 commits)")[![owenandrews](https://avatars.githubusercontent.com/u/5018955?v=4)](https://github.com/owenandrews "owenandrews (1 commits)")[![RobertEcker](https://avatars.githubusercontent.com/u/6156052?v=4)](https://github.com/RobertEcker "RobertEcker (1 commits)")

---

Tags

boltconnectiondatabasedriverhttpneo4jphpphp-librarysessiontransactionhttpclientdatabasedriverneo4jhigh availabilitygraphclusterbolt

###  Code Quality

TestsPHPUnit

Static AnalysisPsalm, Rector

Code StylePHP CS Fixer

Type Coverage Yes

### Embed Badge

![Health badge](/badges/laudis-neo4j-php-client/health.svg)

```
[![Health](https://phpackages.com/badges/laudis-neo4j-php-client/health.svg)](https://phpackages.com/packages/laudis-neo4j-php-client)
```

###  Alternatives

[php-http/client-common

Common HTTP Client implementations and tools for HTTPlug

1.1k225.5M571](/packages/php-http-client-common)[phpro/http-tools

HTTP tools for developing more consistent HTTP implementations.

28137.8k](/packages/phpro-http-tools)[stefanak-michal/bolt

PHP library to provide connectivity to graph database over TCP socket with Bolt specification

79655.8k8](/packages/stefanak-michal-bolt)

PHPackages © 2026

[Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)