diff --git a/pom.xml b/pom.xml
index bc4980990..c3175b555 100644
--- a/pom.xml
+++ b/pom.xml
@@ -244,6 +244,7 @@
           <artifactId>maven-surefire-plugin</artifactId>
           <version>2.22.2</version>
           <configuration>
+            <trimStackTrace>false</trimStackTrace>
             <argLine>
               <!--
                 Gson (used for JSON serialization) utilizes reflection and needs to be able to access private fields of
diff --git a/src/it/java/io/weaviate/ConcurrentTest.java b/src/it/java/io/weaviate/ConcurrentTest.java
index f3a70cc37..57584e047 100644
--- a/src/it/java/io/weaviate/ConcurrentTest.java
+++ b/src/it/java/io/weaviate/ConcurrentTest.java
@@ -2,8 +2,14 @@
 
 import java.util.Random;
 import java.util.UUID;
+import java.util.concurrent.Callable;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
 
 import org.apache.commons.lang3.RandomStringUtils;
+import org.assertj.core.api.Assertions;
 import org.junit.Rule;
 import org.junit.rules.TestName;
 
@@ -62,4 +68,46 @@ protected static float[] randomVector(int length, float origin, float bound) {
     }
     return vector;
   }
+
+  /**
+   * Check that a condition is eventually met.
+   *
+   * @param cond           Arbitrary code that evaluates the test condition..
+   * @param intervalMillis Polling interval.
+   * @param timeoutSeconds Maximum waiting time.
+   * @param message        Optional failure message.
+   *
+   * @throws AssertionError   if the condition does not evaluate to true
+   *                          within {@code timeoutSeconds} or a thread
+   *                          was interrupted in the meantime.
+   * @throws RuntimeException if an exception occurred when envalating condition.
+   */
+  public static void eventually(Callable<Boolean> cond, int intervalMillis, int timeoutSeconds, String... message) {
+    var check = CompletableFuture.runAsync(() -> {
+      try {
+        while (!Thread.currentThread().isInterrupted() && !cond.call()) {
+          try {
+            Thread.sleep(intervalMillis);
+          } catch (InterruptedException ex) {
+            Thread.currentThread().interrupt();
+          }
+        }
+      } catch (Exception e) {
+        // Propagate to callee
+        throw new RuntimeException(e);
+      }
+    });
+
+    try {
+      check.get(timeoutSeconds, TimeUnit.SECONDS);
+    } catch (TimeoutException ex) {
+      check.cancel(true);
+      Assertions.fail(message.length >= 0 ? message[0] : null, ex);
+    } catch (InterruptedException ex) {
+      Thread.currentThread().interrupt();
+      Assertions.fail(ex);
+    } catch (ExecutionException ex) {
+      throw new RuntimeException(ex);
+    }
+  }
 }
