---
title: "Cluster status and metadata"
description: "Monitor the health, status, and metadata of your Weaviate cluster."
url: https://docs.weaviate.io/deploy/configuration/status
---

# Cluster status and metadata

Monitor the health, status, and metadata of your Weaviate cluster.

## Liveness

The `live` endpoint checks if the application is alive. You can use it for a Kubernetes liveness probe.

#### Usage

The endpoint accepts a `GET` request:

```js
GET /v1/.well-known/live
```

The endpoint returns HTTP status code `200` if the application is able to respond to HTTP requests.

#### Example

**Python**

```py
import weaviate

client = weaviate.connect_to_local()

    print(client.is_live())

finally:
    client.close()
```

**JavaScript/TypeScript**

```js
import weaviate from '@weaviate/node';

const client = await weaviate.connectToLocal()
const response = await client.isLive()

console.log(response)
```

**Go (v5)**

```go
package main

import (
  "context"
  "fmt"

  "github.com/weaviate/weaviate-go-client/v5/weaviate"
)

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client, err := weaviate.NewClient(cfg)
  if err != nil {
    panic(err)
  }

  isLive, err := client.Misc().LiveChecker().Do(context.Background())
  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", isLive)
}
```

**Curl**

```bash
curl http://localhost:8080/v1/.well-known/live
```

The endpoint returns HTTP status code `200` if the application is able to respond to HTTP requests.

## Readiness

The `ready` endpoint checks if the application is ready to receive traffic. You can use it for Kubernetes readiness probe.

#### Usage

The discovery endpoint accepts a `GET` request:

```js
GET /v1/.well-known/ready
```

The endpoint returns HTTP status code `200` if the application is able to respond to HTTP requests. If the application is currently unable to serve traffic, the endpoint returns HTTP status code `503`.

If the application is unavailable and you have horizontal replicas of Weaviate that can receive traffic, redirect traffic to one of the replicas.

#### Example

**Python**

```py
import weaviate

client = weaviate.connect_to_local()

    print(client.is_ready())

finally:
    client.close()
```

**JavaScript/TypeScript**

```js
import weaviate from '@weaviate/node';

const client = await weaviate.connectToLocal()
const response = await client.isReady()

console.log(response)
```

**Go (v5)**

```go
package main

import (
  "context"
  "fmt"

  "github.com/weaviate/weaviate-go-client/v5/weaviate"
)

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client, err := weaviate.NewClient(cfg)
  if err != nil {
    panic(err)
  }

  isReady, err := client.Misc().ReadyChecker().Do(context.Background())
  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", isReady)
}
```

**Curl**

```bash
curl http://localhost:8080/v1/.well-known/ready
```

## Operational modes

> [!NOTE]
>
> **Added in `v1.35.0`**

Each Weaviate node can be set to one of the following operational modes, limiting the types of operations it can handle:

- `ReadWrite`: (default) There are no restrictions; the node can handle both read and write operations.
- `WriteOnly`: The node is limited to write operations.
- `ReadOnly`: The node is limited to read operations and backup creation via the `/backups` endpoints.
- `ScaleOut`: The same as `ReadOnly`, with additional CUD operations on `/replication` endpoints allowed.

