---
title: "Manage tenant states & temperature"
description: "Manage tenant states in Weaviate to support multitenancy and secure data separation."
url: https://docs.weaviate.io/weaviate/manage-collections/tenant-states
---

# Manage tenant states & temperature

![Storage Tiers](https://docs.weaviate.io/assets/images/storage-tiers-42d32dfd416335c0a1ff0ffb257d978b.jpg)

Storage resources are grouped into tiers. Each tier has different performance characteristics and costs:

| Tier | Location | Speed | Cost |
| - | - | - | - |
| Hot | RAM | Fastest access | Most expensive |
| Warm | Disk | Medium speed | Medium price |
| Cold | Cloud Storage | Slowest access | Least expensive |

The pricing difference between Hot and Cold tiers is significant. Cloud storage is several orders of magnitude cheaper than RAM.

In multi-tenant collections, you can change tenant states (`Active`, `Inactive`, `Offloaded`) to move data between storage tiers. This allows granular trade-offs between cost, resource availability, and readiness.

**Manage vector index resource temperature**

The vector index type affects its default resource type.

- [`HNSW` index (default)](https://docs.weaviate.io/weaviate/config-refs/indexing/vector-index#hnsw-index) - uses the vector index in RAM, a **Hot** resource.
- [`Flat` index](https://docs.weaviate.io/weaviate/config-refs/indexing/vector-index#flat-index) - uses the vector index on disk, a **Warm** resource.
- [`Dynamic` index](https://docs.weaviate.io/weaviate/config-refs/indexing/vector-index#dynamic-index) - starts as a flat index (using a **Warm** resource), then switches to an HNSW index (a **Hot** resource) at a predetermined threshold.

## Tenant States Overview

There are three tenant states: `Active`, `Inactive` and `Offloaded`.

| Tenant state | CRUD & Queries | Vector Index | Inverted Index | Object Data | Time to Activate | Description |
| - | - | - | - | - | - | - |
| Active (default) | **Yes** | Hot/Warm | Warm | Warm | None | Tenant is available for use |
| Inactive | **No** | Warm | Warm | Warm | Fast | Tenant is locally stored but not available for use |
| Offloaded | **No** | Cold | Cold | Cold | Slow | Tenant is stored in cloud storage and not available for use |

> [!TIP]
>
> **Tenant state and consistency**
>
> Tenant states are eventually consistent. [Read more](https://docs.weaviate.io/weaviate/concepts/replication-architecture/consistency#tenant-states-and-data-objects)

### Active

An `Active` tenant is available for queries and CRUD operations. Depending on the [vector index type](https://docs.weaviate.io/weaviate/starter-guides/managing-resources#vector-index-types) it uses either **hot** or **warm** resources.

The tenant's object data and inverted index are stored on disk, using `warm` resources.

![Active Tenant resources](https://docs.weaviate.io/assets/images/active-tenants-658dde3f9e05fa5ebdc24187e0f15b2c.jpg)

### Inactive

An `Inactive` tenant is not available for queries nor CRUD operations.

The tenant's object data, vector index and inverted index are stored on disk, using `warm` resources. This can lower Weaviate's memory requirements compared to active tenants that use `hot` resources.

Since the tenant is stored locally, inactive tenants can be activated quickly.

![Inactive Tenant resources](https://docs.weaviate.io/assets/images/inactive-tenants-79dcc442d93ddac3fdca67df83fcbee4.jpg)

### Offloaded

> [!NOTE]
>
> **Offloading: AWS S3 only**
>
> As of Weaviate `v1.26.0`, tenants can only be offloaded to cold storage in AWS S3. Additional storage options may be added in future releases.
>
> To offload a tenant, use the `offload-s3` module.

An `offloaded` tenant is not available for queries or CRUD operations.

The tenant's object data, vector index and inverted index are stored on the cloud, using `cold` resources. Since the tenant is stored remotely, there is a delay when activating an offloaded tenant.

![Offloaded Tenant resources](https://docs.weaviate.io/assets/images/offloaded-tenants-762fbe0ae29452b2a8835fd445de12ed.jpg)

## Activate tenant

To activate an `INACTIVE` tenant from disk, or to onload and activate an `OFFLOADED` tenant from cloud, call:

**Python**

```py
from weaviate.classes.tenants import Tenant, TenantActivityStatus

multi_collection = client.collections.use("MultiTenancyCollection")
multi_collection.tenants.update(tenants=[
    Tenant(
        name="tenantA",
        activity_status=TenantActivityStatus.ACTIVE
    )
])
```

**JavaScript/TypeScript**

```ts
  const multiCollection = client.collections.use(collectionName)

  await multiCollection.tenants.update({
    name: 'tenantA',
    activityStatus: 'ACTIVE'
  })
```

**Java**

```java
String tenantName = "tenantA";
CollectionHandle<Map<String, Object>> collection =
    client.collections.use(collectionName);
collection.tenants.activate(tenantName);
```

**C#**

```csharp
string[] tenantName = ["tenantA"];
await collection.Tenants.Activate(tenantName);
```

## Deactivate tenant

To deactivate an `ACTIVE` tenant, or to onload an `OFFLOADED` tenant from cloud (without activating it), call:

**Python**

```py
from weaviate.classes.tenants import Tenant, TenantActivityStatus

multi_collection = client.collections.use("MultiTenancyCollection")
multi_collection.tenants.update(tenants=[
    Tenant(
        name="tenantA",
        activity_status=TenantActivityStatus.INACTIVE
    )
])
```

**JavaScript/TypeScript**

```ts
  const multiCollection = client.collections.use(collectionName)

  await multiCollection.tenants.update({
    name: 'tenantA',
    activityStatus: 'INACTIVE'
  })
```

**Java**

```java
String tenantName = "tenantA";
CollectionHandle<Map<String, Object>> collection =
    client.collections.use(collectionName);
collection.tenants.deactivate(tenantName);
```

**C#**

```csharp
string[] tenantName = ["tenantA"];
await collection.Tenants.Deactivate(tenantName);
```

## Offload tenant

To offload an `ACTIVE` or `INACTIVE` tenant to cloud, call:

**Python**

```py
from weaviate.classes.tenants import Tenant, TenantActivityStatus

multi_collection = client.collections.use("MultiTenancyCollection")
multi_collection.tenants.update(tenants=[
    Tenant(
        name="tenantA",
        activity_status=TenantActivityStatus.OFFLOADED
    )
])
```

**JavaScript/TypeScript**

```ts
  const multiCollection = client.collections.use(collectionName)

  await multiCollection.tenants.update({
    name: 'tenantA',
    activityStatus: 'OFFLOADED'
  })
```

**Java**

```java
String tenantName = "tenantA";
CollectionHandle<Map<String, Object>> collection =
    client.collections.use(collectionName);
collection.tenants.offload(tenantName);
```

**C#**

```csharp
await collection.Tenants.Offload(new[] { "tenantA" });
```

> [!WARNING]
>
> **Requires Offload Module**
>
> Tenant offloading requires an Offload module.
>
> To enable tenant offloading, see the [modules page](https://docs.weaviate.io/weaviate/configuration/modules#tenant-offload-modules)

## Automatically activate tenants

Enable this to automatically activate `INACTIVE` or `OFFLOADED` tenants if a search, read, update, or delete operation is performed on them.

Activation is the only automatic state change. Weaviate never deactivates or offloads a tenant on its own: there is no idle timeout, no usage-based policy, and no background process that moves a tenant to `INACTIVE` or `OFFLOADED`. A tenant stays `ACTIVE`, and keeps using its resources, until you change its state.

To reclaim resources on a schedule, run your own job. A common pattern is a daily job that lists the collection's tenants, selects the ones your application has not used within your chosen window, and then calls [Deactivate tenant](https://docs.weaviate.io/weaviate/manage-collections/tenant-states#deactivate-tenant) or [Offload tenant](https://docs.weaviate.io/weaviate/manage-collections/tenant-states#offload-tenant) for them in one batched update. Track last use in your own application, and pair the job with `autoTenantActivation` so that a tenant that becomes active again is brought back on the next request.

**Python**

```py
from weaviate.classes.config import Configure

multi_collection = client.collections.create(
    name="CollectionWithAutoTenantActivation",
    multi_tenancy_config=Configure.multi_tenancy(
        enabled=True,
        auto_tenant_activation=True  # Enable automatic tenant activation
    )
)
```

**JavaScript/TypeScript**

```ts
  const result = await client.collections.create({
    name: 'CollectionWithAutoTenantActivation',
    multiTenancy: weaviate.configure.multiTenancy({
      enabled: true,
      autoTenantActivation: true
    })
  })
```

**Java**

```java
client.collections.create("MultiTenancyCollection",
    col -> col.multiTenancy(mt -> mt.autoTenantActivation(true)));
```

**C#**

```csharp
await client.Collections.Create(
    new CollectionCreateParams
    {
        Name = "MultiTenancyCollection",
        MultiTenancyConfig = new MultiTenancyConfig
        {
            Enabled = true,
            AutoTenantActivation = true,
        },
    }
);
```