diff --git a/src/it/java/io/weaviate/containers/Container.java b/src/it/java/io/weaviate/containers/Container.java
index 4a95b4044..cca0bcc3e 100644
--- a/src/it/java/io/weaviate/containers/Container.java
+++ b/src/it/java/io/weaviate/containers/Container.java
@@ -16,6 +16,7 @@ public class Container {
   public static final Weaviate WEAVIATE = Weaviate.createDefault();
   public static final Contextionary CONTEXTIONARY = Contextionary.createDefault();
   public static final Img2VecNeural IMG2VEC_NEURAL = Img2VecNeural.createDefault();
+  public static final MinIo MINIO = MinIo.createDefault();
 
   static {
     startAll();
diff --git a/src/it/java/io/weaviate/containers/MinIo.java b/src/it/java/io/weaviate/containers/MinIo.java
new file mode 100644
index 000000000..451d7ac9c
--- /dev/null
+++ b/src/it/java/io/weaviate/containers/MinIo.java
@@ -0,0 +1,20 @@
+package io.weaviate.containers;
+
+import org.testcontainers.containers.MinIOContainer;
+
+public class MinIo extends MinIOContainer {
+  private static final String DOCKER_IMAGE = "minio/minio";
+  public static final String ACCESS_KEY = "minioadmin";
+  public static final String SECRET_KEY = "minioadmin";
+
+  static MinIo createDefault() {
+    return new MinIo();
+  }
+
+  private MinIo() {
+    super(DOCKER_IMAGE);
+    withUserName(ACCESS_KEY);
+    withPassword(SECRET_KEY);
+    withCreateContainerCmdModifier(cmd -> cmd.withHostName("minio"));
+  }
+}
diff --git a/src/it/java/io/weaviate/containers/Weaviate.java b/src/it/java/io/weaviate/containers/Weaviate.java
index d08d8a202..745e0c626 100644
--- a/src/it/java/io/weaviate/containers/Weaviate.java
+++ b/src/it/java/io/weaviate/containers/Weaviate.java
@@ -89,6 +89,15 @@ public Builder withImageInference(String url, String module) {
       return this;
     }
 
+    public Builder withOffloadS3(String accessKey, String secretKey) {
+      addModules("offload-s3");
+      environment.put("OFFLOAD_S3_ENDPOINT", "http://minio:9000");
+      environment.put("OFFLOAD_S3_BUCKET_AUTO_CREATE", "true");
+      environment.put("AWS_ACCESS_KEY_ID", accessKey);
+      environment.put("AWS_SECRET_KEY", secretKey);
+      return this;
+    }
+
     public Builder enableTelemetry(boolean enable) {
       telemetry = enable;
       return this;
diff --git a/src/it/java/io/weaviate/integration/TenantsITest.java b/src/it/java/io/weaviate/integration/TenantsITest.java
new file mode 100644
index 000000000..7c17cf54b
--- /dev/null
+++ b/src/it/java/io/weaviate/integration/TenantsITest.java
@@ -0,0 +1,74 @@
+package io.weaviate.integration;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+
+import io.weaviate.ConcurrentTest;
+import io.weaviate.client6.v1.api.WeaviateClient;
+import io.weaviate.client6.v1.api.collections.tenants.Tenant;
+import io.weaviate.containers.Container;
+import io.weaviate.containers.Container.ContainerGroup;
+import io.weaviate.containers.MinIo;
+import io.weaviate.containers.Weaviate;
+
+public class TenantsITest extends ConcurrentTest {
+  private static final ContainerGroup compose = Container.compose(
+      Weaviate.custom()
+          .withOffloadS3(MinIo.ACCESS_KEY, MinIo.SECRET_KEY)
+          .build(),
+      Container.MINIO);
+
+  private static WeaviateClient client = compose.getClient();
+
+  @Test
+  public void test_tenantLifecycle() throws Exception {
+    var nsThings = ns("Things");
+
+    client.collections.create(
+        nsThings, c -> c
+            .multiTenancy(mt -> mt
+                .autoTenantCreation(false)
+                .autoTenantActivation(false)));
+
+    var things = client.collections.use(nsThings);
+
+    // No tenants at first
+    Assertions.assertThat(things.tenants.list()).as("no tenants initially").isEmpty();
+
+    var allison = Tenant.active("active-allison");
+    var isaac = Tenant.inactive("inactive-isaac");
+    var owen = Tenant.inactive("offloaded-owen");
+
+    things.tenants.create(allison, isaac, owen);
+
+    // Collection has 2 tenants creted just now.
+    Assertions.assertThat(things.tenants.list()).as("list created tenants").hasSize(3);
+    Assertions.assertThat(things.tenants.exists(allison.name()))
+        .describedAs("%s exists", allison.name()).isTrue();
+    Assertions.assertThat(things.tenants.exists(isaac.name()))
+        .describedAs("%s exists", isaac.name()).isTrue();
+    Assertions.assertThat(things.tenants.exists(owen.name()))
+        .describedAs("%s exists", owen.name()).isTrue();
+
+    things.tenants.activate(isaac.name());
+    eventually(() -> things.tenants.get(isaac.name()).get().isActive(),
+        200, 2, isaac.name() + " not activated");
+
+    things.tenants.deactivate(allison.name());
+    eventually(() -> things.tenants.get(allison.name()).get().isInactive(),
+        200, 2, allison.name() + " not deactivated");
+
+    things.tenants.offload(owen.name());
+    eventually(() -> things.tenants.get(owen.name()).get().isOffloaded(),
+        200, 2, owen.name() + " not offloaded");
+
+    things.tenants.delete(allison.name(), isaac.name(), owen.name());
+    Assertions.assertThat(things.tenants.list()).as("no tenants after deletion").isEmpty();
+    Assertions.assertThat(things.tenants.exists(allison.name()))
+        .describedAs("%s not exists", allison.name()).isFalse();
+    Assertions.assertThat(things.tenants.exists(isaac.name()))
+        .describedAs("%s not exists", isaac.name()).isFalse();
+    Assertions.assertThat(things.tenants.exists(owen.name()))
+        .describedAs("%s not exists", owen.name()).isFalse();
+  }
+}
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandle.java b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandle.java
index fb262cbc2..3a1b35038 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandle.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandle.java
@@ -7,34 +7,54 @@
 import io.weaviate.client6.v1.api.collections.config.WeaviateConfigClient;
 import io.weaviate.client6.v1.api.collections.data.WeaviateDataClient;
 import io.weaviate.client6.v1.api.collections.pagination.Paginator;
+import io.weaviate.client6.v1.api.collections.query.ConsistencyLevel;
 import io.weaviate.client6.v1.api.collections.query.WeaviateQueryClient;
+import io.weaviate.client6.v1.api.collections.tenants.WeaviateTenantsClient;
 import io.weaviate.client6.v1.internal.ObjectBuilder;
 import io.weaviate.client6.v1.internal.grpc.GrpcTransport;
 import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
 import io.weaviate.client6.v1.internal.rest.RestTransport;
 
-public class CollectionHandle<T> {
+public class CollectionHandle<PropertiesT> {
   public final WeaviateConfigClient config;
-  public final WeaviateDataClient<T> data;
-  public final WeaviateQueryClient<T> query;
+  public final WeaviateDataClient<PropertiesT> data;
+  public final WeaviateQueryClient<PropertiesT> query;
   public final WeaviateAggregateClient aggregate;
+  public final WeaviateTenantsClient tenants;
+
+  private final CollectionHandleDefaults defaults;
 
   public CollectionHandle(
       RestTransport restTransport,
       GrpcTransport grpcTransport,
-      CollectionDescriptor<T> collectionDescriptor) {
+      CollectionDescriptor<PropertiesT> collection,
+      CollectionHandleDefaults defaults) {
+    this.config = new WeaviateConfigClient(collection, restTransport, grpcTransport, defaults);
+    this.aggregate = new WeaviateAggregateClient(collection, grpcTransport, defaults);
+    this.query = new WeaviateQueryClient<>(collection, grpcTransport, defaults);
+    this.data = new WeaviateDataClient<>(collection, restTransport, grpcTransport, defaults);
+    this.defaults = defaults;
+
+    this.tenants = new WeaviateTenantsClient(collection, restTransport, grpcTransport);
+  }
+
+  /** Copy constructor that sets new defaults. */
+  private CollectionHandle(CollectionHandle<PropertiesT> c, CollectionHandleDefaults defaults) {
+    this.config = new WeaviateConfigClient(c.config, defaults);
+    this.aggregate = new WeaviateAggregateClient(c.aggregate, defaults);
+    this.query = new WeaviateQueryClient<>(c.query, defaults);
+    this.data = new WeaviateDataClient<>(c.data, defaults);
+    this.defaults = defaults;
 
-    this.config = new WeaviateConfigClient(collectionDescriptor, restTransport, grpcTransport);
-    this.data = new WeaviateDataClient<>(collectionDescriptor, restTransport, grpcTransport);
-    this.query = new WeaviateQueryClient<>(collectionDescriptor, grpcTransport);
-    this.aggregate = new WeaviateAggregateClient(collectionDescriptor, grpcTransport);
+    this.tenants = c.tenants;
   }
 
-  public Paginator<T> paginate() {
+  public Paginator<PropertiesT> paginate() {
     return Paginator.of(this.query);
   }
 
-  public Paginator<T> paginate(Function<Paginator.Builder<T>, ObjectBuilder<Paginator<T>>> fn) {
+  public Paginator<PropertiesT> paginate(
+      Function<Paginator.Builder<PropertiesT>, ObjectBuilder<Paginator<PropertiesT>>> fn) {
     return Paginator.of(this.query, fn);
   }
 
@@ -57,4 +77,25 @@ public Paginator<T> paginate(Function<Paginator.Builder<T>, ObjectBuilder<Pagina
   public long size() {
     return this.aggregate.overAll(all -> all.includeTotalCount(true)).totalCount();
   }
+
+  public ConsistencyLevel consistencyLevel() {
+    return defaults.consistencyLevel();
+  }
+
+  public CollectionHandle<PropertiesT> withConsistencyLevel(ConsistencyLevel consistencyLevel) {
+    return new CollectionHandle<>(this, CollectionHandleDefaults.of(with -> with.consistencyLevel(consistencyLevel)));
+  }
+
+  public String tenant() {
+    return defaults.tenant();
+  }
+
+  public CollectionHandle<PropertiesT> withTenant(String tenant) {
+    return new CollectionHandle<>(this, CollectionHandleDefaults.of(with -> with.tenant(tenant)));
+  }
+
+  public CollectionHandle<PropertiesT> withDefaults(
+      Function<CollectionHandleDefaults.Builder, ObjectBuilder<CollectionHandleDefaults>> fn) {
+    return new CollectionHandle<>(this, CollectionHandleDefaults.of(fn));
+  }
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleAsync.java
index 9a646d518..1fdb73a35 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleAsync.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleAsync.java
@@ -9,7 +9,9 @@
 import io.weaviate.client6.v1.api.collections.config.WeaviateConfigClientAsync;
 import io.weaviate.client6.v1.api.collections.data.WeaviateDataClientAsync;
 import io.weaviate.client6.v1.api.collections.pagination.AsyncPaginator;
+import io.weaviate.client6.v1.api.collections.query.ConsistencyLevel;
 import io.weaviate.client6.v1.api.collections.query.WeaviateQueryClientAsync;
+import io.weaviate.client6.v1.api.collections.tenants.WeaviateTenantsClientAsync;
 import io.weaviate.client6.v1.internal.ObjectBuilder;
 import io.weaviate.client6.v1.internal.grpc.GrpcTransport;
 import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
@@ -20,16 +22,34 @@ public class CollectionHandleAsync<PropertiesT> {
   public final WeaviateDataClientAsync<PropertiesT> data;
   public final WeaviateQueryClientAsync<PropertiesT> query;
   public final WeaviateAggregateClientAsync aggregate;
+  public final WeaviateTenantsClientAsync tenants;
+
+  private final CollectionHandleDefaults defaults;
 
   public CollectionHandleAsync(
       RestTransport restTransport,
       GrpcTransport grpcTransport,
-      CollectionDescriptor<PropertiesT> collectionDescriptor) {
+      CollectionDescriptor<PropertiesT> collection,
+      CollectionHandleDefaults defaults) {
+
+    this.config = new WeaviateConfigClientAsync(collection, restTransport, grpcTransport, defaults);
+    this.aggregate = new WeaviateAggregateClientAsync(collection, grpcTransport, defaults);
+    this.query = new WeaviateQueryClientAsync<>(collection, grpcTransport, defaults);
+    this.data = new WeaviateDataClientAsync<>(collection, restTransport, grpcTransport, defaults);
+    this.defaults = defaults;
+
+    this.tenants = new WeaviateTenantsClientAsync(collection, restTransport, grpcTransport);
+  }
 
-    this.config = new WeaviateConfigClientAsync(collectionDescriptor, restTransport, grpcTransport);
-    this.data = new WeaviateDataClientAsync<>(collectionDescriptor, restTransport, grpcTransport);
-    this.query = new WeaviateQueryClientAsync<>(collectionDescriptor, grpcTransport);
-    this.aggregate = new WeaviateAggregateClientAsync(collectionDescriptor, grpcTransport);
+  /** Copy constructor that sets new defaults. */
+  private CollectionHandleAsync(CollectionHandleAsync<PropertiesT> c, CollectionHandleDefaults defaults) {
+    this.config = new WeaviateConfigClientAsync(c.config, defaults);
+    this.aggregate = new WeaviateAggregateClientAsync(c.aggregate, defaults);
+    this.query = new WeaviateQueryClientAsync<>(c.query, defaults);
+    this.data = new WeaviateDataClientAsync<>(c.data, defaults);
+    this.defaults = defaults;
+
+    this.tenants = c.tenants;
   }
 
   public AsyncPaginator<PropertiesT> paginate() {
@@ -64,4 +84,26 @@ public CompletableFuture<Long> size() {
     return this.aggregate.overAll(all -> all.includeTotalCount(true))
         .thenApply(AggregateResponse::totalCount);
   }
+
+  public ConsistencyLevel consistencyLevel() {
+    return defaults.consistencyLevel();
+  }
+
+  public CollectionHandleAsync<PropertiesT> withConsistencyLevel(ConsistencyLevel consistencyLevel) {
+    return new CollectionHandleAsync<>(this, CollectionHandleDefaults.of(
+        def -> def.consistencyLevel(consistencyLevel)));
+  }
+
+  public String tenant() {
+    return defaults.tenant();
+  }
+
+  public CollectionHandleAsync<PropertiesT> withTenant(String tenant) {
+    return new CollectionHandleAsync<>(this, CollectionHandleDefaults.of(with -> with.tenant(tenant)));
+  }
+
+  public CollectionHandleAsync<PropertiesT> withDefaults(
+      Function<CollectionHandleDefaults.Builder, ObjectBuilder<CollectionHandleDefaults>> fn) {
+    return new CollectionHandleAsync<>(this, CollectionHandleDefaults.of(fn));
+  }
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleDefaults.java b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleDefaults.java
new file mode 100644
index 000000000..7ce9711ba
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/CollectionHandleDefaults.java
@@ -0,0 +1,70 @@
+package io.weaviate.client6.v1.api.collections;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Function;
+
+import io.weaviate.client6.v1.api.collections.query.ConsistencyLevel;
+import io.weaviate.client6.v1.internal.ObjectBuilder;
+
+public record CollectionHandleDefaults(ConsistencyLevel consistencyLevel, String tenant) {
+  /**
+   * Set default values for query / aggregation requests.
+   *
+   * @return CollectionHandleDefaults derived from applying {@code fn} to
+   *         {@link Builder}.
+   */
+  public static CollectionHandleDefaults of(Function<Builder, ObjectBuilder<CollectionHandleDefaults>> fn) {
+    return fn.apply(new Builder()).build();
+  }
+
+  /**
+   * Empty collection defaults.
+   *
+   * @return A tucked builder that does not leaves all defaults unset.
+   */
+  public static Function<Builder, ObjectBuilder<CollectionHandleDefaults>> none() {
+    return ObjectBuilder.identity();
+  }
+
+  public CollectionHandleDefaults(Builder builder) {
+    this(builder.consistencyLevel, builder.tenant);
+  }
+
+  public static final class Builder implements ObjectBuilder<CollectionHandleDefaults> {
+    private ConsistencyLevel consistencyLevel;
+    private String tenant;
+
+    /** Set default consistency level for this collection handle. */
+    public Builder consistencyLevel(ConsistencyLevel consistencyLevel) {
+      this.consistencyLevel = consistencyLevel;
+      return this;
+    }
+
+    /** Set default tenant for this collection handle. */
+    public Builder tenant(String tenant) {
+      this.tenant = tenant;
+      return this;
+    }
+
+    @Override
+    public CollectionHandleDefaults build() {
+      return new CollectionHandleDefaults(this);
+    }
+  }
+
+  public Map<String, Object> queryParameters() {
+    if (consistencyLevel == null && tenant == null) {
+      return Collections.emptyMap();
+    }
+    var query = new HashMap<String, Object>();
+    if (consistencyLevel != null) {
+      query.put("consistency_level", consistencyLevel);
+    }
+    if (tenant != null) {
+      query.put("tenant", tenant);
+    }
+    return query;
+  }
+}
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/MultiTenancy.java b/src/main/java/io/weaviate/client6/v1/api/collections/MultiTenancy.java
index 8365c95b7..c02d42539 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/MultiTenancy.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/MultiTenancy.java
@@ -7,8 +7,9 @@
 import io.weaviate.client6.v1.internal.ObjectBuilder;
 
 public record MultiTenancy(
+    @SerializedName("enabled") Boolean enabled,
     @SerializedName("autoTenantCreation") Boolean createAutomatically,
-    @SerializedName("autoTenantActivate") Boolean activateAutomatically) {
+    @SerializedName("autoTenantActivation") Boolean activateAutomatically) {
 
   public static MultiTenancy of(Function<Builder, ObjectBuilder<MultiTenancy>> fn) {
     return fn.apply(new Builder()).build();
@@ -16,21 +17,28 @@ public static MultiTenancy of(Function<Builder, ObjectBuilder<MultiTenancy>> fn)
 
   public MultiTenancy(Builder builder) {
     this(
+        builder.enabled,
         builder.createAutomatically,
         builder.activateAutomatically);
   }
 
   public static class Builder implements ObjectBuilder<MultiTenancy> {
+    private Boolean enabled = true;
     private Boolean createAutomatically;
     private Boolean activateAutomatically;
 
-    public Builder createAutomatically(boolean createAutomatically) {
-      this.createAutomatically = createAutomatically;
+    public Builder enabled(boolean enabled) {
+      this.enabled = enabled;
       return this;
     }
 
-    public Builder activateAutomatically(boolean activateAutomatically) {
-      this.activateAutomatically = activateAutomatically;
+    public Builder autoTenantCreation(boolean enabled) {
+      this.createAutomatically = enabled;
+      return this;
+    }
+
+    public Builder autoTenantActivation(boolean enabled) {
+      this.activateAutomatically = enabled;
       return this;
     }
 
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/Vectorizer.java b/src/main/java/io/weaviate/client6/v1/api/collections/Vectorizer.java
index b5b6c68bb..b0cc27d2e 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/Vectorizer.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/Vectorizer.java
@@ -3,7 +3,6 @@
 import java.io.IOException;
 import java.util.EnumMap;
 import java.util.Map;
-import java.util.function.Function;
 
 import com.google.gson.Gson;
 import com.google.gson.JsonObject;
@@ -20,7 +19,6 @@
 import io.weaviate.client6.v1.api.collections.vectorizers.NoneVectorizer;
 import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecContextionaryVectorizer;
 import io.weaviate.client6.v1.api.collections.vectorizers.Text2VecWeaviateVectorizer;
-import io.weaviate.client6.v1.internal.ObjectBuilder;
 import io.weaviate.client6.v1.internal.json.JsonEnum;
 
 public interface Vectorizer {
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClient.java
index d8c175692..f71d7e9e9 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClient.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClient.java
@@ -29,7 +29,24 @@ public WeaviateCollectionsClient(RestTransport restTransport, GrpcTransport grpc
    *         properties.
    */
   public CollectionHandle<Map<String, Object>> use(String collectionName) {
-    return new CollectionHandle<>(restTransport, grpcTransport, CollectionDescriptor.ofMap(collectionName));
+    return use(collectionName, CollectionHandleDefaults.none());
+  }
+
+  /**
+   * Obtain a handle to send requests to a particular collection.
+   * The returned object is thread-safe.
+   *
+   * @return a handle for a collection with {@code Map<String, Object>}
+   *         properties.
+   */
+  public CollectionHandle<Map<String, Object>> use(
+      String collectionName,
+      Function<CollectionHandleDefaults.Builder, ObjectBuilder<CollectionHandleDefaults>> fn) {
+    return new CollectionHandle<>(
+        restTransport,
+        grpcTransport,
+        CollectionDescriptor.ofMap(collectionName),
+        CollectionHandleDefaults.of(fn));
   }
 
   /**
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClientAsync.java
index d357d56cc..4fc449cf1 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClientAsync.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateCollectionsClientAsync.java
@@ -22,8 +22,17 @@ public WeaviateCollectionsClientAsync(RestTransport restTransport, GrpcTransport
   }
 
   public CollectionHandleAsync<Map<String, Object>> use(String collectionName) {
-    return new CollectionHandleAsync<>(restTransport, grpcTransport,
-        CollectionDescriptor.ofMap(collectionName));
+    return use(collectionName, CollectionHandleDefaults.none());
+  }
+
+  public CollectionHandleAsync<Map<String, Object>> use(
+      String collectionName,
+      Function<CollectionHandleDefaults.Builder, ObjectBuilder<CollectionHandleDefaults>> fn) {
+    return new CollectionHandleAsync<>(
+        restTransport,
+        grpcTransport,
+        CollectionDescriptor.ofMap(collectionName),
+        CollectionHandleDefaults.of(fn));
   }
 
   public CompletableFuture<CollectionConfig> create(String name) {
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateObject.java b/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateObject.java
index 7b1b40306..c96b22916 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateObject.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/WeaviateObject.java
@@ -187,7 +187,7 @@ public void write(JsonWriter out, WeaviateObject<?, ?, ?> value) throws IOExcept
 
           return builder.build();
         }
-      };
+      }.nullSafe();
     }
   }
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AbstractAggregateClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AbstractAggregateClient.java
index 4258947bd..6c6db167b 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AbstractAggregateClient.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AbstractAggregateClient.java
@@ -3,6 +3,7 @@
 import java.util.List;
 import java.util.function.Function;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.api.collections.query.Hybrid;
 import io.weaviate.client6.v1.api.collections.query.NearAudio;
 import io.weaviate.client6.v1.api.collections.query.NearDepth;
@@ -20,10 +21,21 @@
 abstract class AbstractAggregateClient<ResponseT, GroupedResponseT> {
   protected final CollectionDescriptor<?> collection;
   protected final GrpcTransport transport;
+  protected final CollectionHandleDefaults defaults;
 
-  AbstractAggregateClient(CollectionDescriptor<?> collection, GrpcTransport transport) {
+  AbstractAggregateClient(
+      CollectionDescriptor<?> collection,
+      GrpcTransport transport,
+      CollectionHandleDefaults defaults) {
     this.transport = transport;
     this.collection = collection;
+    this.defaults = defaults;
+  }
+
+  AbstractAggregateClient(
+      AbstractAggregateClient<ResponseT, GroupedResponseT> c,
+      CollectionHandleDefaults defaults) {
+    this(c.collection, c.transport, defaults);
   }
 
   protected abstract ResponseT performRequest(Aggregation aggregation);
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateRequest.java
index 79a84505f..c20ab920e 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateRequest.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/AggregateRequest.java
@@ -4,6 +4,7 @@
 import java.util.HashMap;
 import java.util.Map;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.internal.grpc.Rpc;
 import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateBlockingStub;
 import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateFutureStub;
@@ -13,7 +14,8 @@
 public record AggregateRequest(Aggregation aggregation, GroupBy groupBy) {
 
   static <T> Rpc<AggregateRequest, WeaviateProtoAggregate.AggregateRequest, AggregateResponse, WeaviateProtoAggregate.AggregateReply> rpc(
-      CollectionDescriptor<T> collection) {
+      CollectionDescriptor<T> collection,
+      CollectionHandleDefaults defaults) {
     return Rpc.of(
         request -> {
           var message = WeaviateProtoAggregate.AggregateRequest.newBuilder();
@@ -22,6 +24,9 @@ static <T> Rpc<AggregateRequest, WeaviateProtoAggregate.AggregateRequest, Aggreg
           if (request.groupBy != null) {
             request.groupBy.appendTo(message, collection.name());
           }
+          if (defaults.tenant() != null) {
+            message.setTenant(defaults.tenant());
+          }
           return message.build();
         },
         reply -> {
@@ -43,8 +48,9 @@ static <T> Rpc<AggregateRequest, WeaviateProtoAggregate.AggregateRequest, Aggreg
   }
 
   static <T> Rpc<AggregateRequest, WeaviateProtoAggregate.AggregateRequest, AggregateResponseGrouped, WeaviateProtoAggregate.AggregateReply> grouped(
-      CollectionDescriptor<T> collection) {
-    var rpc = rpc(collection);
+      CollectionDescriptor<T> collection,
+      CollectionHandleDefaults defaults) {
+    var rpc = rpc(collection, defaults);
     return Rpc.of(request -> rpc.marshal(request), reply -> {
       var groups = new ArrayList<AggregateResponseGroup<?>>();
       if (reply.hasGroupedResults()) {
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClient.java
index 8f61720f4..ed6b0f234 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClient.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClient.java
@@ -1,21 +1,30 @@
 package io.weaviate.client6.v1.api.collections.aggregate;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.internal.grpc.GrpcTransport;
 import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
 
 public class WeaviateAggregateClient extends AbstractAggregateClient<AggregateResponse, AggregateResponseGrouped> {
 
-  public WeaviateAggregateClient(CollectionDescriptor<?> collection, GrpcTransport transport) {
-    super(collection, transport);
+  public WeaviateAggregateClient(
+      CollectionDescriptor<?> collection,
+      GrpcTransport transport,
+      CollectionHandleDefaults defaults) {
+    super(collection, transport, defaults);
+  }
+
+  /** Copy constructor that sets new defaults. */
+  public WeaviateAggregateClient(WeaviateAggregateClient c, CollectionHandleDefaults defaults) {
+    super(c, defaults);
   }
 
   protected final AggregateResponse performRequest(Aggregation aggregation) {
     var request = new AggregateRequest(aggregation, null);
-    return this.transport.performRequest(request, AggregateRequest.rpc(collection));
+    return this.transport.performRequest(request, AggregateRequest.rpc(collection, defaults));
   }
 
   protected final AggregateResponseGrouped performRequest(Aggregation aggregation, GroupBy groupBy) {
     var request = new AggregateRequest(aggregation, groupBy);
-    return this.transport.performRequest(request, AggregateRequest.grouped(collection));
+    return this.transport.performRequest(request, AggregateRequest.grouped(collection, defaults));
   }
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClientAsync.java
index cdb138867..0b00513b3 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClientAsync.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/aggregate/WeaviateAggregateClientAsync.java
@@ -2,23 +2,32 @@
 
 import java.util.concurrent.CompletableFuture;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.internal.grpc.GrpcTransport;
 import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
 
 public class WeaviateAggregateClientAsync
     extends AbstractAggregateClient<CompletableFuture<AggregateResponse>, CompletableFuture<AggregateResponseGrouped>> {
 
-  public WeaviateAggregateClientAsync(CollectionDescriptor<?> collection, GrpcTransport transport) {
-    super(collection, transport);
+  public WeaviateAggregateClientAsync(
+      CollectionDescriptor<?> collection,
+      GrpcTransport transport,
+      CollectionHandleDefaults defaults) {
+    super(collection, transport, defaults);
+  }
+
+  /** Copy constructor that sets new defaults. */
+  public WeaviateAggregateClientAsync(WeaviateAggregateClientAsync c, CollectionHandleDefaults defaults) {
+    super(c, defaults);
   }
 
   protected final CompletableFuture<AggregateResponse> performRequest(Aggregation aggregation) {
     var request = new AggregateRequest(aggregation, null);
-    return this.transport.performRequestAsync(request, AggregateRequest.rpc(collection));
+    return this.transport.performRequestAsync(request, AggregateRequest.rpc(collection, defaults));
   }
 
   protected final CompletableFuture<AggregateResponseGrouped> performRequest(Aggregation aggregation, GroupBy groupBy) {
     var request = new AggregateRequest(aggregation, groupBy);
-    return this.transport.performRequestAsync(request, AggregateRequest.grouped(collection));
+    return this.transport.performRequestAsync(request, AggregateRequest.grouped(collection, defaults));
   }
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/config/GetShardsRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/config/GetShardsRequest.java
index 7d76a32a6..d04ccfbcf 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/config/GetShardsRequest.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/config/GetShardsRequest.java
@@ -2,20 +2,29 @@
 
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 
 import com.google.gson.reflect.TypeToken;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.internal.json.JSON;
+import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
 import io.weaviate.client6.v1.internal.rest.Endpoint;
 import io.weaviate.client6.v1.internal.rest.SimpleEndpoint;
 
-public record GetShardsRequest(String collectionName) {
+public record GetShardsRequest() {
 
   @SuppressWarnings("unchecked")
-  public static final Endpoint<GetShardsRequest, List<Shard>> _ENDPOINT = SimpleEndpoint.noBody(
-      request -> "GET",
-      request -> "/schema/" + request.collectionName + "/shards", // TODO: tenant support
-      request -> Collections.emptyMap(),
-      (statusCode, response) -> (List<Shard>) JSON.deserialize(response, TypeToken.getParameterized(
-          List.class, Shard.class)));
+  public static final Endpoint<Void, List<Shard>> endpoint(
+      CollectionDescriptor<?> collection,
+      CollectionHandleDefaults defaults) {
+    return SimpleEndpoint.noBody(
+        request -> "GET",
+        request -> "/schema/" + collection.name() + "/shards",
+        request -> defaults.tenant() != null
+            ? Map.of("tenant", defaults.tenant())
+            : Collections.emptyMap(),
+        (statusCode, response) -> (List<Shard>) JSON.deserialize(response, TypeToken.getParameterized(
+            List.class, Shard.class)));
+  }
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClient.java
index b2a0fb493..fdc957f01 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClient.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClient.java
@@ -7,6 +7,7 @@
 import java.util.function.Function;
 
 import io.weaviate.client6.v1.api.collections.CollectionConfig;
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.api.collections.Property;
 import io.weaviate.client6.v1.api.collections.WeaviateCollectionsClient;
 import io.weaviate.client6.v1.internal.ObjectBuilder;
@@ -18,14 +19,27 @@ public class WeaviateConfigClient {
   private final RestTransport restTransport;
   private final WeaviateCollectionsClient collectionsClient;
 
-  protected final CollectionDescriptor<?> collection;
+  private final CollectionDescriptor<?> collection;
+  private final CollectionHandleDefaults defaults;
 
-  public WeaviateConfigClient(CollectionDescriptor<?> collection, RestTransport restTransport,
-      GrpcTransport grpcTransport) {
+  public WeaviateConfigClient(
+      CollectionDescriptor<?> collection,
+      RestTransport restTransport,
+      GrpcTransport grpcTransport,
+      CollectionHandleDefaults defaults) {
     this.restTransport = restTransport;
     this.collectionsClient = new WeaviateCollectionsClient(restTransport, grpcTransport);
 
     this.collection = collection;
+    this.defaults = defaults;
+  }
+
+  /** Copy constructor that sets new defaults. */
+  public WeaviateConfigClient(WeaviateConfigClient c, CollectionHandleDefaults defaults) {
+    this.restTransport = c.restTransport;
+    this.collectionsClient = c.collectionsClient;
+    this.collection = c.collection;
+    this.defaults = defaults;
   }
 
   public Optional<CollectionConfig> get() throws IOException {
@@ -49,7 +63,7 @@ public void update(String collectionName,
   }
 
   public List<Shard> getShards() throws IOException {
-    return this.restTransport.performRequest(new GetShardsRequest(collection.name()), GetShardsRequest._ENDPOINT);
+    return this.restTransport.performRequest(null, GetShardsRequest.endpoint(collection, defaults));
   }
 
   public List<Shard> updateShards(ShardStatus status, String... shards) throws IOException {
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClientAsync.java
index a418a47aa..34d6a66a6 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClientAsync.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/config/WeaviateConfigClientAsync.java
@@ -8,6 +8,7 @@
 import java.util.function.Function;
 
 import io.weaviate.client6.v1.api.collections.CollectionConfig;
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.api.collections.Property;
 import io.weaviate.client6.v1.api.collections.WeaviateCollectionsClientAsync;
 import io.weaviate.client6.v1.internal.ObjectBuilder;
@@ -19,22 +20,35 @@ public class WeaviateConfigClientAsync {
   private final RestTransport restTransport;
   private final WeaviateCollectionsClientAsync collectionsClient;
 
-  protected final CollectionDescriptor<?> collectionDescriptor;
+  private final CollectionDescriptor<?> collection;
+  private final CollectionHandleDefaults defaults;
 
-  public WeaviateConfigClientAsync(CollectionDescriptor<?> collection, RestTransport restTransport,
-      GrpcTransport grpcTransport) {
+  public WeaviateConfigClientAsync(
+      CollectionDescriptor<?> collection,
+      RestTransport restTransport,
+      GrpcTransport grpcTransport,
+      CollectionHandleDefaults defaults) {
     this.restTransport = restTransport;
     this.collectionsClient = new WeaviateCollectionsClientAsync(restTransport, grpcTransport);
 
-    this.collectionDescriptor = collection;
+    this.collection = collection;
+    this.defaults = defaults;
+  }
+
+  /** Copy constructor that sets new defaults. */
+  public WeaviateConfigClientAsync(WeaviateConfigClientAsync c, CollectionHandleDefaults defaults) {
+    this.restTransport = c.restTransport;
+    this.collectionsClient = c.collectionsClient;
+    this.collection = c.collection;
+    this.defaults = defaults;
   }
 
   public CompletableFuture<Optional<CollectionConfig>> get() throws IOException {
-    return collectionsClient.getConfig(collectionDescriptor.name());
+    return collectionsClient.getConfig(collection.name());
   }
 
   public CompletableFuture<Void> addProperty(Property property) throws IOException {
-    return this.restTransport.performRequestAsync(new AddPropertyRequest(collectionDescriptor.name(), property),
+    return this.restTransport.performRequestAsync(new AddPropertyRequest(collection.name(), property),
         AddPropertyRequest._ENDPOINT);
   }
 
@@ -52,8 +66,7 @@ public CompletableFuture<Void> update(String collectionName,
   }
 
   public CompletableFuture<List<Shard>> getShards() {
-    return this.restTransport.performRequestAsync(new GetShardsRequest(collectionDescriptor.name()),
-        GetShardsRequest._ENDPOINT);
+    return this.restTransport.performRequestAsync(null, GetShardsRequest.endpoint(collection, defaults));
   }
 
   public CompletableFuture<List<Shard>> updateShards(ShardStatus status, String... shards) throws IOException {
@@ -63,7 +76,7 @@ public CompletableFuture<List<Shard>> updateShards(ShardStatus status, String...
   public CompletableFuture<List<Shard>> updateShards(ShardStatus status, List<String> shards) throws IOException {
     var updates = shards.stream().map(
         shard -> this.restTransport.performRequestAsync(
-            new UpdateShardStatusRequest(collectionDescriptor.name(), shard, status),
+            new UpdateShardStatusRequest(collection.name(), shard, status),
             UpdateShardStatusRequest._ENDPOINT))
         .toArray(CompletableFuture[]::new);
     return CompletableFuture.allOf(updates).thenCompose(__ -> getShards());
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteManyRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteManyRequest.java
index fe4788481..a472b918a 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteManyRequest.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteManyRequest.java
@@ -2,6 +2,7 @@
 
 import java.util.function.Function;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.api.collections.query.Where;
 import io.weaviate.client6.v1.internal.ObjectBuilder;
 import io.weaviate.client6.v1.internal.grpc.ByteStringUtil;
@@ -15,44 +16,50 @@
 public record DeleteManyRequest(Where where, Boolean verbose, Boolean dryRun) {
 
   public static Rpc<DeleteManyRequest, WeaviateProtoBatchDelete.BatchDeleteRequest, DeleteManyResponse, WeaviateProtoBatchDelete.BatchDeleteReply> rpc(
-      CollectionDescriptor<?> collectionDescriptor) {
-    return Rpc
-        .of(
-            request -> {
-              var message = WeaviateProtoBatchDelete.BatchDeleteRequest.newBuilder();
-              message.setCollection(collectionDescriptor.name());
-
-              if (request.verbose != null) {
-                message.setVerbose(request.verbose);
-              }
-              if (request.dryRun != null) {
-                message.setDryRun(request.dryRun);
-              }
-
-              var filters = WeaviateProtoBase.Filters.newBuilder();
-              request.where.appendTo(filters);
-              message.setFilters(filters);
-
-              return message.build();
-            },
-            reply -> {
-              var objects = reply.getObjectsList()
-                  .stream()
-                  .map(obj -> new DeleteManyResponse.DeletedObject(
-                      ByteStringUtil.decodeUuid(obj.getUuid()).toString(),
-                      obj.getSuccessful(),
-                      obj.getError()))
-                  .toList();
-
-              return new DeleteManyResponse(
-                  reply.getTook(),
-                  reply.getFailed(),
-                  reply.getMatches(),
-                  reply.getSuccessful(),
-                  objects);
-            },
-            () -> WeaviateBlockingStub::batchDelete,
-            () -> WeaviateFutureStub::batchDelete);
+      CollectionDescriptor<?> collection,
+      CollectionHandleDefaults defaults) {
+    return Rpc.of(
+        request -> {
+          var message = WeaviateProtoBatchDelete.BatchDeleteRequest.newBuilder();
+          message.setCollection(collection.name());
+
+          if (request.verbose != null) {
+            message.setVerbose(request.verbose);
+          }
+          if (request.dryRun != null) {
+            message.setDryRun(request.dryRun);
+          }
+          if (defaults.tenant() != null) {
+            message.setTenant(defaults.tenant());
+          }
+          if (defaults.consistencyLevel() != null) {
+            defaults.consistencyLevel().appendTo(message);
+          }
+
+          var filters = WeaviateProtoBase.Filters.newBuilder();
+          request.where.appendTo(filters);
+          message.setFilters(filters);
+
+          return message.build();
+        },
+        reply -> {
+          var objects = reply.getObjectsList()
+              .stream()
+              .map(obj -> new DeleteManyResponse.DeletedObject(
+                  ByteStringUtil.decodeUuid(obj.getUuid()).toString(),
+                  obj.getSuccessful(),
+                  obj.getError()))
+              .toList();
+
+          return new DeleteManyResponse(
+              reply.getTook(),
+              reply.getFailed(),
+              reply.getMatches(),
+              reply.getSuccessful(),
+              objects);
+        },
+        () -> WeaviateBlockingStub::batchDelete,
+        () -> WeaviateFutureStub::batchDelete);
   }
 
   public static DeleteManyRequest of(Where where) {
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteObjectRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteObjectRequest.java
index 217a27682..307dfd04f 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteObjectRequest.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/DeleteObjectRequest.java
@@ -1,14 +1,18 @@
 package io.weaviate.client6.v1.api.collections.data;
 
-import java.util.Collections;
-
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
+import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
 import io.weaviate.client6.v1.internal.rest.Endpoint;
 import io.weaviate.client6.v1.internal.rest.SimpleEndpoint;
 
-public record DeleteObjectRequest(String collectionName, String uuid) {
+public record DeleteObjectRequest(String uuid) {
 
-  public static final Endpoint<DeleteObjectRequest, Void> _ENDPOINT = SimpleEndpoint.sideEffect(
-      request -> "DELETE",
-      request -> "/objects/" + request.collectionName + "/" + request.uuid,
-      request -> Collections.emptyMap());
+  public static final Endpoint<DeleteObjectRequest, Void> endpoint(
+      CollectionDescriptor<?> collection,
+      CollectionHandleDefaults defaults) {
+    return SimpleEndpoint.sideEffect(
+        request -> "DELETE",
+        request -> "/objects/" + collection.name() + "/" + request.uuid,
+        request -> defaults.queryParameters());
+  }
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertManyRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertManyRequest.java
index 48c41ebec..261a69064 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertManyRequest.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertManyRequest.java
@@ -6,6 +6,7 @@
 import java.util.UUID;
 import java.util.stream.Collectors;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.api.collections.ObjectMetadata;
 import io.weaviate.client6.v1.api.collections.WeaviateObject;
 import io.weaviate.client6.v1.internal.grpc.ByteStringUtil;
@@ -37,18 +38,23 @@ public static final <T> InsertManyRequest<T> of(T... properties) {
 
   public static <T> Rpc<InsertManyRequest<T>, WeaviateProtoBatch.BatchObjectsRequest, InsertManyResponse, WeaviateProtoBatch.BatchObjectsReply> rpc(
       List<WeaviateObject<T, Reference, ObjectMetadata>> insertObjects,
-      CollectionDescriptor<T> collectionsDescriptor) {
+      CollectionDescriptor<T> collection,
+      CollectionHandleDefaults defaults) {
     return Rpc.of(
         request -> {
           var message = WeaviateProtoBatch.BatchObjectsRequest.newBuilder();
 
           var batch = request.objects.stream().map(obj -> {
             var batchObject = WeaviateProtoBatch.BatchObject.newBuilder();
-            buildObject(batchObject, obj, collectionsDescriptor);
+            buildObject(batchObject, obj, collection, defaults);
             return batchObject.build();
           }).toList();
 
           message.addAllObjects(batch);
+
+          if (defaults.consistencyLevel() != null) {
+            defaults.consistencyLevel().appendTo(message);
+          }
           return message.build();
         },
         response -> {
@@ -85,8 +91,9 @@ public static <T> Rpc<InsertManyRequest<T>, WeaviateProtoBatch.BatchObjectsReque
 
   public static <T> void buildObject(WeaviateProtoBatch.BatchObject.Builder object,
       WeaviateObject<T, Reference, ObjectMetadata> insert,
-      CollectionDescriptor<T> collectionDescriptor) {
-    object.setCollection(collectionDescriptor.name());
+      CollectionDescriptor<T> collection,
+      CollectionHandleDefaults defaults) {
+    object.setCollection(collection.name());
 
     var metadata = insert.metadata();
     if (metadata != null) {
@@ -113,6 +120,9 @@ public static <T> void buildObject(WeaviateProtoBatch.BatchObject.Builder object
             }).toList();
         object.addAllVectors(vectors);
       }
+      if (defaults.tenant() != null) {
+        object.setTenant(defaults.tenant());
+      }
     }
 
     var properties = WeaviateProtoBatch.BatchObject.Properties.newBuilder();
@@ -120,7 +130,7 @@ public static <T> void buildObject(WeaviateProtoBatch.BatchObject.Builder object
     var singleRef = new ArrayList<WeaviateProtoBatch.BatchObject.SingleTargetRefProps>();
     var multiRef = new ArrayList<WeaviateProtoBatch.BatchObject.MultiTargetRefProps>();
 
-    collectionDescriptor
+    collection
         .propertiesReader(insert.properties()).readProperties()
         .entrySet().stream().forEach(entry -> {
           var value = entry.getValue();
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertObjectRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertObjectRequest.java
index b1b460b11..972be0183 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertObjectRequest.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/InsertObjectRequest.java
@@ -1,10 +1,12 @@
 package io.weaviate.client6.v1.api.collections.data;
 
 import java.util.Collections;
+import java.util.Map;
 import java.util.function.Function;
 
 import com.google.gson.reflect.TypeToken;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.api.collections.ObjectMetadata;
 import io.weaviate.client6.v1.api.collections.Vectors;
 import io.weaviate.client6.v1.api.collections.WeaviateObject;
@@ -18,16 +20,21 @@ public record InsertObjectRequest<T>(WeaviateObject<T, Reference, ObjectMetadata
 
   @SuppressWarnings("unchecked")
   public static final <T> Endpoint<InsertObjectRequest<T>, WeaviateObject<T, Object, ObjectMetadata>> endpoint(
-      CollectionDescriptor<T> descriptor) {
+      CollectionDescriptor<T> collection,
+      CollectionHandleDefaults defaults) {
     return new SimpleEndpoint<>(
         request -> "POST",
         request -> "/objects/",
-        request -> Collections.emptyMap(),
-        request -> JSON.serialize(request.object, TypeToken.getParameterized(
-            WeaviateObject.class, descriptor.typeToken().getType(), Reference.class, ObjectMetadata.class)),
+        request -> defaults.consistencyLevel() != null
+            ? Map.of("consistency_level", defaults.consistencyLevel())
+            : Collections.emptyMap(),
+        request -> JSON.serialize(
+            new WriteWeaviateObject<>(request.object, defaults.tenant()),
+            TypeToken.getParameterized(
+                WriteWeaviateObject.class, collection.typeToken().getType())),
         (statusCode, response) -> JSON.deserialize(response,
             (TypeToken<WeaviateObject<T, Object, ObjectMetadata>>) TypeToken.getParameterized(
-                WeaviateObject.class, descriptor.typeToken().getType(), Object.class, ObjectMetadata.class)));
+                WeaviateObject.class, collection.typeToken().getType(), Object.class, ObjectMetadata.class)));
   }
 
   public static <T> InsertObjectRequest<T> of(String collectionName, T properties) {
@@ -72,4 +79,5 @@ public InsertObjectRequest<T> build() {
       return new InsertObjectRequest<>(this);
     }
   }
+
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddManyRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddManyRequest.java
index 0530d23e9..284688daa 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddManyRequest.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddManyRequest.java
@@ -1,9 +1,9 @@
 package io.weaviate.client6.v1.api.collections.data;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.internal.json.JSON;
 import io.weaviate.client6.v1.internal.rest.Endpoint;
 import io.weaviate.client6.v1.internal.rest.SimpleEndpoint;
@@ -11,11 +11,12 @@
 public record ReferenceAddManyRequest(List<BatchReference> references) {
 
   public static final Endpoint<ReferenceAddManyRequest, ReferenceAddManyResponse> endpoint(
-      List<BatchReference> references) {
+      List<BatchReference> references,
+      CollectionHandleDefaults defaults) {
     return new SimpleEndpoint<>(
         request -> "POST",
         request -> "/batch/references",
-        request -> Collections.emptyMap(),
+        request -> defaults.queryParameters(),
         request -> JSON.serialize(request.references),
         (statusCode, response) -> {
           var result = JSON.deserialize(response, ReferenceAddManyResponse.class);
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddRequest.java
index 5da29e0fe..89201f4de 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddRequest.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceAddRequest.java
@@ -1,7 +1,6 @@
 package io.weaviate.client6.v1.api.collections.data;
 
-import java.util.Collections;
-
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.internal.json.JSON;
 import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
 import io.weaviate.client6.v1.internal.rest.Endpoint;
@@ -10,11 +9,13 @@
 public record ReferenceAddRequest(String fromUuid, String fromProperty, Reference reference) {
 
   public static final Endpoint<ReferenceAddRequest, Void> endpoint(
-      CollectionDescriptor<?> descriptor) {
+      CollectionDescriptor<?> descriptor,
+      CollectionHandleDefaults defaults) {
     return SimpleEndpoint.sideEffect(
         request -> "POST",
         request -> "/objects/" + descriptor.name() + "/" + request.fromUuid + "/references/" + request.fromProperty,
-        request -> Collections.emptyMap(),
+        request -> defaults.queryParameters(),
         request -> JSON.serialize(request.reference));
+
   }
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceDeleteRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceDeleteRequest.java
index f7f037e23..fc53457ae 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceDeleteRequest.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceDeleteRequest.java
@@ -1,7 +1,6 @@
 package io.weaviate.client6.v1.api.collections.data;
 
-import java.util.Collections;
-
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.internal.json.JSON;
 import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
 import io.weaviate.client6.v1.internal.rest.Endpoint;
@@ -10,11 +9,12 @@
 public record ReferenceDeleteRequest(String fromUuid, String fromProperty, Reference reference) {
 
   public static final Endpoint<ReferenceDeleteRequest, Void> endpoint(
-      CollectionDescriptor<?> descriptor) {
+      CollectionDescriptor<?> descriptor,
+      CollectionHandleDefaults defaults) {
     return SimpleEndpoint.sideEffect(
         request -> "DELETE",
         request -> "/objects/" + descriptor.name() + "/" + request.fromUuid + "/references/" + request.fromProperty,
-        request -> Collections.emptyMap(),
+        request -> defaults.queryParameters(),
         request -> JSON.serialize(request.reference));
   }
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceReplaceRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceReplaceRequest.java
index 746fe6966..13516d0ac 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceReplaceRequest.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReferenceReplaceRequest.java
@@ -1,8 +1,8 @@
 package io.weaviate.client6.v1.api.collections.data;
 
-import java.util.Collections;
 import java.util.List;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.internal.json.JSON;
 import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
 import io.weaviate.client6.v1.internal.rest.Endpoint;
@@ -11,11 +11,12 @@
 public record ReferenceReplaceRequest(String fromUuid, String fromProperty, Reference reference) {
 
   public static final Endpoint<ReferenceReplaceRequest, Void> endpoint(
-      CollectionDescriptor<?> descriptor) {
+      CollectionDescriptor<?> descriptor,
+      CollectionHandleDefaults defaults) {
     return SimpleEndpoint.sideEffect(
         request -> "PUT",
         request -> "/objects/" + descriptor.name() + "/" + request.fromUuid + "/references/" + request.fromProperty,
-        request -> Collections.emptyMap(),
+        request -> defaults.queryParameters(),
         request -> JSON.serialize(List.of(request.reference)));
   }
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReplaceObjectRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReplaceObjectRequest.java
index 09704839b..e327c4999 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/data/ReplaceObjectRequest.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/ReplaceObjectRequest.java
@@ -1,10 +1,12 @@
 package io.weaviate.client6.v1.api.collections.data;
 
 import java.util.Collections;
+import java.util.Map;
 import java.util.function.Function;
 
 import com.google.gson.reflect.TypeToken;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.api.collections.ObjectMetadata;
 import io.weaviate.client6.v1.api.collections.Vectors;
 import io.weaviate.client6.v1.api.collections.WeaviateObject;
@@ -16,13 +18,17 @@
 
 public record ReplaceObjectRequest<T>(WeaviateObject<T, Reference, ObjectMetadata> object) {
 
-  static final <T> Endpoint<ReplaceObjectRequest<T>, Void> endpoint(CollectionDescriptor<T> collectionDescriptor) {
+  static final <T> Endpoint<ReplaceObjectRequest<T>, Void> endpoint(CollectionDescriptor<T> collection,
+      CollectionHandleDefaults defaults) {
     return SimpleEndpoint.sideEffect(
         request -> "PUT",
-        request -> "/objects/" + collectionDescriptor.name() + "/" + request.object.metadata().uuid(),
-        request -> Collections.emptyMap(),
-        request -> JSON.serialize(request.object, TypeToken.getParameterized(
-            WeaviateObject.class, collectionDescriptor.typeToken().getType(), Reference.class, ObjectMetadata.class)));
+        request -> "/objects/" + collection.name() + "/" + request.object.metadata().uuid(),
+        request -> defaults.consistencyLevel() != null
+            ? Map.of("consistency_level", defaults.consistencyLevel())
+            : Collections.emptyMap(),
+        request -> JSON.serialize(
+            new WriteWeaviateObject<>(request.object, defaults.tenant()),
+            TypeToken.getParameterized(WriteWeaviateObject.class, collection.typeToken().getType())));
   }
 
   public static <T> ReplaceObjectRequest<T> of(String collectionName, String uuid,
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/UpdateObjectRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/UpdateObjectRequest.java
index f1f64022d..f50a76ad2 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/data/UpdateObjectRequest.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/UpdateObjectRequest.java
@@ -1,10 +1,12 @@
 package io.weaviate.client6.v1.api.collections.data;
 
 import java.util.Collections;
+import java.util.Map;
 import java.util.function.Function;
 
 import com.google.gson.reflect.TypeToken;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.api.collections.ObjectMetadata;
 import io.weaviate.client6.v1.api.collections.Vectors;
 import io.weaviate.client6.v1.api.collections.WeaviateObject;
@@ -16,13 +18,17 @@
 
 public record UpdateObjectRequest<T>(WeaviateObject<T, Reference, ObjectMetadata> object) {
 
-  static final <T> Endpoint<UpdateObjectRequest<T>, Void> endpoint(CollectionDescriptor<T> collectionDescriptor) {
+  static final <T> Endpoint<UpdateObjectRequest<T>, Void> endpoint(CollectionDescriptor<T> collection,
+      CollectionHandleDefaults defaults) {
     return SimpleEndpoint.sideEffect(
         request -> "PATCH",
-        request -> "/objects/" + collectionDescriptor.name() + "/" + request.object.metadata().uuid(),
-        request -> Collections.emptyMap(),
-        request -> JSON.serialize(request.object, TypeToken.getParameterized(
-            WeaviateObject.class, collectionDescriptor.typeToken().getType(), Reference.class, ObjectMetadata.class)));
+        request -> "/objects/" + collection.name() + "/" + request.object.metadata().uuid(),
+        request -> defaults.consistencyLevel() != null
+            ? Map.of("consistency_level", defaults.consistencyLevel())
+            : Collections.emptyMap(),
+        request -> JSON.serialize(
+            new WriteWeaviateObject<>(request.object, defaults.tenant()),
+            TypeToken.getParameterized(WriteWeaviateObject.class, collection.typeToken().getType())));
   }
 
   public static <T> UpdateObjectRequest<T> of(String collectionName, String uuid,
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClient.java
index cb0771e0f..1455b8638 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClient.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClient.java
@@ -5,6 +5,7 @@
 import java.util.List;
 import java.util.function.Function;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.api.collections.ObjectMetadata;
 import io.weaviate.client6.v1.api.collections.WeaviateObject;
 import io.weaviate.client6.v1.api.collections.query.WeaviateQueryClient;
@@ -15,96 +16,112 @@
 import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
 import io.weaviate.client6.v1.internal.rest.RestTransport;
 
-public class WeaviateDataClient<T> {
+public class WeaviateDataClient<PropertiesT> {
   private final RestTransport restTransport;
   private final GrpcTransport grpcTransport;
-  private final CollectionDescriptor<T> collectionDescriptor;
+  private final CollectionDescriptor<PropertiesT> collection;
 
-  private final WeaviateQueryClient<T> query;
+  private final WeaviateQueryClient<PropertiesT> query;
+  private final CollectionHandleDefaults defaults;
 
-  public WeaviateDataClient(CollectionDescriptor<T> collectionDescriptor, RestTransport restTransport,
-      GrpcTransport grpcTransport) {
+  public WeaviateDataClient(
+      CollectionDescriptor<PropertiesT> collection,
+      RestTransport restTransport,
+      GrpcTransport grpcTransport,
+      CollectionHandleDefaults defaults) {
     this.restTransport = restTransport;
     this.grpcTransport = grpcTransport;
-    this.collectionDescriptor = collectionDescriptor;
-    this.query = new WeaviateQueryClient<>(collectionDescriptor, grpcTransport);
+    this.collection = collection;
+    this.query = new WeaviateQueryClient<>(collection, grpcTransport, defaults);
+    this.defaults = defaults;
+  }
 
+  /** Copy constructor that updates the {@link #query} to use new defaults. */
+  public WeaviateDataClient(WeaviateDataClient<PropertiesT> c, CollectionHandleDefaults defaults) {
+    this.restTransport = c.restTransport;
+    this.grpcTransport = c.grpcTransport;
+    this.collection = c.collection;
+    this.query = new WeaviateQueryClient<>(collection, grpcTransport, defaults);
+    this.defaults = defaults;
   }
 
-  public WeaviateObject<T, Object, ObjectMetadata> insert(T properties) throws IOException {
-    return insert(InsertObjectRequest.of(collectionDescriptor.name(), properties));
+  public WeaviateObject<PropertiesT, Object, ObjectMetadata> insert(PropertiesT properties) throws IOException {
+    return insert(InsertObjectRequest.of(collection.name(), properties));
   }
 
-  public WeaviateObject<T, Object, ObjectMetadata> insert(T properties,
-      Function<InsertObjectRequest.Builder<T>, ObjectBuilder<InsertObjectRequest<T>>> fn)
+  public WeaviateObject<PropertiesT, Object, ObjectMetadata> insert(PropertiesT properties,
+      Function<InsertObjectRequest.Builder<PropertiesT>, ObjectBuilder<InsertObjectRequest<PropertiesT>>> fn)
       throws IOException {
-    return insert(InsertObjectRequest.of(collectionDescriptor.name(), properties, fn));
+    return insert(InsertObjectRequest.of(collection.name(), properties, fn));
   }
 
   @SafeVarargs
-  public final InsertManyResponse insertMany(T... objects) {
+  public final InsertManyResponse insertMany(PropertiesT... objects) {
     return insertMany(InsertManyRequest.of(objects));
   }
 
-  public InsertManyResponse insertMany(List<WeaviateObject<T, Reference, ObjectMetadata>> objects) {
+  public InsertManyResponse insertMany(List<WeaviateObject<PropertiesT, Reference, ObjectMetadata>> objects) {
     return insertMany(new InsertManyRequest<>(objects));
   }
 
-  public InsertManyResponse insertMany(InsertManyRequest<T> request) {
-    return this.grpcTransport.performRequest(request, InsertManyRequest.rpc(request.objects(), collectionDescriptor));
+  public InsertManyResponse insertMany(InsertManyRequest<PropertiesT> request) {
+    return this.grpcTransport.performRequest(request,
+        InsertManyRequest.rpc(request.objects(), collection, defaults));
   }
 
-  public WeaviateObject<T, Object, ObjectMetadata> insert(InsertObjectRequest<T> request) throws IOException {
-    return this.restTransport.performRequest(request, InsertObjectRequest.endpoint(collectionDescriptor));
+  public WeaviateObject<PropertiesT, Object, ObjectMetadata> insert(InsertObjectRequest<PropertiesT> request)
+      throws IOException {
+    return this.restTransport.performRequest(request, InsertObjectRequest.endpoint(collection, defaults));
   }
 
-  public boolean exists(String uuid) throws IOException {
+  public boolean exists(String uuid) {
     return this.query.byId(uuid).isPresent();
   }
 
-  public void update(String uuid, Function<UpdateObjectRequest.Builder<T>, ObjectBuilder<UpdateObjectRequest<T>>> fn)
+  public void update(String uuid,
+      Function<UpdateObjectRequest.Builder<PropertiesT>, ObjectBuilder<UpdateObjectRequest<PropertiesT>>> fn)
       throws IOException {
-    this.restTransport.performRequest(UpdateObjectRequest.of(collectionDescriptor.name(), uuid, fn),
-        UpdateObjectRequest.endpoint(collectionDescriptor));
+    this.restTransport.performRequest(UpdateObjectRequest.of(collection.name(), uuid, fn),
+        UpdateObjectRequest.endpoint(collection, defaults));
   }
 
-  public void replace(String uuid, Function<ReplaceObjectRequest.Builder<T>, ObjectBuilder<ReplaceObjectRequest<T>>> fn)
+  public void replace(String uuid,
+      Function<ReplaceObjectRequest.Builder<PropertiesT>, ObjectBuilder<ReplaceObjectRequest<PropertiesT>>> fn)
       throws IOException {
-    this.restTransport.performRequest(ReplaceObjectRequest.of(collectionDescriptor.name(), uuid, fn),
-        ReplaceObjectRequest.endpoint(collectionDescriptor));
+    this.restTransport.performRequest(ReplaceObjectRequest.of(collection.name(), uuid, fn),
+        ReplaceObjectRequest.endpoint(collection, defaults));
   }
 
   public void delete(String uuid) throws IOException {
-    this.restTransport.performRequest(new DeleteObjectRequest(collectionDescriptor.name(), uuid),
-        DeleteObjectRequest._ENDPOINT);
+    this.restTransport.performRequest(new DeleteObjectRequest(uuid),
+        DeleteObjectRequest.endpoint(collection, defaults));
   }
 
-  public DeleteManyResponse deleteMany(String... uuids) throws IOException {
+  public DeleteManyResponse deleteMany(String... uuids) {
     var either = Arrays.stream(uuids)
         .map(uuid -> (WhereOperand) Where.uuid().eq(uuid))
         .toList();
     return deleteMany(DeleteManyRequest.of(Where.or(either)));
   }
 
-  public DeleteManyResponse deleteMany(Where where) throws IOException {
+  public DeleteManyResponse deleteMany(Where where) {
     return deleteMany(DeleteManyRequest.of(where));
   }
 
   public DeleteManyResponse deleteMany(Where where,
-      Function<DeleteManyRequest.Builder, ObjectBuilder<DeleteManyRequest>> fn)
-      throws IOException {
+      Function<DeleteManyRequest.Builder, ObjectBuilder<DeleteManyRequest>> fn) {
     return deleteMany(DeleteManyRequest.of(where, fn));
   }
 
-  public DeleteManyResponse deleteMany(DeleteManyRequest request) throws IOException {
-    return this.grpcTransport.performRequest(request, DeleteManyRequest.rpc(collectionDescriptor));
+  public DeleteManyResponse deleteMany(DeleteManyRequest request) {
+    return this.grpcTransport.performRequest(request, DeleteManyRequest.rpc(collection, defaults));
   }
 
   public void referenceAdd(String fromUuid, String fromProperty, Reference reference) throws IOException {
     for (var uuid : reference.uuids()) {
       var singleRef = new Reference(reference.collection(), uuid);
       this.restTransport.performRequest(new ReferenceAddRequest(fromUuid, fromProperty, singleRef),
-          ReferenceAddRequest.endpoint(collectionDescriptor));
+          ReferenceAddRequest.endpoint(collection, defaults));
     }
   }
 
@@ -114,14 +131,14 @@ public ReferenceAddManyResponse referenceAddMany(BatchReference... references) t
 
   public ReferenceAddManyResponse referenceAddMany(List<BatchReference> references) throws IOException {
     return this.restTransport.performRequest(new ReferenceAddManyRequest(references),
-        ReferenceAddManyRequest.endpoint(references));
+        ReferenceAddManyRequest.endpoint(references, defaults));
   }
 
   public void referenceDelete(String fromUuid, String fromProperty, Reference reference) throws IOException {
     for (var uuid : reference.uuids()) {
       var singleRef = new Reference(reference.collection(), uuid);
       this.restTransport.performRequest(new ReferenceDeleteRequest(fromUuid, fromProperty, singleRef),
-          ReferenceDeleteRequest.endpoint(collectionDescriptor));
+          ReferenceDeleteRequest.endpoint(collection, defaults));
     }
   }
 
@@ -129,7 +146,7 @@ public void referenceReplace(String fromUuid, String fromProperty, Reference ref
     for (var uuid : reference.uuids()) {
       var singleRef = new Reference(reference.collection(), uuid);
       this.restTransport.performRequest(new ReferenceReplaceRequest(fromUuid, fromProperty, singleRef),
-          ReferenceReplaceRequest.endpoint(collectionDescriptor));
+          ReferenceReplaceRequest.endpoint(collection, defaults));
     }
   }
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClientAsync.java
index 506020b4b..f85696a5f 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClientAsync.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/WeaviateDataClientAsync.java
@@ -1,6 +1,5 @@
 package io.weaviate.client6.v1.api.collections.data;
 
-import java.io.IOException;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.List;
@@ -8,6 +7,7 @@
 import java.util.concurrent.CompletableFuture;
 import java.util.function.Function;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.api.collections.ObjectMetadata;
 import io.weaviate.client6.v1.api.collections.WeaviateObject;
 import io.weaviate.client6.v1.api.collections.query.WeaviateQueryClientAsync;
@@ -18,48 +18,62 @@
 import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
 import io.weaviate.client6.v1.internal.rest.RestTransport;
 
-public class WeaviateDataClientAsync<T> {
+public class WeaviateDataClientAsync<PropertiesT> {
   private final RestTransport restTransport;
   private final GrpcTransport grpcTransport;
-  private final CollectionDescriptor<T> collectionDescriptor;
+  private final CollectionDescriptor<PropertiesT> collection;
 
-  private final WeaviateQueryClientAsync<T> query;
+  private final WeaviateQueryClientAsync<PropertiesT> query;
+  private final CollectionHandleDefaults defaults;
 
-  public WeaviateDataClientAsync(CollectionDescriptor<T> collectionDescriptor, RestTransport restTransport,
-      GrpcTransport grpcTransport) {
+  public WeaviateDataClientAsync(
+      CollectionDescriptor<PropertiesT> collectionDescriptor,
+      RestTransport restTransport,
+      GrpcTransport grpcTransport,
+      CollectionHandleDefaults defaults) {
     this.restTransport = restTransport;
     this.grpcTransport = grpcTransport;
-    this.collectionDescriptor = collectionDescriptor;
-    this.query = new WeaviateQueryClientAsync<>(collectionDescriptor, grpcTransport);
+    this.collection = collectionDescriptor;
+    this.query = new WeaviateQueryClientAsync<>(collectionDescriptor, grpcTransport, defaults);
+    this.defaults = defaults;
   }
 
-  public CompletableFuture<WeaviateObject<T, Object, ObjectMetadata>> insert(T properties) throws IOException {
-    return insert(InsertObjectRequest.of(collectionDescriptor.name(), properties));
+  /** Copy constructor that updates the {@link #query} to use new defaults. */
+  public WeaviateDataClientAsync(WeaviateDataClientAsync<PropertiesT> c, CollectionHandleDefaults defaults) {
+    this.restTransport = c.restTransport;
+    this.grpcTransport = c.grpcTransport;
+    this.collection = c.collection;
+    this.query = new WeaviateQueryClientAsync<>(collection, grpcTransport, defaults);
+    this.defaults = defaults;
   }
 
-  public CompletableFuture<WeaviateObject<T, Object, ObjectMetadata>> insert(T properties,
-      Function<InsertObjectRequest.Builder<T>, ObjectBuilder<InsertObjectRequest<T>>> fn)
-      throws IOException {
-    return insert(InsertObjectRequest.of(collectionDescriptor.name(), properties, fn));
+  public CompletableFuture<WeaviateObject<PropertiesT, Object, ObjectMetadata>> insert(PropertiesT properties) {
+    return insert(InsertObjectRequest.of(collection.name(), properties));
   }
 
-  public CompletableFuture<WeaviateObject<T, Object, ObjectMetadata>> insert(InsertObjectRequest<T> request)
-      throws IOException {
-    return this.restTransport.performRequestAsync(request, InsertObjectRequest.endpoint(collectionDescriptor));
+  public CompletableFuture<WeaviateObject<PropertiesT, Object, ObjectMetadata>> insert(PropertiesT properties,
+      Function<InsertObjectRequest.Builder<PropertiesT>, ObjectBuilder<InsertObjectRequest<PropertiesT>>> fn) {
+    return insert(InsertObjectRequest.of(collection.name(), properties, fn));
+  }
+
+  public CompletableFuture<WeaviateObject<PropertiesT, Object, ObjectMetadata>> insert(
+      InsertObjectRequest<PropertiesT> request) {
+    return this.restTransport.performRequestAsync(request, InsertObjectRequest.endpoint(collection, defaults));
   }
 
   @SafeVarargs
-  public final CompletableFuture<InsertManyResponse> insertMany(T... objects) {
+  public final CompletableFuture<InsertManyResponse> insertMany(PropertiesT... objects) {
     return insertMany(InsertManyRequest.of(objects));
   }
 
-  public CompletableFuture<InsertManyResponse> insertMany(List<WeaviateObject<T, Reference, ObjectMetadata>> objects) {
+  public CompletableFuture<InsertManyResponse> insertMany(
+      List<WeaviateObject<PropertiesT, Reference, ObjectMetadata>> objects) {
     return insertMany(new InsertManyRequest<>(objects));
   }
 
-  public CompletableFuture<InsertManyResponse> insertMany(InsertManyRequest<T> request) {
+  public CompletableFuture<InsertManyResponse> insertMany(InsertManyRequest<PropertiesT> request) {
     return this.grpcTransport.performRequestAsync(request,
-        InsertManyRequest.rpc(request.objects(), collectionDescriptor));
+        InsertManyRequest.rpc(request.objects(), collection, defaults));
   }
 
   public CompletableFuture<Boolean> exists(String uuid) {
@@ -67,68 +81,64 @@ public CompletableFuture<Boolean> exists(String uuid) {
   }
 
   public CompletableFuture<Void> update(String uuid,
-      Function<UpdateObjectRequest.Builder<T>, ObjectBuilder<UpdateObjectRequest<T>>> fn)
-      throws IOException {
-    return this.restTransport.performRequestAsync(UpdateObjectRequest.of(collectionDescriptor.name(), uuid, fn),
-        UpdateObjectRequest.endpoint(collectionDescriptor));
+      Function<UpdateObjectRequest.Builder<PropertiesT>, ObjectBuilder<UpdateObjectRequest<PropertiesT>>> fn) {
+    return this.restTransport.performRequestAsync(UpdateObjectRequest.of(collection.name(), uuid, fn),
+        UpdateObjectRequest.endpoint(collection, defaults));
   }
 
   public CompletableFuture<Void> replace(String uuid,
-      Function<ReplaceObjectRequest.Builder<T>, ObjectBuilder<ReplaceObjectRequest<T>>> fn)
-      throws IOException {
-    return this.restTransport.performRequestAsync(ReplaceObjectRequest.of(collectionDescriptor.name(), uuid, fn),
-        ReplaceObjectRequest.endpoint(collectionDescriptor));
+      Function<ReplaceObjectRequest.Builder<PropertiesT>, ObjectBuilder<ReplaceObjectRequest<PropertiesT>>> fn) {
+    return this.restTransport.performRequestAsync(ReplaceObjectRequest.of(collection.name(), uuid, fn),
+        ReplaceObjectRequest.endpoint(collection, defaults));
   }
 
   public CompletableFuture<Void> delete(String uuid) {
-    return this.restTransport.performRequestAsync(new DeleteObjectRequest(collectionDescriptor.name(), uuid),
-        DeleteObjectRequest._ENDPOINT);
+    return this.restTransport.performRequestAsync(new DeleteObjectRequest(uuid),
+        DeleteObjectRequest.endpoint(collection, defaults));
   }
 
-  public CompletableFuture<DeleteManyResponse> deleteMany(String... uuids) throws IOException {
+  public CompletableFuture<DeleteManyResponse> deleteMany(String... uuids) {
     var either = Arrays.stream(uuids)
         .map(uuid -> (WhereOperand) Where.uuid().eq(uuid))
         .toList();
     return deleteMany(DeleteManyRequest.of(Where.or(either)));
   }
 
-  public CompletableFuture<DeleteManyResponse> deleteMany(Where where) throws IOException {
+  public CompletableFuture<DeleteManyResponse> deleteMany(Where where) {
     return deleteMany(DeleteManyRequest.of(where));
   }
 
   public CompletableFuture<DeleteManyResponse> deleteMany(Where where,
-      Function<DeleteManyRequest.Builder, ObjectBuilder<DeleteManyRequest>> fn)
-      throws IOException {
+      Function<DeleteManyRequest.Builder, ObjectBuilder<DeleteManyRequest>> fn) {
     return deleteMany(DeleteManyRequest.of(where, fn));
   }
 
-  public CompletableFuture<DeleteManyResponse> deleteMany(DeleteManyRequest request) throws IOException {
-    return this.grpcTransport.performRequestAsync(request, DeleteManyRequest.rpc(collectionDescriptor));
+  public CompletableFuture<DeleteManyResponse> deleteMany(DeleteManyRequest request) {
+    return this.grpcTransport.performRequestAsync(request, DeleteManyRequest.rpc(collection, defaults));
   }
 
   public CompletableFuture<Void> referenceAdd(String fromUuid, String fromProperty, Reference reference) {
     return forEachAsync(reference.uuids(), uuid -> {
       var singleRef = new Reference(reference.collection(), (String) uuid);
       return this.restTransport.performRequestAsync(new ReferenceAddRequest(fromUuid, fromProperty, singleRef),
-          ReferenceAddRequest.endpoint(collectionDescriptor));
+          ReferenceAddRequest.endpoint(collection, defaults));
     });
   }
 
-  public CompletableFuture<ReferenceAddManyResponse> referenceAddMany(BatchReference... references) throws IOException {
+  public CompletableFuture<ReferenceAddManyResponse> referenceAddMany(BatchReference... references) {
     return referenceAddMany(Arrays.asList(references));
   }
 
-  public CompletableFuture<ReferenceAddManyResponse> referenceAddMany(List<BatchReference> references)
-      throws IOException {
+  public CompletableFuture<ReferenceAddManyResponse> referenceAddMany(List<BatchReference> references) {
     return this.restTransport.performRequestAsync(new ReferenceAddManyRequest(references),
-        ReferenceAddManyRequest.endpoint(references));
+        ReferenceAddManyRequest.endpoint(references, defaults));
   }
 
   public CompletableFuture<Void> referenceDelete(String fromUuid, String fromProperty, Reference reference) {
     return forEachAsync(reference.uuids(), uuid -> {
       var singleRef = new Reference(reference.collection(), (String) uuid);
       return this.restTransport.performRequestAsync(new ReferenceDeleteRequest(fromUuid, fromProperty, singleRef),
-          ReferenceDeleteRequest.endpoint(collectionDescriptor));
+          ReferenceDeleteRequest.endpoint(collection, defaults));
     });
   }
 
@@ -136,7 +146,7 @@ public CompletableFuture<Void> referenceReplace(String fromUuid, String fromProp
     return forEachAsync(reference.uuids(), uuid -> {
       var singleRef = new Reference(reference.collection(), (String) uuid);
       return this.restTransport.performRequestAsync(new ReferenceReplaceRequest(fromUuid, fromProperty, singleRef),
-          ReferenceReplaceRequest.endpoint(collectionDescriptor));
+          ReferenceReplaceRequest.endpoint(collection, defaults));
     });
   }
 
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/data/WriteWeaviateObject.java b/src/main/java/io/weaviate/client6/v1/api/collections/data/WriteWeaviateObject.java
new file mode 100644
index 000000000..a351e6667
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/data/WriteWeaviateObject.java
@@ -0,0 +1,129 @@
+package io.weaviate.client6.v1.api.collections.data;
+
+import java.io.IOException;
+import java.lang.reflect.ParameterizedType;
+import java.util.List;
+import java.util.Map;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.gson.TypeAdapter;
+import com.google.gson.TypeAdapterFactory;
+import com.google.gson.internal.Streams;
+import com.google.gson.reflect.TypeToken;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonWriter;
+
+import io.weaviate.client6.v1.api.collections.ObjectMetadata;
+import io.weaviate.client6.v1.api.collections.WeaviateObject;
+
+public record WriteWeaviateObject<P>(
+    String collection,
+    P properties,
+    Map<String, List<Reference>> references,
+    ObjectMetadata metadata,
+    String tenant) {
+
+  WriteWeaviateObject(WeaviateObject<P, Reference, ObjectMetadata> object, String tenant) {
+    this(object.collection(), object.properties(), object.references(), object.metadata(), tenant);
+  }
+
+  public static enum CustomTypeAdapterFactory implements TypeAdapterFactory {
+    INSTANCE;
+
+    @SuppressWarnings("unchecked")
+    @Override
+    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
+      var type = typeToken.getType();
+      var rawType = typeToken.getRawType();
+      if (rawType != WriteWeaviateObject.class ||
+          !(type instanceof ParameterizedType parameterized)
+          || parameterized.getActualTypeArguments().length < 1) {
+        return null;
+      }
+
+      var typeParams = parameterized.getActualTypeArguments();
+      final var propertiesType = typeParams[0];
+
+      final var propertiesAdapter = gson.getAdapter(TypeToken.get(propertiesType));
+      final var metadataAdapter = gson.getAdapter(ObjectMetadata.class);
+      final var referencesAdapter = gson.getAdapter(Reference.class);
+
+      return (TypeAdapter<T>) new TypeAdapter<WriteWeaviateObject<?>>() {
+
+        @Override
+        public void write(JsonWriter out, WriteWeaviateObject<?> value) throws IOException {
+          out.beginObject();
+
+          out.name("class");
+          out.value(value.collection());
+
+          out.name("properties");
+          if (value.references().isEmpty()) {
+            ((TypeAdapter<Object>) propertiesAdapter).write(out, value.properties());
+          } else {
+            var properties = ((TypeAdapter<Object>) propertiesAdapter).toJsonTree(value.properties()).getAsJsonObject();
+            for (var refEntry : value.references().entrySet()) {
+              var beacons = new JsonArray();
+              for (var reference : refEntry.getValue()) {
+                var beacon = referencesAdapter.toJsonTree(reference);
+                beacons.add(beacon);
+              }
+              properties.add(refEntry.getKey(), beacons);
+            }
+            Streams.write(properties, out);
+          }
+
+          // Flatten out metadata fields.
+          var metadata = metadataAdapter.toJsonTree(value.metadata);
+          for (var entry : metadata.getAsJsonObject().entrySet()) {
+            out.name(entry.getKey());
+            Streams.write(entry.getValue(), out);
+          }
+
+          out.name("tenant");
+          out.value(value.tenant());
+
+          out.endObject();
+        }
+
+        @Override
+        public WriteWeaviateObject<?> read(JsonReader in) throws IOException {
+          var builder = new WeaviateObject.Builder<Object, Reference, ObjectMetadata>();
+          var metadata = new ObjectMetadata.Builder();
+
+          var object = JsonParser.parseReader(in).getAsJsonObject();
+          builder.collection(object.get("class").getAsString());
+
+          var jsonProperties = object.get("properties").getAsJsonObject();
+          var trueProperties = new JsonObject();
+          for (var property : jsonProperties.entrySet()) {
+            var value = property.getValue();
+            if (!value.isJsonArray()) {
+              trueProperties.add(property.getKey(), value);
+              continue;
+            }
+            var array = value.getAsJsonArray();
+            var first = array.get(0);
+            if (first.isJsonObject() && first.getAsJsonObject().has("beacon")) {
+              for (var el : array) {
+                var beacon = referencesAdapter.fromJsonTree(el);
+                builder.reference(property.getKey(), (Reference) beacon);
+              }
+            }
+          }
+
+          builder.properties(propertiesAdapter.fromJsonTree(trueProperties));
+
+          metadata.uuid(object.get("id").getAsString());
+          builder.metadata(metadata.build());
+
+          var tenant = object.get("tenant");
+          return new WriteWeaviateObject<>(builder.build(), tenant != null ? tenant.getAsString() : "");
+        }
+      }.nullSafe();
+    }
+  }
+}
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/AbstractQueryClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/AbstractQueryClient.java
index 0db66bd6b..356df14d5 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/query/AbstractQueryClient.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/AbstractQueryClient.java
@@ -4,6 +4,8 @@
 import java.util.Optional;
 import java.util.function.Function;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
+import io.weaviate.client6.v1.api.collections.WeaviateObject;
 import io.weaviate.client6.v1.internal.ObjectBuilder;
 import io.weaviate.client6.v1.internal.grpc.GrpcTransport;
 import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
@@ -11,10 +13,20 @@
 abstract class AbstractQueryClient<PropertiesT, SingleT, ResponseT, GroupedResponseT> {
   protected final CollectionDescriptor<PropertiesT> collection;
   protected final GrpcTransport grpcTransport;
+  protected final CollectionHandleDefaults defaults;
 
-  AbstractQueryClient(CollectionDescriptor<PropertiesT> collection, GrpcTransport grpcTransport) {
+  AbstractQueryClient(CollectionDescriptor<PropertiesT> collection, GrpcTransport grpcTransport,
+      CollectionHandleDefaults defaults) {
     this.collection = collection;
     this.grpcTransport = grpcTransport;
+    this.defaults = defaults;
+  }
+
+  /** Copy constructor that sets new defaults. */
+  AbstractQueryClient(
+      AbstractQueryClient<PropertiesT, SingleT, ResponseT, GroupedResponseT> c,
+      CollectionHandleDefaults defaults) {
+    this(c.collection, c.grpcTransport, defaults);
   }
 
   protected abstract SingleT byId(ById byId);
@@ -30,11 +42,22 @@ public SingleT byId(String uuid) {
   }
 
   public SingleT byId(String uuid, Function<ById.Builder, ObjectBuilder<ById>> fn) {
+    // Collection handle defaults (consistencyLevel / tenant) are irrelevant for
+    // by-ID lookup. Do not `applyDefaults` to `fn`.
     return byId(ById.of(uuid, fn));
   }
 
-  protected final <T> Optional<T> optionalFirst(List<T> objects) {
-    return objects.isEmpty() ? Optional.empty() : Optional.ofNullable(objects.get(0));
+  /**
+   * Retrieve the first result from query response if any.
+   *
+   * @param response Query response.
+   * @return An object from the list or empty {@link Optional}.
+   */
+  protected final <T> Optional<WeaviateObject<T, Object, QueryMetadata>> optionalFirst(QueryResponse<T> response) {
+    return response == null || response.objects().isEmpty()
+        ? Optional.empty()
+        : Optional.ofNullable(response.objects().get(0));
+
   }
 
   // Object queries -----------------------------------------------------------
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/ConsistencyLevel.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/ConsistencyLevel.java
index 27cd30221..5ed88258f 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/query/ConsistencyLevel.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/ConsistencyLevel.java
@@ -1,20 +1,37 @@
 package io.weaviate.client6.v1.api.collections.query;
 
 import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase;
+import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatch;
+import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBatchDelete;
 import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet;
 
 public enum ConsistencyLevel {
-  ONE(WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE),
-  QUORUM(WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE),
-  ALL(WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE);
+  ONE(WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE, "ONE"),
+  QUORUM(WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE, "QUORUM"),
+  ALL(WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE, "ALL");
 
   private final WeaviateProtoBase.ConsistencyLevel consistencyLevel;
+  private final String queryParameter;
 
-  ConsistencyLevel(WeaviateProtoBase.ConsistencyLevel consistencyLevel) {
+  ConsistencyLevel(WeaviateProtoBase.ConsistencyLevel consistencyLevel, String queryParameter) {
     this.consistencyLevel = consistencyLevel;
+    this.queryParameter = queryParameter;
   }
 
-  final void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) {
+  public final void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req) {
     req.setConsistencyLevel(consistencyLevel);
   }
+
+  public final void appendTo(WeaviateProtoBatchDelete.BatchDeleteRequest.Builder req) {
+    req.setConsistencyLevel(consistencyLevel);
+  }
+
+  public final void appendTo(WeaviateProtoBatch.BatchObjectsRequest.Builder req) {
+    req.setConsistencyLevel(consistencyLevel);
+  }
+
+  @Override
+  public String toString() {
+    return queryParameter;
+  }
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryOperator.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryOperator.java
index d7a3e4bb2..a3844b4eb 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryOperator.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryOperator.java
@@ -3,5 +3,6 @@
 import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoSearchGet;
 
 interface QueryOperator {
+  /** Append QueryOperator to the request message. */
   void appendTo(WeaviateProtoSearchGet.SearchRequest.Builder req);
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryRequest.java
index 22ebbfa7c..a14be5794 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryRequest.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/QueryRequest.java
@@ -9,6 +9,7 @@
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.api.collections.ObjectMetadata;
 import io.weaviate.client6.v1.api.collections.Vectors;
 import io.weaviate.client6.v1.api.collections.WeaviateObject;
@@ -24,7 +25,8 @@
 public record QueryRequest(QueryOperator operator, GroupBy groupBy) {
 
   static <T> Rpc<QueryRequest, WeaviateProtoSearchGet.SearchRequest, QueryResponse<T>, WeaviateProtoSearchGet.SearchReply> rpc(
-      CollectionDescriptor<T> collection) {
+      CollectionDescriptor<T> collection,
+      CollectionHandleDefaults defaults) {
     return Rpc.of(
         request -> {
           var message = WeaviateProtoSearchGet.SearchRequest.newBuilder();
@@ -33,6 +35,14 @@ static <T> Rpc<QueryRequest, WeaviateProtoSearchGet.SearchRequest, QueryResponse
           message.setUses123Api(true);
           message.setCollection(collection.name());
           request.operator.appendTo(message);
+
+          if (defaults.tenant() != null) {
+            message.setTenant(defaults.tenant());
+          }
+          if (defaults.consistencyLevel() != null) {
+            defaults.consistencyLevel().appendTo(message);
+          }
+
           if (request.groupBy != null) {
             request.groupBy.appendTo(message);
           }
@@ -52,8 +62,9 @@ static <T> Rpc<QueryRequest, WeaviateProtoSearchGet.SearchRequest, QueryResponse
   }
 
   static <T> Rpc<QueryRequest, WeaviateProtoSearchGet.SearchRequest, QueryResponseGrouped<T>, WeaviateProtoSearchGet.SearchReply> grouped(
-      CollectionDescriptor<T> collection) {
-    var rpc = rpc(collection);
+      CollectionDescriptor<T> collection,
+      CollectionHandleDefaults defaults) {
+    var rpc = rpc(collection, defaults);
     return Rpc.of(
         request -> rpc.marshal(request),
         reply -> {
@@ -85,8 +96,8 @@ static <T> Rpc<QueryRequest, WeaviateProtoSearchGet.SearchRequest, QueryResponse
   private static <T> WeaviateObject<T, Object, QueryMetadata> unmarshalResultObject(
       WeaviateProtoSearchGet.PropertiesResult propertiesResult,
       WeaviateProtoSearchGet.MetadataResult metadataResult,
-      CollectionDescriptor<T> descriptor) {
-    var object = unmarshalWithReferences(propertiesResult, metadataResult, descriptor);
+      CollectionDescriptor<T> collection) {
+    var object = unmarshalWithReferences(propertiesResult, metadataResult, collection);
     var metadata = new QueryMetadata.Builder()
         .uuid(object.metadata().uuid())
         .vectors(object.metadata().vectors());
@@ -109,7 +120,7 @@ private static <T> WeaviateObject<T, Object, QueryMetadata> unmarshalResultObjec
     if (metadataResult.getExplainScorePresent()) {
       metadata.explainScore(metadataResult.getExplainScore());
     }
-    return new WeaviateObject<>(descriptor.name(), object.properties(), object.references(), metadata.build());
+    return new WeaviateObject<>(collection.name(), object.properties(), object.references(), metadata.build());
   }
 
   private static <T> WeaviateObject<T, Object, ObjectMetadata> unmarshalWithReferences(
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClient.java
index 54801ca12..81a7c11b1 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClient.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClient.java
@@ -2,6 +2,7 @@
 
 import java.util.Optional;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.api.collections.WeaviateObject;
 import io.weaviate.client6.v1.internal.grpc.GrpcTransport;
 import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
@@ -10,28 +11,36 @@ public class WeaviateQueryClient<T>
     extends
     AbstractQueryClient<T, Optional<WeaviateObject<T, Object, QueryMetadata>>, QueryResponse<T>, QueryResponseGrouped<T>> {
 
-  public WeaviateQueryClient(CollectionDescriptor<T> collection, GrpcTransport grpcTransport) {
-    super(collection, grpcTransport);
+  public WeaviateQueryClient(
+      CollectionDescriptor<T> collection,
+      GrpcTransport grpcTransport,
+      CollectionHandleDefaults defaults) {
+    super(collection, grpcTransport, defaults);
+  }
+
+  /** Copy constructor that sets new defaults. */
+  public WeaviateQueryClient(WeaviateQueryClient<T> c, CollectionHandleDefaults defaults) {
+    super(c, defaults);
   }
 
   @Override
   protected Optional<WeaviateObject<T, Object, QueryMetadata>> byId(ById byId) {
     var request = new QueryRequest(byId, null);
-    var result = this.grpcTransport.performRequest(request, QueryRequest.rpc(collection));
-    return optionalFirst(result.objects());
+    var result = this.grpcTransport.performRequest(request, QueryRequest.rpc(collection, defaults));
+    return optionalFirst(result);
 
   }
 
   @Override
   protected final QueryResponse<T> performRequest(QueryOperator operator) {
     var request = new QueryRequest(operator, null);
-    return this.grpcTransport.performRequest(request, QueryRequest.rpc(collection));
+    return this.grpcTransport.performRequest(request, QueryRequest.rpc(collection, defaults));
   }
 
   @Override
   protected final QueryResponseGrouped<T> performRequest(QueryOperator operator, GroupBy groupBy) {
     var request = new QueryRequest(operator, groupBy);
-    return this.grpcTransport.performRequest(request, QueryRequest.grouped(collection));
+    return this.grpcTransport.performRequest(request, QueryRequest.grouped(collection, defaults));
   }
 
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClientAsync.java
index e8415314f..0c195e80d 100644
--- a/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClientAsync.java
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/query/WeaviateQueryClientAsync.java
@@ -3,6 +3,7 @@
 import java.util.Optional;
 import java.util.concurrent.CompletableFuture;
 
+import io.weaviate.client6.v1.api.collections.CollectionHandleDefaults;
 import io.weaviate.client6.v1.api.collections.WeaviateObject;
 import io.weaviate.client6.v1.internal.grpc.GrpcTransport;
 import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
@@ -11,28 +12,36 @@ public class WeaviateQueryClientAsync<T>
     extends
     AbstractQueryClient<T, CompletableFuture<Optional<WeaviateObject<T, Object, QueryMetadata>>>, CompletableFuture<QueryResponse<T>>, CompletableFuture<QueryResponseGrouped<T>>> {
 
-  public WeaviateQueryClientAsync(CollectionDescriptor<T> collection, GrpcTransport grpcTransport) {
-    super(collection, grpcTransport);
+  public WeaviateQueryClientAsync(
+      CollectionDescriptor<T> collection,
+      GrpcTransport grpcTransport,
+      CollectionHandleDefaults defaults) {
+    super(collection, grpcTransport, defaults);
+  }
+
+  /** Copy constructor that sets new defaults. */
+  public WeaviateQueryClientAsync(WeaviateQueryClientAsync<T> qc, CollectionHandleDefaults defaults) {
+    super(qc, defaults);
   }
 
   @Override
   protected CompletableFuture<Optional<WeaviateObject<T, Object, QueryMetadata>>> byId(
       ById byId) {
     var request = new QueryRequest(byId, null);
-    var result = this.grpcTransport.performRequestAsync(request, QueryRequest.rpc(collection));
-    return result.thenApply(r -> optionalFirst(r.objects()));
+    var result = this.grpcTransport.performRequestAsync(request, QueryRequest.rpc(collection, defaults));
+    return result.thenApply(this::optionalFirst);
   }
 
   @Override
   protected final CompletableFuture<QueryResponse<T>> performRequest(QueryOperator operator) {
     var request = new QueryRequest(operator, null);
-    return this.grpcTransport.performRequestAsync(request, QueryRequest.rpc(collection));
+    return this.grpcTransport.performRequestAsync(request, QueryRequest.rpc(collection, defaults));
   }
 
   @Override
   protected final CompletableFuture<QueryResponseGrouped<T>> performRequest(QueryOperator operator, GroupBy groupBy) {
     var request = new QueryRequest(operator, groupBy);
-    return this.grpcTransport.performRequestAsync(request, QueryRequest.grouped(collection));
+    return this.grpcTransport.performRequestAsync(request, QueryRequest.grouped(collection, defaults));
   }
 
 }
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/CreateTenantsRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/CreateTenantsRequest.java
new file mode 100644
index 000000000..ea740e68c
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/CreateTenantsRequest.java
@@ -0,0 +1,19 @@
+package io.weaviate.client6.v1.api.collections.tenants;
+
+import java.util.Collections;
+import java.util.List;
+
+import io.weaviate.client6.v1.internal.json.JSON;
+import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
+import io.weaviate.client6.v1.internal.rest.Endpoint;
+import io.weaviate.client6.v1.internal.rest.SimpleEndpoint;
+
+public record CreateTenantsRequest(List<Tenant> tenants) {
+  static Endpoint<CreateTenantsRequest, Void> endpoint(CollectionDescriptor<?> collection) {
+    return SimpleEndpoint.sideEffect(
+        __ -> "POST",
+        __ -> "/schema/" + collection.name() + "/tenants",
+        __ -> Collections.emptyMap(),
+        request -> JSON.serialize(request.tenants));
+  }
+}
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/DeleteTenantsRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/DeleteTenantsRequest.java
new file mode 100644
index 000000000..82f499314
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/DeleteTenantsRequest.java
@@ -0,0 +1,19 @@
+package io.weaviate.client6.v1.api.collections.tenants;
+
+import java.util.Collections;
+import java.util.List;
+
+import io.weaviate.client6.v1.internal.json.JSON;
+import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
+import io.weaviate.client6.v1.internal.rest.Endpoint;
+import io.weaviate.client6.v1.internal.rest.SimpleEndpoint;
+
+public record DeleteTenantsRequest(List<String> tenants) {
+  static Endpoint<DeleteTenantsRequest, Void> endpoint(CollectionDescriptor<?> collection) {
+    return SimpleEndpoint.sideEffect(
+        __ -> "DELETE",
+        __ -> "/schema/" + collection.name() + "/tenants",
+        __ -> Collections.emptyMap(),
+        request -> JSON.serialize(request.tenants));
+  }
+}
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/GetTenantsRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/GetTenantsRequest.java
new file mode 100644
index 000000000..a8095ed1b
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/GetTenantsRequest.java
@@ -0,0 +1,57 @@
+package io.weaviate.client6.v1.api.collections.tenants;
+
+import java.util.List;
+
+import io.weaviate.client6.v1.internal.grpc.Rpc;
+import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateBlockingStub;
+import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateGrpc.WeaviateFutureStub;
+import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants;
+import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoTenants.TenantNames;
+import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
+
+public record GetTenantsRequest(List<String> tenants) {
+  static final Rpc<GetTenantsRequest, WeaviateProtoTenants.TenantsGetRequest, List<Tenant>, WeaviateProtoTenants.TenantsGetReply> rpc(
+      CollectionDescriptor<?> collection) {
+    return Rpc.of(
+        request -> {
+          var message = WeaviateProtoTenants.TenantsGetRequest.newBuilder()
+              .setCollection(collection.name());
+
+          if (!request.tenants.isEmpty()) {
+            message.setNames(TenantNames.newBuilder()
+                .addAllValues(request.tenants)
+                .build());
+          }
+          return message.build();
+        },
+        response -> {
+          return response.getTenantsList().stream()
+              .map(t -> {
+                TenantStatus status;
+                switch (t.getActivityStatus()) {
+                  case TENANT_ACTIVITY_STATUS_ACTIVE, TENANT_ACTIVITY_STATUS_HOT:
+                    status = TenantStatus.ACTIVE;
+                    break;
+                  case TENANT_ACTIVITY_STATUS_INACTIVE, TENANT_ACTIVITY_STATUS_COLD:
+                    status = TenantStatus.INACTIVE;
+                    break;
+                  case TENANT_ACTIVITY_STATUS_FROZEN, TENANT_ACTIVITY_STATUS_OFFLOADED:
+                    status = TenantStatus.OFFLOADED;
+                    break;
+                  case TENANT_ACTIVITY_STATUS_OFFLOADING, TENANT_ACTIVITY_STATUS_FREEZING:
+                    status = TenantStatus.OFFLOADING;
+                    break;
+                  case TENANT_ACTIVITY_STATUS_ONLOADING, TENANT_ACTIVITY_STATUS_UNFREEZING:
+                    status = TenantStatus.ONLOADING;
+                    break;
+                  default:
+                    throw new RuntimeException("unknown tenant status " + t.getActivityStatus().toString());
+                }
+                return new Tenant(t.getName(), status);
+              })
+              .toList();
+        },
+        () -> WeaviateBlockingStub::tenantsGet,
+        () -> WeaviateFutureStub::tenantsGet);
+  };
+}
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/Tenant.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/Tenant.java
new file mode 100644
index 000000000..519e19bd7
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/Tenant.java
@@ -0,0 +1,43 @@
+package io.weaviate.client6.v1.api.collections.tenants;
+
+import com.google.gson.annotations.SerializedName;
+
+public record Tenant(
+    @SerializedName("name") String name,
+    @SerializedName("activityStatus") TenantStatus status) {
+
+  /** Create new tenant with {@link TenantStatus#ACTIVE}. */
+  public static Tenant active(String name) {
+    return new Tenant(name, TenantStatus.ACTIVE);
+  }
+
+  /** Create new tenant with {@link TenantStatus#INACTIVE}. */
+  public static Tenant inactive(String name) {
+    return new Tenant(name, TenantStatus.INACTIVE);
+  }
+
+  /** Returns true if tenant's status is {@link TenantStatus#ACTIVE}. */
+  public boolean isActive() {
+    return status == TenantStatus.ACTIVE;
+  }
+
+  /** Returns true if tenant's status is {@link TenantStatus#INACTIVE}. */
+  public boolean isInactive() {
+    return status == TenantStatus.INACTIVE;
+  }
+
+  /** Returns true if tenant's status is {@link TenantStatus#OFFLOADED}. */
+  public boolean isOffloaded() {
+    return status == TenantStatus.OFFLOADED;
+  }
+
+  /** Returns true if tenant's status is {@link TenantStatus#OFFLOADING}. */
+  public boolean isOffloading() {
+    return status == TenantStatus.OFFLOADING;
+  }
+
+  /** Returns true if tenant's status is {@link TenantStatus#ONLOADING}. */
+  public boolean isOnloading() {
+    return status == TenantStatus.ONLOADING;
+  }
+}
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/TenantExistsRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/TenantExistsRequest.java
new file mode 100644
index 000000000..50e238457
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/TenantExistsRequest.java
@@ -0,0 +1,17 @@
+package io.weaviate.client6.v1.api.collections.tenants;
+
+import java.util.Collections;
+
+import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
+import io.weaviate.client6.v1.internal.rest.BooleanEndpoint;
+import io.weaviate.client6.v1.internal.rest.Endpoint;
+
+public record TenantExistsRequest(String tenant) {
+  static Endpoint<TenantExistsRequest, Boolean> endpoint(CollectionDescriptor<?> collection) {
+    return new BooleanEndpoint<>(
+        __ -> "GET",
+        request -> "/schema/" + collection.name() + "/tenants/" + request.tenant,
+        __ -> Collections.emptyMap(),
+        __ -> null);
+  }
+}
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/TenantStatus.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/TenantStatus.java
new file mode 100644
index 000000000..69b759a71
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/TenantStatus.java
@@ -0,0 +1,28 @@
+package io.weaviate.client6.v1.api.collections.tenants;
+
+import com.google.gson.annotations.SerializedName;
+
+public enum TenantStatus {
+  /** The tenant is activated and can be readily used. */
+  @SerializedName(value = "ACTIVE", alternate = "HOT")
+  ACTIVE,
+  /**
+   * Tenant needs to be activated before use.
+   * Files are stored locally on the node.
+   */
+  @SerializedName(value = "INACTIVE", alternate = "COLD")
+  INACTIVE,
+  /**
+   * Tenant is inactive and will need to be onloaded before use.
+   * Files are stored in the configured remote (cloud) storage.
+   */
+  @SerializedName(value = "OFFLOADED", alternate = "FROZEN")
+  OFFLOADED,
+
+  /** Tenant is being offloaded to a remote storage. */
+  @SerializedName(value = "OFFLOADING", alternate = "FREEZING")
+  OFFLOADING,
+  /** Tenant is being activated. */
+  @SerializedName(value = "ONLOADING", alternate = "UNFREEZING")
+  ONLOADING;
+}
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/UpdateTenantsRequest.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/UpdateTenantsRequest.java
new file mode 100644
index 000000000..37f40be00
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/UpdateTenantsRequest.java
@@ -0,0 +1,19 @@
+package io.weaviate.client6.v1.api.collections.tenants;
+
+import java.util.Collections;
+import java.util.List;
+
+import io.weaviate.client6.v1.internal.json.JSON;
+import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
+import io.weaviate.client6.v1.internal.rest.Endpoint;
+import io.weaviate.client6.v1.internal.rest.SimpleEndpoint;
+
+public record UpdateTenantsRequest(List<Tenant> tenants) {
+  static Endpoint<UpdateTenantsRequest, Void> endpoint(CollectionDescriptor<?> collection) {
+    return SimpleEndpoint.sideEffect(
+        __ -> "PUT",
+        __ -> "/schema/" + collection.name() + "/tenants",
+        __ -> Collections.emptyMap(),
+        request -> JSON.serialize(request.tenants));
+  }
+}
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/WeaviateTenantsClient.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/WeaviateTenantsClient.java
new file mode 100644
index 000000000..37385672a
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/WeaviateTenantsClient.java
@@ -0,0 +1,94 @@
+package io.weaviate.client6.v1.api.collections.tenants;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+
+import io.weaviate.client6.v1.internal.grpc.GrpcTransport;
+import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
+import io.weaviate.client6.v1.internal.rest.RestTransport;
+
+public class WeaviateTenantsClient {
+  private final CollectionDescriptor<?> collection;
+  private final RestTransport restTransport;
+  private final GrpcTransport grpcTransport;
+
+  public WeaviateTenantsClient(
+      CollectionDescriptor<?> collection,
+      RestTransport restTransport,
+      GrpcTransport grpcTransport) {
+    this.collection = collection;
+    this.restTransport = restTransport;
+    this.grpcTransport = grpcTransport;
+  }
+
+  public void create(Tenant... tenants) throws IOException {
+    create(Arrays.asList(tenants));
+  }
+
+  public void create(List<Tenant> tenants) throws IOException {
+    this.restTransport.performRequest(new CreateTenantsRequest(tenants), CreateTenantsRequest.endpoint(collection));
+  }
+
+  public Optional<Tenant> get(String tenant) {
+    var tenants = get(List.of(tenant));
+    return tenants.isEmpty() ? Optional.empty() : Optional.ofNullable(tenants.get(0));
+  }
+
+  public List<Tenant> list() {
+    return get();
+  }
+
+  public List<Tenant> get(String... tenants) {
+    return get(Arrays.asList(tenants));
+  }
+
+  public List<Tenant> get(List<String> tenants) {
+    return this.grpcTransport.performRequest(new GetTenantsRequest(tenants), GetTenantsRequest.rpc(collection));
+  }
+
+  public void update(Tenant... tenants) throws IOException {
+    update(Arrays.asList(tenants));
+  }
+
+  public void update(List<Tenant> tenants) throws IOException {
+    this.restTransport.performRequest(new UpdateTenantsRequest(tenants), UpdateTenantsRequest.endpoint(collection));
+  }
+
+  public void delete(String... tenants) throws IOException {
+    delete(Arrays.asList(tenants));
+  }
+
+  public void delete(List<String> tenants) throws IOException {
+    this.restTransport.performRequest(new DeleteTenantsRequest(tenants), DeleteTenantsRequest.endpoint(collection));
+  }
+
+  public boolean exists(String tenant) throws IOException {
+    return this.restTransport.performRequest(new TenantExistsRequest(tenant), TenantExistsRequest.endpoint(collection));
+  }
+
+  public void activate(String... tenants) throws IOException {
+    activate(Arrays.asList(tenants));
+  }
+
+  public void activate(List<String> tenants) throws IOException {
+    update(tenants.stream().map(Tenant::active).toList());
+  }
+
+  public void deactivate(String... tenants) throws IOException {
+    deactivate(Arrays.asList(tenants));
+  }
+
+  public void deactivate(List<String> tenants) throws IOException {
+    update(tenants.stream().map(Tenant::inactive).toList());
+  }
+
+  public void offload(String... tenants) throws IOException {
+    offload(Arrays.asList(tenants));
+  }
+
+  public void offload(List<String> tenants) throws IOException {
+    update(tenants.stream().map(t -> new Tenant(t, TenantStatus.OFFLOADED)).toList());
+  }
+}
diff --git a/src/main/java/io/weaviate/client6/v1/api/collections/tenants/WeaviateTenantsClientAsync.java b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/WeaviateTenantsClientAsync.java
new file mode 100644
index 000000000..5725f55ac
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/api/collections/tenants/WeaviateTenantsClientAsync.java
@@ -0,0 +1,99 @@
+package io.weaviate.client6.v1.api.collections.tenants;
+
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CompletableFuture;
+
+import io.weaviate.client6.v1.internal.grpc.GrpcTransport;
+import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
+import io.weaviate.client6.v1.internal.rest.RestTransport;
+
+public class WeaviateTenantsClientAsync {
+  private final CollectionDescriptor<?> collection;
+  private final RestTransport restTransport;
+  private final GrpcTransport grpcTransport;
+
+  public WeaviateTenantsClientAsync(
+      CollectionDescriptor<?> collection,
+      RestTransport restTransport,
+      GrpcTransport grpcTransport) {
+    this.collection = collection;
+    this.restTransport = restTransport;
+    this.grpcTransport = grpcTransport;
+  }
+
+  public CompletableFuture<Void> create(Tenant... tenants) throws IOException {
+    return create(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<Void> create(List<Tenant> tenants) throws IOException {
+    return this.restTransport.performRequestAsync(new CreateTenantsRequest(tenants),
+        CreateTenantsRequest.endpoint(collection));
+  }
+
+  public CompletableFuture<Optional<Tenant>> get(String tenant) {
+    var tenants = get(List.of(tenant));
+    return tenants.thenApply(result -> result.isEmpty() ? Optional.empty() : Optional.ofNullable(result.get(0)));
+  }
+
+  public CompletableFuture<List<Tenant>> list() {
+    return get();
+  }
+
+  public CompletableFuture<List<Tenant>> get(String... tenants) {
+    return get(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<List<Tenant>> get(List<String> tenants) {
+    return this.grpcTransport.performRequestAsync(new GetTenantsRequest(tenants), GetTenantsRequest.rpc(collection));
+  }
+
+  public CompletableFuture<Void> update(Tenant... tenants) throws IOException {
+    return update(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<Void> update(List<Tenant> tenants) throws IOException {
+    return this.restTransport.performRequestAsync(new UpdateTenantsRequest(tenants),
+        UpdateTenantsRequest.endpoint(collection));
+  }
+
+  public CompletableFuture<Void> delete(String... tenants) throws IOException {
+    return delete(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<Void> delete(List<String> tenants) throws IOException {
+    return this.restTransport.performRequestAsync(new DeleteTenantsRequest(tenants),
+        DeleteTenantsRequest.endpoint(collection));
+  }
+
+  public CompletableFuture<Boolean> exists(String tenant) throws IOException {
+    return this.restTransport.performRequestAsync(new TenantExistsRequest(tenant),
+        TenantExistsRequest.endpoint(collection));
+  }
+
+  public CompletableFuture<Void> activate(String... tenants) throws IOException {
+    return activate(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<Void> activate(List<String> tenants) throws IOException {
+    return update(tenants.stream().map(Tenant::active).toList());
+  }
+
+  public CompletableFuture<Void> deactivate(String... tenants) throws IOException {
+    return deactivate(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<Void> deactivate(List<String> tenants) throws IOException {
+    return update(tenants.stream().map(Tenant::inactive).toList());
+  }
+
+  public CompletableFuture<Void> offload(String... tenants) throws IOException {
+    return offload(Arrays.asList(tenants));
+  }
+
+  public CompletableFuture<Void> offload(List<String> tenants) throws IOException {
+    return update(tenants.stream().map(t -> new Tenant(t, TenantStatus.OFFLOADED)).toList());
+  }
+}
diff --git a/src/main/java/io/weaviate/client6/v1/internal/json/JSON.java b/src/main/java/io/weaviate/client6/v1/internal/json/JSON.java
index ca52d4c2d..960d40279 100644
--- a/src/main/java/io/weaviate/client6/v1/internal/json/JSON.java
+++ b/src/main/java/io/weaviate/client6/v1/internal/json/JSON.java
@@ -13,6 +13,8 @@ public final class JSON {
     // TypeAdapterFactories ---------------------------------------------------
     gsonBuilder.registerTypeAdapterFactory(
         io.weaviate.client6.v1.api.collections.WeaviateObject.CustomTypeAdapterFactory.INSTANCE);
+    gsonBuilder.registerTypeAdapterFactory(
+        io.weaviate.client6.v1.api.collections.data.WriteWeaviateObject.CustomTypeAdapterFactory.INSTANCE);
     gsonBuilder.registerTypeAdapterFactory(
         io.weaviate.client6.v1.api.collections.CollectionConfig.CustomTypeAdapterFactory.INSTANCE);
     gsonBuilder.registerTypeAdapterFactory(
diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/BooleanEndpoint.java b/src/main/java/io/weaviate/client6/v1/internal/rest/BooleanEndpoint.java
index b0b20665e..2efc2abee 100644
--- a/src/main/java/io/weaviate/client6/v1/internal/rest/BooleanEndpoint.java
+++ b/src/main/java/io/weaviate/client6/v1/internal/rest/BooleanEndpoint.java
@@ -5,10 +5,17 @@
 
 public class BooleanEndpoint<RequestT> extends EndpointBase<RequestT, Boolean> {
 
+  public static <RequestT> BooleanEndpoint<RequestT> noBody(
+      Function<RequestT, String> method,
+      Function<RequestT, String> requestUrl,
+      Function<RequestT, Map<String, Object>> queryParameters) {
+    return new BooleanEndpoint<>(method, requestUrl, queryParameters, nullBody());
+  }
+
   public BooleanEndpoint(
       Function<RequestT, String> method,
       Function<RequestT, String> requestUrl,
-      Function<RequestT, Map<String, String>> queryParameters,
+      Function<RequestT, Map<String, Object>> queryParameters,
       Function<RequestT, String> body) {
     super(method, requestUrl, queryParameters, body);
   }
diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/DefaultRestTransport.java b/src/main/java/io/weaviate/client6/v1/internal/rest/DefaultRestTransport.java
index bcd5a07ab..f8b4d255b 100644
--- a/src/main/java/io/weaviate/client6/v1/internal/rest/DefaultRestTransport.java
+++ b/src/main/java/io/weaviate/client6/v1/internal/rest/DefaultRestTransport.java
@@ -75,6 +75,12 @@ public DefaultRestTransport(RestTransportOptions transportOptions) {
     this.httpClientAsync.start();
   }
 
+  private <RequestT> String uri(Endpoint<RequestT, ?> ep, RequestT req) {
+    return transportOptions.baseUrl()
+        + ep.requestUrl(req)
+        + UrlEncoder.encodeQuery(ep.queryParameters(req));
+  }
+
   @Override
   public <RequestT, ResponseT, ExceptionT> ResponseT performRequest(RequestT request,
       Endpoint<RequestT, ResponseT> endpoint)
@@ -86,7 +92,7 @@ public <RequestT, ResponseT, ExceptionT> ResponseT performRequest(RequestT reque
   private <RequestT, ResponseT> ClassicHttpRequest prepareClassicRequest(RequestT request,
       Endpoint<RequestT, ResponseT> endpoint) {
     var method = endpoint.method(request);
-    var uri = transportOptions.baseUrl() + endpoint.requestUrl(request);
+    var uri = uri(endpoint, request);
 
     // TODO: apply options;
     var req = ClassicRequestBuilder.create(method).setUri(uri);
@@ -138,8 +144,7 @@ public void cancelled() {
   private <RequestT, ResponseT> SimpleHttpRequest prepareSimpleRequest(RequestT request,
       Endpoint<RequestT, ResponseT> endpoint) {
     var method = endpoint.method(request);
-    var uri = transportOptions.baseUrl() + endpoint.requestUrl(request);
-    // TODO: apply options;
+    var uri = uri(endpoint, request);
 
     var body = endpoint.body(request);
     var req = SimpleHttpRequest.create(method, uri);
@@ -160,21 +165,17 @@ private <ResponseT, ExceptionT> ResponseT handleResponseAsync(
     return _handleResponse(endpoint, method, url, statusCode, body);
   }
 
+  @SuppressWarnings("unchecked")
   private <ResponseT> ResponseT _handleResponse(Endpoint<?, ResponseT> endpoint, String method, String url,
       int statusCode, String body) {
     if (endpoint.isError(statusCode)) {
       var message = endpoint.deserializeError(statusCode, body);
       throw WeaviateApiException.http(method, url, statusCode, message);
     }
-
     if (endpoint instanceof JsonEndpoint json) {
-      @SuppressWarnings("unchecked")
-      ResponseT response = (ResponseT) json.deserializeResponse(statusCode, body);
-      return response;
+      return (ResponseT) json.deserializeResponse(statusCode, body);
     } else if (endpoint instanceof BooleanEndpoint bool) {
-      @SuppressWarnings("unchecked")
-      ResponseT response = (ResponseT) ((Boolean) bool.getResult(statusCode));
-      return response;
+      return (ResponseT) ((Boolean) bool.getResult(statusCode));
     }
 
     // TODO: make it a WeaviateTransportException
diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/Endpoint.java b/src/main/java/io/weaviate/client6/v1/internal/rest/Endpoint.java
index 52cc37c3b..6e1e33760 100644
--- a/src/main/java/io/weaviate/client6/v1/internal/rest/Endpoint.java
+++ b/src/main/java/io/weaviate/client6/v1/internal/rest/Endpoint.java
@@ -10,7 +10,7 @@ public interface Endpoint<RequestT, ResponseT> {
 
   String body(RequestT request);
 
-  Map<String, String> queryParameters(RequestT request);
+  Map<String, Object> queryParameters(RequestT request);
 
   /** Should this status code be considered an error? */
   boolean isError(int statusCode);
diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/EndpointBase.java b/src/main/java/io/weaviate/client6/v1/internal/rest/EndpointBase.java
index 2ebe61d6d..4776d4afe 100644
--- a/src/main/java/io/weaviate/client6/v1/internal/rest/EndpointBase.java
+++ b/src/main/java/io/weaviate/client6/v1/internal/rest/EndpointBase.java
@@ -14,7 +14,7 @@ public abstract class EndpointBase<RequestT, ResponseT> implements Endpoint<Requ
   protected final Function<RequestT, String> method;
   protected final Function<RequestT, String> requestUrl;
   protected final Function<RequestT, String> body;
-  protected final Function<RequestT, Map<String, String>> queryParameters;
+  protected final Function<RequestT, Map<String, Object>> queryParameters;
 
   @SuppressWarnings("unchecked")
   protected static <RequestT> Function<RequestT, String> nullBody() {
@@ -24,7 +24,7 @@ protected static <RequestT> Function<RequestT, String> nullBody() {
   public EndpointBase(
       Function<RequestT, String> method,
       Function<RequestT, String> requestUrl,
-      Function<RequestT, Map<String, String>> queryParameters,
+      Function<RequestT, Map<String, Object>> queryParameters,
       Function<RequestT, String> body) {
     this.method = method;
     this.requestUrl = requestUrl;
@@ -43,7 +43,7 @@ public String requestUrl(RequestT request) {
   }
 
   @Override
-  public Map<String, String> queryParameters(RequestT request) {
+  public Map<String, Object> queryParameters(RequestT request) {
     return queryParameters.apply(request);
   }
 
@@ -59,16 +59,24 @@ public boolean isError(int statusCode) {
 
   @Override
   public String deserializeError(int statusCode, String responseBody) {
-    var response = JSON.deserialize(responseBody, ErrorResponse.class);
-    if (response.errors.isEmpty()) {
-      return "";
-
+    {
+      var response = JSON.deserialize(responseBody, ErrorResponse1.class);
+      if (response.errors != null && !response.errors.isEmpty()) {
+        return response.errors.get(0).message();
+      }
+    }
+    var response = JSON.deserialize(responseBody, ErrorResponse2.class);
+    if (response.error != null && !response.error.isBlank()) {
+      return response.error;
     }
-    return response.errors.get(0).text();
+    return responseBody;
   }
 
-  static record ErrorResponse(@SerializedName("error") List<ErrorMessage> errors) {
-    private static record ErrorMessage(@SerializedName("message") String text) {
+  private static record ErrorResponse1(@SerializedName("error") List<ErrorMessage> errors) {
+    private static record ErrorMessage(@SerializedName("message") String message) {
     }
   }
+
+  private static record ErrorResponse2(@SerializedName("message") String error) {
+  }
 }
diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/OptionalEndpoint.java b/src/main/java/io/weaviate/client6/v1/internal/rest/OptionalEndpoint.java
index 0b6052573..c3863bf97 100644
--- a/src/main/java/io/weaviate/client6/v1/internal/rest/OptionalEndpoint.java
+++ b/src/main/java/io/weaviate/client6/v1/internal/rest/OptionalEndpoint.java
@@ -10,7 +10,7 @@ public class OptionalEndpoint<RequestT, ResponseT> extends SimpleEndpoint<Reques
   public static <RequestT, ResponseT> OptionalEndpoint<RequestT, ResponseT> noBodyOptional(
       Function<RequestT, String> method,
       Function<RequestT, String> requestUrl,
-      Function<RequestT, Map<String, String>> queryParameters,
+      Function<RequestT, Map<String, Object>> queryParameters,
       BiFunction<Integer, String, ResponseT> deserializeResponse) {
     return new OptionalEndpoint<>(method, requestUrl, queryParameters, nullBody(), deserializeResponse);
   }
@@ -18,7 +18,7 @@ public static <RequestT, ResponseT> OptionalEndpoint<RequestT, ResponseT> noBody
   public OptionalEndpoint(
       Function<RequestT, String> method,
       Function<RequestT, String> requestUrl,
-      Function<RequestT, Map<String, String>> queryParameters,
+      Function<RequestT, Map<String, Object>> queryParameters,
       Function<RequestT, String> body,
       BiFunction<Integer, String, ResponseT> deserializeResponse) {
     super(method, requestUrl, queryParameters, body, optional(deserializeResponse));
diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/SimpleEndpoint.java b/src/main/java/io/weaviate/client6/v1/internal/rest/SimpleEndpoint.java
index 9f5c6fa9c..963cf4e3a 100644
--- a/src/main/java/io/weaviate/client6/v1/internal/rest/SimpleEndpoint.java
+++ b/src/main/java/io/weaviate/client6/v1/internal/rest/SimpleEndpoint.java
@@ -17,7 +17,7 @@ protected static BiFunction<Integer, String, Void> nullResponse() {
   public static <RequestT, ResponseT> SimpleEndpoint<RequestT, ResponseT> noBody(
       Function<RequestT, String> method,
       Function<RequestT, String> requestUrl,
-      Function<RequestT, Map<String, String>> queryParameters,
+      Function<RequestT, Map<String, Object>> queryParameters,
       BiFunction<Integer, String, ResponseT> deserializeResponse) {
     return new SimpleEndpoint<>(method, requestUrl, queryParameters, nullBody(), deserializeResponse);
   }
@@ -25,7 +25,7 @@ public static <RequestT, ResponseT> SimpleEndpoint<RequestT, ResponseT> noBody(
   public static <RequestT> SimpleEndpoint<RequestT, Void> sideEffect(
       Function<RequestT, String> method,
       Function<RequestT, String> requestUrl,
-      Function<RequestT, Map<String, String>> queryParameters,
+      Function<RequestT, Map<String, Object>> queryParameters,
       Function<RequestT, String> body) {
     return new SimpleEndpoint<>(method, requestUrl, queryParameters, body, nullResponse());
   }
@@ -33,14 +33,14 @@ public static <RequestT> SimpleEndpoint<RequestT, Void> sideEffect(
   public static <RequestT> SimpleEndpoint<RequestT, Void> sideEffect(
       Function<RequestT, String> method,
       Function<RequestT, String> requestUrl,
-      Function<RequestT, Map<String, String>> queryParameters) {
+      Function<RequestT, Map<String, Object>> queryParameters) {
     return new SimpleEndpoint<>(method, requestUrl, queryParameters, nullBody(), nullResponse());
   }
 
   public SimpleEndpoint(
       Function<RequestT, String> method,
       Function<RequestT, String> requestUrl,
-      Function<RequestT, Map<String, String>> queryParameters,
+      Function<RequestT, Map<String, Object>> queryParameters,
       Function<RequestT, String> body,
       BiFunction<Integer, String, ResponseT> deserializeResponse) {
     super(method, requestUrl, queryParameters, body);
diff --git a/src/main/java/io/weaviate/client6/v1/internal/rest/UrlEncoder.java b/src/main/java/io/weaviate/client6/v1/internal/rest/UrlEncoder.java
new file mode 100644
index 000000000..b4a9d2b67
--- /dev/null
+++ b/src/main/java/io/weaviate/client6/v1/internal/rest/UrlEncoder.java
@@ -0,0 +1,44 @@
+package io.weaviate.client6.v1.internal.rest;
+
+import java.io.UnsupportedEncodingException;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+final class UrlEncoder {
+
+  private static String encodeValue(Object value) {
+    try {
+      return URLEncoder.encode(value.toString(), StandardCharsets.UTF_8.toString());
+    } catch (UnsupportedEncodingException e) {
+      throw new AssertionError(e); // should never happen with a standard encoding
+    }
+  }
+
+  /**
+   * Encodes each key-value pair into a URL-compatible query string, omitting any
+   * {@code null} or blank (in case of String parameter) values.
+   * Each value is represented by the return of its [@conde toString()} method.
+   *
+   * @return URL query string or empty string if the map was empty
+   *         or contained no valid parameters.
+   */
+  public static String encodeQuery(Map<String, Object> queryParams) {
+    if (queryParams == null || queryParams.isEmpty()) {
+      return "";
+    }
+    return queryParams.entrySet().stream()
+        .filter(qp -> {
+          if (qp == null) {
+            return false;
+          }
+          if (qp.getValue() instanceof String str) {
+            return !str.isBlank();
+          }
+          return true;
+        })
+        .map(qp -> qp.getKey() + "=" + encodeValue(qp.getValue()))
+        .collect(Collectors.joining("&", "?", ""));
+  }
+}
diff --git a/src/test/java/io/weaviate/client6/v1/api/collections/CollectionHandleDefaultsTest.java b/src/test/java/io/weaviate/client6/v1/api/collections/CollectionHandleDefaultsTest.java
new file mode 100644
index 000000000..4b420b3fd
--- /dev/null
+++ b/src/test/java/io/weaviate/client6/v1/api/collections/CollectionHandleDefaultsTest.java
@@ -0,0 +1,74 @@
+package io.weaviate.client6.v1.api.collections;
+
+import java.util.Map;
+
+import org.assertj.core.api.Assertions;
+import org.junit.Test;
+
+import io.weaviate.client6.v1.api.collections.query.ConsistencyLevel;
+import io.weaviate.client6.v1.internal.ObjectBuilder;
+import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
+
+public class CollectionHandleDefaultsTest {
+  private static final CollectionDescriptor<Map<String, Object>> DESCRIPTOR = CollectionDescriptor.ofMap("Things");
+  private static final CollectionHandleDefaults NONE_DEFAULTS = CollectionHandleDefaults.of(ObjectBuilder.identity());
+
+  /** CollectionHandle with no defaults. */
+  private static final CollectionHandle<Map<String, Object>> HANDLE_NONE = new CollectionHandle<>(
+      null, null, DESCRIPTOR, NONE_DEFAULTS);
+
+  /** CollectionHandleAsync with no defaults. */
+  private static final CollectionHandleAsync<Map<String, Object>> HANDLE_NONE_ASYNC = new CollectionHandleAsync<>(
+      null, null, DESCRIPTOR, NONE_DEFAULTS);
+
+  /** All defaults are {@code null} if none were set. */
+  @Test
+  public void test_defaults() {
+    Assertions.assertThat(HANDLE_NONE.consistencyLevel()).as("default ConsistencyLevel").isNull();
+    Assertions.assertThat(HANDLE_NONE.tenant()).as("default tenant").isNull();
+  }
+
+  /**
+   * {@link CollectionHandle#withConsistencyLevel} should create a copy with
+   * different defaults but not modify the original.
+   */
+  @Test
+  public void test_withConsistencyLevel() {
+    var handle = HANDLE_NONE.withConsistencyLevel(ConsistencyLevel.QUORUM);
+    Assertions.assertThat(handle.consistencyLevel()).isEqualTo(ConsistencyLevel.QUORUM);
+    Assertions.assertThat(HANDLE_NONE.consistencyLevel()).isNull();
+  }
+
+  /**
+   * {@link CollectionHandleAsync#withTenant} should create a copy with
+   * different defaults but not modify the original.
+   */
+  @Test
+  public void test_withConsistencyLevel_async() {
+    var handle = HANDLE_NONE_ASYNC.withConsistencyLevel(ConsistencyLevel.QUORUM);
+    Assertions.assertThat(handle.consistencyLevel()).isEqualTo(ConsistencyLevel.QUORUM);
+    Assertions.assertThat(HANDLE_NONE_ASYNC.consistencyLevel()).isNull();
+  }
+
+  /**
+   * {@link CollectionHandle#withTenant} should create a copy with
+   * different defaults but not modify the original.
+   */
+  @Test
+  public void test_withTenant() {
+    var handle = HANDLE_NONE.withTenant("john_doe");
+    Assertions.assertThat(handle.tenant()).isEqualTo("john_doe");
+    Assertions.assertThat(HANDLE_NONE.consistencyLevel()).isNull();
+  }
+
+  /**
+   * {@link CollectionHandleAsync#withTenant} should create a copy with
+   * different defaults but not modify the original.
+   */
+  @Test
+  public void test_withTenant_async() {
+    var handle = HANDLE_NONE_ASYNC.withTenant("john_doe");
+    Assertions.assertThat(handle.tenant()).isEqualTo("john_doe");
+    Assertions.assertThat(HANDLE_NONE_ASYNC.consistencyLevel()).isNull();
+  }
+}
diff --git a/src/test/java/io/weaviate/client6/v1/api/collections/CollectionHandleTest.java b/src/test/java/io/weaviate/client6/v1/api/collections/CollectionHandleTest.java
new file mode 100644
index 000000000..c9b186afc
--- /dev/null
+++ b/src/test/java/io/weaviate/client6/v1/api/collections/CollectionHandleTest.java
@@ -0,0 +1,256 @@
+package io.weaviate.client6.v1.api.collections;
+
+import java.io.IOException;
+import java.util.Map;
+
+import org.assertj.core.api.Assertions;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import com.google.gson.JsonParser;
+import com.jparams.junit4.JParamsTestRunner;
+import com.jparams.junit4.data.DataMethod;
+import com.jparams.junit4.description.Name;
+
+import io.weaviate.client6.v1.api.collections.data.Reference;
+import io.weaviate.client6.v1.api.collections.query.ConsistencyLevel;
+import io.weaviate.client6.v1.internal.ObjectBuilder;
+import io.weaviate.client6.v1.internal.grpc.protocol.WeaviateProtoBase;
+import io.weaviate.client6.v1.internal.json.JSON;
+import io.weaviate.client6.v1.internal.orm.CollectionDescriptor;
+import io.weaviate.testutil.transport.MockGrpcTransport;
+import io.weaviate.testutil.transport.MockRestTransport;
+
+@RunWith(JParamsTestRunner.class)
+public class CollectionHandleTest {
+  private static MockRestTransport rest;
+  private static MockGrpcTransport grpc;
+
+  @BeforeClass
+  public static void setUp() {
+    rest = new MockRestTransport();
+    grpc = new MockGrpcTransport();
+  }
+
+  @AfterClass
+  public static void tearDown() throws Exception {
+    rest.close();
+    grpc.close();
+  }
+
+  @FunctionalInterface
+  interface Act {
+    void apply(CollectionHandle<Map<String, Object>> client) throws Exception;
+  }
+
+  /** Which part of the request a parameter should be added to. */
+  public static enum Location {
+    /** Query string. */
+    QUERY,
+    /**
+     * Request body. {@code RequestT} must implement {@link WithDefaults} for the
+     * changes to be applied.
+     */
+    BODY;
+  }
+
+  public static Object[][] restTestCases() {
+    return new Object[][] {
+        {
+            "data::insert single object",
+            ConsistencyLevel.ONE, Location.QUERY,
+            "john_doe", Location.BODY,
+            (Act) c -> c.data.insert(Map.of()),
+        },
+        {
+            "data::replace single object",
+            ConsistencyLevel.ONE, Location.QUERY,
+            "john_doe", Location.BODY,
+            (Act) c -> c.data.replace("test-uuid", ObjectBuilder.identity()),
+        },
+        {
+            "data::update single object",
+            ConsistencyLevel.ONE, Location.QUERY,
+            "john_doe", Location.BODY,
+            (Act) c -> c.data.update("test-uuid", ObjectBuilder.identity()),
+        },
+        {
+            "data::delete by id",
+            ConsistencyLevel.ONE, Location.QUERY,
+            "john_doe", Location.QUERY,
+            (Act) c -> c.data.delete("test-uuid"),
+        },
+        {
+            "data::add reference",
+            ConsistencyLevel.ONE, Location.QUERY,
+            "john_doe", Location.QUERY,
+            (Act) c -> c.data.referenceAdd("from-uuid", "from_property", Reference.uuids("to-uuid")),
+        },
+        {
+            "data::add reference many",
+            ConsistencyLevel.ONE, Location.QUERY,
+            "john_doe", Location.QUERY,
+            (Act) c -> c.data.referenceAddMany(),
+        },
+        {
+            "data::replace reference",
+            ConsistencyLevel.ONE, Location.QUERY,
+            "john_doe", Location.QUERY,
+            (Act) c -> c.data.referenceReplace("from-uuid", "from_property", Reference.uuids("to-uuid")),
+        },
+        {
+            "data::delete reference",
+            ConsistencyLevel.ONE, Location.QUERY,
+            "john_doe", Location.QUERY,
+            (Act) c -> c.data.referenceDelete("from-uuid", "from_property", Reference.uuids("to-uuid")),
+        },
+    };
+  }
+
+  @Name("{0}")
+  @DataMethod(source = CollectionHandleTest.class, method = "restTestCases")
+  @Test
+  public void test_collectionHandleDefaults_rest(String __,
+      ConsistencyLevel cl, Location clLoc,
+      String tenant, Location tenantLoc,
+      Act act)
+      throws Exception {
+    // Arrange
+    var collection = CollectionDescriptor.ofMap("Things");
+    var defaults = CollectionHandleDefaults.of(d -> d
+        .consistencyLevel(cl)
+        .tenant(tenant));
+    var client = new CollectionHandle<Map<String, Object>>(rest, grpc, collection, defaults);
+
+    // Act
+    act.apply(client);
+
+    // Assert
+    rest.assertNext((method, requestUrl, body, query) -> {
+      switch (clLoc) {
+        case QUERY:
+          Assertions.assertThat(query).containsEntry("consistency_level", defaults.consistencyLevel());
+          break;
+        case BODY:
+          assertJsonHasValue(body, "consistency_level", defaults.consistencyLevel());
+      }
+
+      switch (tenantLoc) {
+        case QUERY:
+          Assertions.assertThat(query).containsEntry("tenant", defaults.tenant());
+          break;
+        case BODY:
+          assertJsonHasValue(body, "tenant", defaults.tenant());
+      }
+    });
+  }
+
+  public static Object[][] grpcTestCases() {
+    return new Object[][] {
+        { "data::object exists", (Act) c -> c.data.exists("test-uuid") },
+        { "data::delete many", (Act) c -> c.data.deleteMany() },
+
+        { "query::get by id", (Act) c -> c.query.byId("test-uuid") },
+        { "query::fetch objects", (Act) c -> c.query.fetchObjects(ObjectBuilder.identity()) },
+        { "query::bm25", (Act) c -> c.query.bm25("red ballon") },
+        { "query::hybrid", (Act) c -> c.query.hybrid("red ballon") },
+        { "query::nearVector", (Act) c -> c.query.nearVector(new float[] {}) },
+        { "query::nearText", (Act) c -> c.query.nearText("weather in Arizona") },
+        { "query::nearObject", (Act) c -> c.query.nearObject("test-uuid") },
+        { "query::nearImage", (Act) c -> c.query.nearImage("img.jpeg") },
+        { "query::nearAudio", (Act) c -> c.query.nearAudio("song.mp3") },
+        { "query::nearVideo", (Act) c -> c.query.nearVideo("clip.mp4") },
+        { "query::nearDepth", (Act) c -> c.query.nearDepth("20.000 leagues") },
+        { "query::nearThermal", (Act) c -> c.query.nearThermal("Fahrenheit 451") },
+        { "query::nearImu", (Act) c -> c.query.nearImu("6 m/s") },
+
+        { "aggregate::over all", (Act) c -> c.aggregate.overAll(ObjectBuilder.identity()), true },
+        { "aggregate::hybrid", (Act) c -> c.aggregate.hybrid("red balloon", ObjectBuilder.identity()), true },
+        { "aggregate::nearVector", (Act) c -> c.aggregate.nearVector(new float[] {}, ObjectBuilder.identity()), true },
+        { "aggregate::nearText", (Act) c -> c.aggregate.nearText("red balloon", ObjectBuilder.identity()), true },
+        { "aggregate::nearObject", (Act) c -> c.aggregate.nearObject("test-uuid", ObjectBuilder.identity()), true },
+        { "aggregate::nearImage", (Act) c -> c.aggregate.nearImage("img.jpeg", ObjectBuilder.identity()), true },
+        { "aggregate::nearAudio", (Act) c -> c.aggregate.nearAudio("song.mp3", ObjectBuilder.identity()), true },
+        { "aggregate::nearVideo", (Act) c -> c.aggregate.nearVideo("clip.mp4", ObjectBuilder.identity()), true },
+        { "aggregate::nearDepth", (Act) c -> c.aggregate.nearDepth("20.000 leagues", ObjectBuilder.identity()), true },
+        { "aggregate::nearThermal", (Act) c -> c.aggregate.nearThermal("Fahrenheit 451", ObjectBuilder.identity()),
+            true },
+        { "aggregate::nearImu", (Act) c -> c.aggregate.nearImu("6 m/s", ObjectBuilder.identity()), true },
+    };
+  }
+
+  @Name("{0}")
+  @DataMethod(source = CollectionHandleTest.class, method = "grpcTestCases")
+  @Test
+  public void test_collectionHandleDefaults_grpc(String __, Act act, Boolean skipConsistency) throws Exception {
+    // Arrange
+    var collection = CollectionDescriptor.ofMap("Things");
+    var defaults = CollectionHandleDefaults.of(d -> d
+        .consistencyLevel(ConsistencyLevel.ONE)
+        .tenant("john_doe"));
+    var client = new CollectionHandle<Map<String, Object>>(rest, grpc, collection, defaults);
+
+    // Act
+    act.apply(client);
+
+    // Assert
+    grpc.assertNext(json -> {
+      assertJsonHasValue(json, "tenant", "john_doe");
+
+      if (skipConsistency != null && !skipConsistency) {
+        assertJsonHasValue(json, "consistencyLevel",
+            WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE.toString());
+      }
+    });
+  }
+
+  @Test
+  public void test_defaultTenant_getShards() throws IOException {
+    // Arrange
+    var collection = CollectionDescriptor.ofMap("Things");
+    var defaults = CollectionHandleDefaults.of(d -> d
+        .tenant("john_doe"));
+    var client = new CollectionHandle<Map<String, Object>>(rest, grpc, collection, defaults);
+
+    // Act
+    client.config.getShards();
+
+    // Assert
+    rest.assertNext((method, requestUrl, body, query) -> {
+      Assertions.assertThat(query).containsEntry("tenant", defaults.tenant());
+    });
+  }
+
+  @Test
+  public void test_defaultTenant_insertMany() {
+    // Arrange
+    var collection = CollectionDescriptor.ofMap("Things");
+    var defaults = CollectionHandleDefaults.of(d -> d
+        .consistencyLevel(ConsistencyLevel.ONE)
+        .tenant("john_doe"));
+    var client = new CollectionHandle<Map<String, Object>>(rest, grpc, collection, defaults);
+
+    // Act
+    client.data.insertMany(Map.of());
+
+    // Assert
+    grpc.assertNext(json -> {
+      // Tenant is nested in each of the batch objects
+      Assertions.assertThat(json).containsSequence("\"tenant\": \"john_doe\"");
+      assertJsonHasValue(json, "consistencyLevel",
+          WeaviateProtoBase.ConsistencyLevel.CONSISTENCY_LEVEL_ONE.toString());
+    });
+  }
+
+  private static <T> void assertJsonHasValue(String json, String key, T value) {
+    var gotJson = JsonParser.parseString(json).getAsJsonObject();
+    Assertions.assertThat(gotJson.has(key))
+        .describedAs("missing key \"%s\" in %s", key, json)
+        .isTrue();
+
+    var wantValue = JsonParser.parseString(JSON.serialize(value));
+    Assertions.assertThat(gotJson.get(key)).isEqualTo(wantValue);
+  }
+}
diff --git a/src/test/java/io/weaviate/client6/v1/internal/json/JSONTest.java b/src/test/java/io/weaviate/client6/v1/internal/json/JSONTest.java
index 56e189f2e..45607c4f4 100644
--- a/src/test/java/io/weaviate/client6/v1/internal/json/JSONTest.java
+++ b/src/test/java/io/weaviate/client6/v1/internal/json/JSONTest.java
@@ -345,6 +345,7 @@ public void test_serialize(Object cls, Object in, String want) {
 
   }
 
+  @FunctionalInterface
   private interface CustomAssert extends BiConsumer<Object, Object> {
   }
 
diff --git a/src/test/java/io/weaviate/testutil/transport/MockGrpcTransport.java b/src/test/java/io/weaviate/testutil/transport/MockGrpcTransport.java
new file mode 100644
index 000000000..ebea2fea7
--- /dev/null
+++ b/src/test/java/io/weaviate/testutil/transport/MockGrpcTransport.java
@@ -0,0 +1,60 @@
+package io.weaviate.testutil.transport;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import com.google.protobuf.InvalidProtocolBufferException;
+import com.google.protobuf.MessageOrBuilder;
+import com.google.protobuf.util.JsonFormat;
+
+import io.weaviate.client6.v1.internal.grpc.GrpcTransport;
+import io.weaviate.client6.v1.internal.grpc.Rpc;
+
+public class MockGrpcTransport implements GrpcTransport {
+
+  @FunctionalInterface
+  public interface AssertFunction {
+    void apply(String json);
+  }
+
+  private List<MessageOrBuilder> requests = new ArrayList<>();
+
+  public void assertNext(AssertFunction... assertions) {
+    var assertN = Math.min(assertions.length, requests.size());
+    try {
+      for (var i = 0; i < assertN; i++) {
+        var req = requests.get(i);
+        String json;
+        try {
+          json = JsonFormat.printer().print(req);
+        } catch (InvalidProtocolBufferException e) {
+          throw new RuntimeException(e);
+        }
+        assertions[i].apply(json);
+      }
+    } finally {
+      requests.clear();
+    }
+  }
+
+  @Override
+  public <RequestT, RequestM, ReplyM, ResponseT> ResponseT performRequest(RequestT request,
+      Rpc<RequestT, RequestM, ResponseT, ReplyM> rpc) {
+    var r = rpc.marshal(request);
+    requests.add((MessageOrBuilder) r);
+    return null;
+  }
+
+  @Override
+  public <RequestT, RequestM, ReplyM, ResponseT> CompletableFuture<ResponseT> performRequestAsync(RequestT request,
+      Rpc<RequestT, RequestM, ResponseT, ReplyM> rpc) {
+    requests.add((MessageOrBuilder) rpc.marshal(request));
+    return null;
+  }
+
+  @Override
+  public void close() throws IOException {
+  }
+}
diff --git a/src/test/java/io/weaviate/testutil/transport/MockRestTransport.java b/src/test/java/io/weaviate/testutil/transport/MockRestTransport.java
new file mode 100644
index 000000000..1ae6c4498
--- /dev/null
+++ b/src/test/java/io/weaviate/testutil/transport/MockRestTransport.java
@@ -0,0 +1,58 @@
+package io.weaviate.testutil.transport;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+
+import io.weaviate.client6.v1.internal.rest.Endpoint;
+import io.weaviate.client6.v1.internal.rest.RestTransport;
+
+public class MockRestTransport implements RestTransport {
+
+  private record Request<RequestT>(String method, String requestUrl, String body,
+      Map<String, Object> queryParameters) {
+
+    Request(RequestT req, Endpoint<RequestT, ?> ep) {
+      this(ep.method(req), ep.requestUrl(req), ep.body(req), ep.queryParameters(req));
+    }
+  }
+
+  @FunctionalInterface
+  public interface AssertFunction {
+    void apply(String method, String requestUrl, String body, Map<String, Object> queryParameters);
+  }
+
+  private List<Request<?>> requests = new ArrayList<>();
+
+  public void assertNext(AssertFunction... assertions) {
+    var assertN = Math.min(assertions.length, requests.size());
+    try {
+      for (var i = 0; i < assertN; i++) {
+        var req = requests.get(i);
+        assertions[i].apply(req.method, req.requestUrl, req.body, req.queryParameters);
+      }
+    } finally {
+      requests.clear();
+    }
+  }
+
+  @Override
+  public <RequestT, ResponseT, ExceptionT> ResponseT performRequest(RequestT request,
+      Endpoint<RequestT, ResponseT> endpoint) throws IOException {
+    requests.add(new Request<>(request, endpoint));
+    return null;
+  }
+
+  @Override
+  public <RequestT, ResponseT, ExceptionT> CompletableFuture<ResponseT> performRequestAsync(RequestT request,
+      Endpoint<RequestT, ResponseT> endpoint) {
+    requests.add(new Request<>(request, endpoint));
+    return null;
+  }
+
+  @Override
+  public void close() throws IOException {
+  }
+}