These modes can be configured using the `OPERATIONAL_MODE` [environment variable](https://docs.weaviate.io/deploy/configuration/env-vars), or the equivalent `operational_mode` [runtime configuration](https://docs.weaviate.io/deploy/configuration/env-vars/runtime-config).

## Cluster synchronization

To check whether the nodes agree on the cluster state, use the [`/v1/cluster/statistics`](https://docs.weaviate.io/weaviate/api/rest#tag/cluster/GET/cluster/statistics) endpoint. It lists every node that has reported in, and a top-level `synchronized` field that is `true` when they have reached consensus.

## Cluster node data

You can retrieve information about individual nodes in a Weaviate cluster. The query can be for the entire cluster, or for a particular collection.

### Parameters

| Name | Location | Type | Description |
| - | - | - | - |
| `output` | body | string | How much information to include in the output. Options: `minimal` (default) and `verbose` (includes shard information). |

### Returned data:

The `nodes` endpoint returns an array of nodes. The nodes have the following fields:

- `name`: Name of the node.

- `status`: Status of the node (one of: `HEALTHY`, `UNHEALTHY`, `UNAVAILABLE`, `INDEXING`).

- `version`: Version of Weaviate running on the node.

- `gitHash`: Short git hash of the latest commit of Weaviate running on the node.

- `stats`: Statistics for the node.

  - `shardCount`: Total number of shards on the node.
  - `objectCount` Total number of indexed objects on the node.

- `shards`: Array of shard statistics. To see `shards` details, set `output == verbose`.

  - `name`: Name of the shard.
  - `class`: Name of the collection stored on the shard.
  - `objectCount`: Number of indexed objects on the shard.
  - `vectorQueueLength`: Number of objects waiting to be indexed on the shard. (Available starting in Weaviate `1.22` when `ASYNC_INDEXING` is enabled.)

### Example

The following command will retrieve summary information about all nodes in the cluster:

**Python**

```py
import weaviate

client = weaviate.connect_to_local()

nodes_info = client.cluster.nodes(
    collection="JeopardyQuestion",  # If omitted, all collections will be returned
    output="verbose",  #  If omitted, will be "minimal"
)
print(nodes_info)

client.close()
```

**JavaScript/TypeScript**

```js
import weaviate from '@weaviate/node';

const client = await weaviate.connectToLocal()

const response = await client.cluster.nodes({
  collection: 'JeopardyQuestion',
  output: 'minimal'
})

console.log(response)
```

**Go (v5)**

```go
package main

import (
  "context"
  "fmt"

  "github.com/weaviate/weaviate-go-client/v5/weaviate"
)

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client, err := weaviate.NewClient(cfg)
  if err != nil {
    panic(err)
  }

  nodesStatus, err := client.Cluster().
    NodesStatusGetter().
    Do(context.Background())

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", nodesStatus)
}
```

**Java**

```java
WeaviateClient client = WeaviateClient
    .connectToLocal(config -> config.host("127.0.0.1").port(8080));

System.out.println(client.cluster.listNodes()); // all
System.out
    .println(client.cluster.listNodes(n -> n.collection("MyCollection")
        .shard("MyShard")
        .verbosity(NodeVerbosity.MINIMAL)));

client.close(); // Free up resources
WeaviateClient client = WeaviateClient.connectToLocal();

System.out.println(client.meta()); // all

client.close(); // Free up resources
```

**Curl**

```bash
curl http://localhost:8080/v1/nodes
```

Example output:

```json
{
  "nodes": [
    {
      "batchStats": {
        "ratePerSecond": 0
      },
      "gitHash": "e6b37ce",
      "name": "weaviate-0",
      "stats": {
        "objectCount": 0,
        "shardCount": 2
      },
      "status": "HEALTHY",
      "version": "1.22.1"
    },
    {
      "batchStats": {
        "ratePerSecond": 0
      },
      "gitHash": "e6b37ce",
      "name": "weaviate-1",
      "stats": {
        "objectCount": 1,
        "shardCount": 2
      },
      "status": "HEALTHY",
      "version": "1.22.1"
    },
    {
      "batchStats": {
        "ratePerSecond": 0
      },
      "gitHash": "e6b37ce",
      "name": "weaviate-2",
      "stats": {
        "objectCount": 1,
        "shardCount": 2
      },
      "status": "HEALTHY",
      "version": "1.22.1"
    }
  ]
}
```

## Cluster metadata

You can retrieve metadata about the Weaviate instance, such as:

- `hostname`: The location of the Weaviate instance.
- `version`: The version of Weaviate.
- `modules`: Module specific info.

### Example

**Python**

```py
import weaviate

client = weaviate.connect_to_local()

meta_info = client.get_meta()
print(meta_info)

client.close()
```

**JavaScript/TypeScript**

```js
import weaviate from '@weaviate/node';

const client = await weaviate.connectToLocal()
const response = await client.getMeta()

console.log(response)
```

**Go (v5)**

```go
package main

import (
  "context"
  "fmt"

  "github.com/weaviate/weaviate-go-client/v5/weaviate"
)

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client, err := weaviate.NewClient(cfg)
  if err != nil {
    panic(err)
  }

  meta, err := client.Misc().MetaGetter().Do(context.Background())

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", meta)
}
```

**Curl**

```bash
curl http://localhost:8080/v1/meta
```

returns:

```json
{
  "hostname": "http://[::]:8080",
  "modules": {
    "text2vec-contextionary": {
      "version": "en0.16.0-v0.4.21",
      "wordCount": 818072
    }
  },
  "version": "1.0.0"
}
```