diff --git a/CHANGELOG.md b/CHANGELOG.md
index 0bca6d4..7d8367d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -16,6 +16,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Fixed
 
 - Parsing server URLs with an additional path, [PR-102](https://github.com/reductstore/reduct-cpp/pull/102)
+- Fix Multi-entry API implementation,[PR-108](https://github.com/reductstore/reduct-cpp/pull/108)
 
 ## [1.17.1] - 2025-11-17
 
diff --git a/src/reduct/bucket.cc b/src/reduct/bucket.cc
index a25fd73..473dc37 100644
--- a/src/reduct/bucket.cc
+++ b/src/reduct/bucket.cc
@@ -1,4 +1,4 @@
-// Copyright 2022-2024 ReductSoftware UG
+// Copyright 2022-2026 ReductSoftware UG
 
 #include "reduct/bucket.h"
 #define FMT_HEADER_ONLY 1
@@ -23,6 +23,7 @@
 
 #include "reduct/internal/batch_v1.h"
 #include "reduct/internal/batch_v2.h"
+#include "reduct/internal/headers.h"
 #include "reduct/internal/http_client.h"
 #include "reduct/internal/serialisation.h"
 
@@ -165,15 +166,27 @@ class Bucket : public IBucket {
   }
 
   Result<BatchErrors> WriteBatch(std::string_view entry_name, BatchCallback callback) const noexcept override {
-    return ProcessBatch(entry_name, std::move(callback), BatchType::kWrite);
+    return ProcessBatchV1(entry_name, std::move(callback), BatchType::kWrite);
+  }
+
+  Result<BatchRecordErrors> WriteBatch(BatchCallback callback) const noexcept override {
+    return ProcessBatchV2(std::move(callback), BatchType::kWrite);
   }
 
   Result<BatchErrors> UpdateBatch(std::string_view entry_name, BatchCallback callback) const noexcept override {
-    return ProcessBatch(entry_name, std::move(callback), BatchType::kUpdate);
+    return ProcessBatchV1(entry_name, std::move(callback), BatchType::kUpdate);
+  }
+
+  Result<BatchRecordErrors> UpdateBatch(BatchCallback callback) const noexcept override {
+    return ProcessBatchV2(std::move(callback), BatchType::kUpdate);
   }
 
   Result<BatchErrors> RemoveBatch(std::string_view entry_name, BatchCallback callback) const noexcept override {
-    return ProcessBatch(entry_name, std::move(callback), BatchType::kRemove);
+    return ProcessBatchV1(entry_name, std::move(callback), BatchType::kRemove);
+  }
+
+  Result<BatchRecordErrors> RemoveBatch(BatchCallback callback) const noexcept override {
+    return ProcessBatchV2(std::move(callback), BatchType::kRemove);
   }
 
   Error Update(std::string_view entry_name, const WriteOptions& options) const noexcept override {
@@ -209,16 +222,30 @@ class Bucket : public IBucket {
   Error Query(std::string_view entry_name, std::optional<Time> start, std::optional<Time> stop, QueryOptions options,
               ReadRecordCallback callback) const noexcept override {
     if (SupportsBatchProtocolV2()) {
-      return QueryV2(entry_name, start, stop, options, callback);
+      const auto entries = std::vector{std::string(entry_name)};
+      return QueryV2(entries, start, stop, options, callback);
     }
 
     return QueryV1(entry_name, start, stop, options, callback);
   }
 
+  Error Query(const std::vector<std::string>& entry_names, std::optional<Time> start, std::optional<Time> stop,
+              QueryOptions options, ReadRecordCallback callback) const noexcept override {
+    if (!SupportsBatchProtocolV2()) {
+      return Error{.code = -1, .message = "Batch protocol v2 not supported"};
+    }
+
+    if (entry_names.empty()) {
+      return Error{.code = -1, .message = "No entry names provided"};
+    }
+
+    return QueryV2(entry_names, start, stop, options, callback);
+  }
+
   Error QueryV1(std::string_view entry_name, std::optional<Time> start, std::optional<Time> stop, QueryOptions options,
                 const ReadRecordCallback& callback) const {
     std::string body;
-    auto [json_payload, json_err] = QueryOptionsToJsonString("QUERY", start, stop, options);
+    auto [json_payload, json_err] = QueryOptionsToJsonString("QUERY", {}, start, stop, options);
     if (json_err) {
       return json_err;
     }
@@ -262,21 +289,12 @@ class Bucket : public IBucket {
     return Error::kOk;
   }
 
-  Error QueryV2(std::string_view entry_name, std::optional<Time> start, std::optional<Time> stop, QueryOptions options,
-                const ReadRecordCallback& callback) const {
-    auto [json_payload, json_err] = QueryOptionsToJsonString("QUERY", start, stop, options);
+  Error QueryV2(const std::vector<std::string>& entries, std::optional<Time> start, std::optional<Time> stop,
+                QueryOptions options, const ReadRecordCallback& callback) const {
+    auto [json_payload, json_err] = QueryOptionsToJsonString("QUERY", entries, start, stop, options);
     if (json_err) {
       return json_err;
     }
-    auto entries = ParseEntryList(entry_name);
-    if (entries.empty()) {
-      return Error{.code = 400, .message = "Entry name is required"};
-    }
-
-    json_payload["entries"] = nlohmann::ordered_json::array();
-    for (const auto& entry : entries) {
-      json_payload["entries"].push_back(entry);
-    }
 
     auto [resp, resp_err] = client_->PostWithResponse(fmt::format("{}/q", io_path_), json_payload.dump());
     if (resp_err) {
@@ -317,16 +335,30 @@ class Bucket : public IBucket {
   Result<uint64_t> RemoveQuery(std::string_view entry_name, std::optional<Time> start, std::optional<Time> stop,
                                QueryOptions options) const noexcept override {
     if (SupportsBatchProtocolV2()) {
-      return RemoveQueryV2(entry_name, start, stop, options);
+      const auto entries = std::vector<std::string>{std::string(entry_name)};
+      return RemoveQueryV2(entries, start, stop, options);
     }
 
     return RemoveQueryV1(entry_name, start, stop, options);
   }
 
+  Result<uint64_t> RemoveQuery(std::vector<std::string> entry_names, std::optional<Time> start,
+                               std::optional<Time> stop, QueryOptions options) const noexcept override {
+    if (!SupportsBatchProtocolV2()) {
+      return {0, Error{.code = -1, .message = "Batch protocol v2 not supported"}};
+    }
+
+    if (entry_names.empty()) {
+      return {0, Error{.code = -1, .message = "No entry names provided"}};
+    }
+
+    return RemoveQueryV2(entry_names, start, stop, options);
+  }
+
   Result<uint64_t> RemoveQueryV1(std::string_view entry_name, std::optional<Time> start, std::optional<Time> stop,
                                  QueryOptions options) const {
     std::string body;
-    auto [json_payload, json_err] = QueryOptionsToJsonString("REMOVE", start, stop, options);
+    auto [json_payload, json_err] = QueryOptionsToJsonString("REMOVE", {}, start, stop, options);
     if (json_err) {
       return {0, std::move(json_err)};
     }
@@ -346,19 +378,14 @@ class Bucket : public IBucket {
     }
   }
 
-  Result<uint64_t> RemoveQueryV2(std::string_view entry_name, std::optional<Time> start, std::optional<Time> stop,
-                                 QueryOptions options) const {
-    auto [json_payload, json_err] = QueryOptionsToJsonString("REMOVE", start, stop, options);
+  Result<uint64_t> RemoveQueryV2(const std::vector<std::string>& entries, std::optional<Time> start,
+                                 std::optional<Time> stop, QueryOptions options) const {
+    auto [json_payload, json_err] = QueryOptionsToJsonString("REMOVE", entries, start, stop, options);
     if (json_err) {
       return {0, std::move(json_err)};
     }
-    auto entries = ParseEntryList(entry_name);
     if (entries.empty()) {
-      return {0, Error{.code = 400, .message = "Entry name is required"}};
-    }
-    json_payload["entries"] = nlohmann::ordered_json::array();
-    for (const auto& entry : entries) {
-      json_payload["entries"].push_back(entry);
+      return {0, Error{.code = -1, .message = "At least one entry name is required"}};
     }
 
     auto [resp, resp_err] = client_->PostWithResponse(fmt::format("{}/q", io_path_), json_payload.dump());
@@ -392,8 +419,8 @@ class Bucket : public IBucket {
     return Error::kOk;
   }
 
-  Result<std::string> CreateQueryLink(std::string entry_name, QueryLinkOptions options) const noexcept override {
-    auto [json_payload, json_err] = internal::QueryLinkOptionsToJsonString(name_, entry_name, options);
+  Result<std::string> CreateQueryLink(std::string_view entry_name, QueryLinkOptions options) const noexcept override {
+    auto [json_payload, json_err] = internal::QueryLinkOptionsToJsonString(name_, {std::string(entry_name)}, options);
 
     auto file_name =
         options.file_name ? *options.file_name : fmt::format("{}_{}.bin", entry_name, options.record_index);
@@ -410,6 +437,31 @@ class Bucket : public IBucket {
     }
   }
 
+  Result<std::string> CreateQueryLink(const std::vector<std::string>& entries,
+                                      QueryLinkOptions options) const noexcept override {
+    if (!SupportsBatchProtocolV2()) {
+      return {{}, Error{.code = -1, .message = "Batch protocol v2 not supported"}};
+    }
+    if (entries.empty()) {
+      return {{}, Error{.code = -1, .message = "At least one entry name is required"}};
+    }
+
+    auto [json_payload, json_err] = internal::QueryLinkOptionsToJsonString(name_, entries, options);
+
+    auto file_name = options.file_name ? *options.file_name : fmt::format("{}_{}.bin", name_, options.record_index);
+    auto [body, err] = client_->PostWithResponse(fmt::format("/links/{}", file_name), json_payload.dump());
+    if (err) {
+      return {{}, std::move(err)};
+    }
+
+    try {
+      auto data = nlohmann::json::parse(body);
+      return {data.at("link").get<std::string>(), Error::kOk};
+    } catch (const std::exception& ex) {
+      return {{}, Error{.code = -1, .message = ex.what()}};
+    }
+  }
+
  private:
   enum class ReadType {
     kSingle,
@@ -487,7 +539,7 @@ class Bucket : public IBucket {
     bool stopped = false;
 
     IHttpClient::Headers request_headers;
-    request_headers.emplace("x-reduct-query-id", std::to_string(query_id));
+    request_headers.emplace(std::string(internal::kHeaderQueryId), std::to_string(query_id));
 
     auto parse_headers_and_receive_data = [&stopped, &data, &data_mutex, &callback, &future, head,
                                            this](IHttpClient::Headers&& headers) {
@@ -545,14 +597,14 @@ class Bucket : public IBucket {
                                                   bool head, IHttpClient::Headers&& headers) {
     ReadableRecord record;
 
-    record.timestamp = internal::FromMicroseconds(headers["x-reduct-time"]);
+    record.timestamp = internal::FromMicroseconds(headers[std::string(internal::kHeaderTime)]);
     record.size = std::stoi(headers["content-length"]);
     record.content_type = headers["content-type"];
-    record.last = headers["x-reduct-last"] == "1";
+    record.last = headers[std::string(internal::kHeaderLast)] == "1";
 
     for (const auto& [key, value] : headers) {
-      if (key.starts_with("x-reduct-label-")) {
-        record.labels.emplace(key.substr(15), value);
+      if (key.starts_with(internal::kHeaderLabelPrefix)) {
+        record.labels.emplace(std::string(key.substr(internal::kHeaderLabelPrefix.size())), value);
       }
     }
 
@@ -593,7 +645,7 @@ class Bucket : public IBucket {
   IHttpClient::Headers MakeHeadersFromLabels(const WriteOptions& options) const {
     IHttpClient::Headers headers;
     for (const auto& [key, value] : options.labels) {
-      headers.emplace(fmt::format("x-reduct-label-{}", key), value);
+      headers.emplace(fmt::format("{}{}", internal::kHeaderLabelPrefix, key), value);
     }
     return headers;
   }
@@ -603,52 +655,50 @@ class Bucket : public IBucket {
     return api_version && internal::IsCompatible("1.18", *api_version);
   }
 
-  static std::string TrimWhitespace(std::string_view value) {
-    auto start = value.find_first_not_of(" \t");
-    if (start == std::string_view::npos) {
-      return "";
-    }
-    auto end = value.find_last_not_of(" \t");
-    return std::string(value.substr(start, end - start + 1));
-  }
-
-  static std::vector<std::string> ParseEntryList(std::string_view entries_raw) {
-    std::vector<std::string> entries;
-    size_t start = 0;
-    while (start < entries_raw.size()) {
-      auto comma = entries_raw.find(',', start);
-      auto slice =
-          entries_raw.substr(start, comma == std::string_view::npos ? entries_raw.size() - start : comma - start);
-      auto trimmed = TrimWhitespace(slice);
-      if (!trimmed.empty()) {
-        entries.emplace_back(std::move(trimmed));
-      }
-      if (comma == std::string_view::npos) {
-        break;
-      }
-      start = comma + 1;
-    }
+  Result<BatchErrors> ProcessBatchV1(std::string_view entry_name, BatchCallback callback,
+                                     BatchType type) const noexcept {
+    Batch batch;
+    callback(&batch);
 
-    if (entries.empty() && !entries_raw.empty()) {
-      auto trimmed = TrimWhitespace(entries_raw);
-      if (!trimmed.empty()) {
-        entries.emplace_back(std::move(trimmed));
-      }
+    if (SupportsBatchProtocolV2()) {
+      return internal::ProcessBatchV2(client_.get(), io_path_, entry_name, std::move(batch), type);
     }
 
-    return entries;
+    return internal::ProcessBatchV1(client_.get(), path_, entry_name, std::move(batch), type);
   }
 
-  Result<WriteBatchErrors> ProcessBatch(std::string_view entry_name, BatchCallback callback,
-                                        BatchType type) const noexcept {
+  Result<BatchRecordErrors> ProcessBatchV2(BatchCallback callback, BatchType type) const noexcept {
     Batch batch;
     callback(&batch);
 
+    if (batch.records().empty()) {
+      return {BatchRecordErrors{}, Error::kOk};
+    }
+
     if (SupportsBatchProtocolV2()) {
-      return internal::ProcessBatchV2(client_.get(), io_path_, entry_name, std::move(batch), type);
+      return internal::ProcessBatchV2Records(client_.get(), io_path_, std::move(batch), type);
     }
 
-    return internal::ProcessBatchV1(client_.get(), path_, entry_name, std::move(batch), type);
+    std::string entry_name;
+    for (const auto& record : batch.records()) {
+      if (!record.entry.empty()) {
+        entry_name = record.entry;
+        break;
+      }
+    }
+
+    if (entry_name.empty()) {
+      return {{}, Error{.code = 400, .message = "Entry name is required"}};
+    }
+
+    auto [errors, err] = internal::ProcessBatchV1(client_.get(), path_, entry_name, std::move(batch), type);
+    if (err) {
+      return {{}, err};
+    }
+
+    BatchRecordErrors record_errors;
+    record_errors.emplace(std::move(entry_name), std::move(errors));
+    return {record_errors, Error::kOk};
   }
 
   std::unique_ptr<internal::IHttpClient> client_;
@@ -667,8 +717,8 @@ std::unique_ptr<IBucket> IBucket::Build(std::string_view server_url, std::string
   return std::make_unique<Bucket>(server_url, name, options);
 }
 
-std::unique_ptr<IBucket> IBucket::Build(std::string_view server_url, std::string_view name,
-                                        const HttpOptions& options, std::optional<std::string> api_version) noexcept {
+std::unique_ptr<IBucket> IBucket::Build(std::string_view server_url, std::string_view name, const HttpOptions& options,
+                                        std::optional<std::string> api_version) noexcept {
   return std::make_unique<Bucket>(server_url, name, options, std::move(api_version));
 }
 
diff --git a/src/reduct/bucket.h b/src/reduct/bucket.h
index 13bc9c4..dc5a5ae 100644
--- a/src/reduct/bucket.h
+++ b/src/reduct/bucket.h
@@ -1,4 +1,4 @@
-// Copyright 2022-2025 ReductSoftware UG
+// Copyright 2022-2026 ReductSoftware UG
 #ifndef REDUCT_CPP_BUCKET_H
 #define REDUCT_CPP_BUCKET_H
 
@@ -36,7 +36,7 @@ class IBucket {
    */
   enum class Status { kReady, kDeleting };
 
-  /**
+  /**se
    * Bucket Settings
    */
   struct Settings {
@@ -215,12 +215,9 @@ class IBucket {
 
     [[nodiscard]] const std::vector<Record>& records() const { return records_; }
 
-    [[nodiscard]] std::string Slice(size_t offset, size_t size) const {
-      return Slice(std::nullopt, offset, size);
-    }
+    [[nodiscard]] std::string Slice(size_t offset, size_t size) const { return Slice(std::nullopt, offset, size); }
 
-    [[nodiscard]] std::string Slice(const std::optional<std::vector<size_t>>& order, size_t offset,
-                                    size_t size) const {
+    [[nodiscard]] std::string Slice(const std::optional<std::vector<size_t>>& order, size_t offset, size_t size) const {
       if (offset >= size_) {
         return "";
       }
@@ -277,8 +274,8 @@ class IBucket {
   /**
    * @deprecated Use BatchErrors instead
    */
-  using WriteBatchErrors = std::map<Time, Error>;
   using BatchErrors = std::map<Time, Error>;
+  using BatchRecordErrors = std::map<std::string, BatchErrors>;
 
   /**
    * Read a record in chunks
@@ -337,6 +334,13 @@ class IBucket {
   [[nodiscard]] virtual Result<BatchErrors> WriteBatch(std::string_view entry_name,
                                                        BatchCallback callback) const noexcept = 0;
 
+  /**
+   * Write a batch of records in one HTTP request (targeting multiple entries)
+   * @param callback a callback to add records to batch
+   * @return HTTP error or map of errors for each record
+   */
+  [[nodiscard]] virtual Result<BatchRecordErrors> WriteBatch(BatchCallback callback) const noexcept = 0;
+
   /**
    * Write labels of an existing record
    *
@@ -357,6 +361,14 @@ class IBucket {
    */
   [[nodiscard]] virtual Result<BatchErrors> UpdateBatch(std::string_view entry_name,
                                                         BatchCallback callback) const noexcept = 0;
+
+  /**
+   * Update labels of existing records in a batch (targeting multiple entries)
+   * @param callback a callback to add records to batch
+   * @return HTTP error or map of errors for each record
+   */
+  [[nodiscard]] virtual Result<BatchRecordErrors> UpdateBatch(BatchCallback callback) const noexcept = 0;
+
   /**
    * Query options
    */
@@ -381,7 +393,7 @@ class IBucket {
   };
 
   /**
-   * Query data for a time interval
+   * @brief Query data for a time interval
    * @param entry_name
    * @param start start time point ,if nullopt then from very beginning
    * @param stop stop time point, if nullopt then until the last record
@@ -389,9 +401,21 @@ class IBucket {
    * @param callback return  next record If you want to stop querying, return false
    * @return
    */
-  [[nodiscard]] virtual Error Query(
-      std::string_view entry_name, std::optional<Time> start, std::optional<Time> stop, QueryOptions options,
-      ReadRecordCallback callback = [](auto) { return false; }) const noexcept = 0;
+  [[nodiscard]] virtual Error Query(std::string_view entry_name, std::optional<Time> start, std::optional<Time> stop,
+                                    QueryOptions options, ReadRecordCallback callback) const noexcept = 0;
+
+  /**
+   * @brief  Query data for multiple entries for a time interval
+   * @param entry_names
+   * @param start start time point ,if nullopt then from very beginning
+   * @param stop stop time point, if nullopt then until the last record
+   * @param options
+   * @param callback return  next record If you want to stop querying, return false
+   * @return
+   */
+  [[nodiscard]] virtual Error Query(const std::vector<std::string>& entry_names, std::optional<Time> start,
+                                    std::optional<Time> stop, QueryOptions options,
+                                    ReadRecordCallback callback) const noexcept = 0;
   /**
    * @brief Get settings by HTTP request
    * @return settings or HTTP error
@@ -447,7 +471,14 @@ class IBucket {
   virtual Result<BatchErrors> RemoveBatch(std::string_view entry_name, BatchCallback callback) const noexcept = 0;
 
   /**
-   * @brief Remove revision of an entry by query
+   * @brief Remove a batch of records from multiple entries
+   * @param callback a callback to add records to batch
+   * @return HTTP error or map of errors for each record
+   */
+  virtual Result<BatchRecordErrors> RemoveBatch(BatchCallback callback) const noexcept = 0;
+
+  /**
+   * @brief Remove records of an entry by query
    * @param entry_name
    * @param start start time point
    * @param stop stop time point
@@ -457,6 +488,17 @@ class IBucket {
   virtual Result<uint64_t> RemoveQuery(std::string_view entry_name, std::optional<Time> start, std::optional<Time> stop,
                                        QueryOptions options) const noexcept = 0;
 
+  /**
+   * @brief Remove records of multiple entries by query
+   * @param entries vector of entry names
+   * @param start start time point
+   * @param stop stop time point
+   * @param options query options. TTL, continuous, poll_interval, head_only are ignored
+   * @return HTTP  error or number of removed records
+   */
+  virtual Result<uint64_t> RemoveQuery(std::vector<std::string> entries, std::optional<Time> start,
+                                       std::optional<Time> stop, QueryOptions options) const noexcept = 0;
+
   /**
    * @brief Rename an entry
    * @param old_name entry name to rename
@@ -488,19 +530,30 @@ class IBucket {
    * @param options options for the query link
    * @return a query link or an error
    */
-  virtual Result<std::string> CreateQueryLink(std::string entry_name, QueryLinkOptions options) const noexcept = 0;
+  virtual Result<std::string> CreateQueryLink(std::string_view entry_name, QueryLinkOptions options) const noexcept = 0;
+
+  /**
+   * @brief  Creates a query link for accessing data
+   *
+   * You can specify multiple entries in the bucket
+   *
+   * @param entries list of entries in the bucket
+   * @param options options for the query link
+   * @return a query link or an error
+   */
+  virtual Result<std::string> CreateQueryLink(const std::vector<std::string>& entries,
+                                              QueryLinkOptions options) const noexcept = 0;
 
   /**
    * @brief Creates a new bucket
    * @param server_url HTTP url
    * @param name name of the bucket
-  * @param options HTTP options
-  * @return a pointer to the bucket
-  */
+   * @param options HTTP options
+   * @return a pointer to the bucket
+   */
   static std::unique_ptr<IBucket> Build(std::string_view server_url, std::string_view name,
                                         const HttpOptions& options) noexcept;
-  static std::unique_ptr<IBucket> Build(std::string_view server_url, std::string_view name,
-                                        const HttpOptions& options,
+  static std::unique_ptr<IBucket> Build(std::string_view server_url, std::string_view name, const HttpOptions& options,
                                         std::optional<std::string> api_version) noexcept;
 };
 }  // namespace reduct
diff --git a/src/reduct/internal/batch_v1.cc b/src/reduct/internal/batch_v1.cc
index ab96f76..712c2c5 100644
--- a/src/reduct/internal/batch_v1.cc
+++ b/src/reduct/internal/batch_v1.cc
@@ -1,6 +1,7 @@
 // Copyright 2026 ReductSoftware UG
 
 #include "reduct/internal/batch_v1.h"
+#include "reduct/internal/headers.h"
 
 #include <fmt/core.h>
 #include <fmt/ranges.h>
@@ -121,19 +122,20 @@ std::vector<IBucket::ReadableRecord> ParseAndBuildBatchedRecordsV1(
   };
 
   std::vector<IBucket::ReadableRecord> records;
-  size_t total_records = std::count_if(
-      headers.begin(), headers.end(), [](const auto& header) { return header.first.starts_with("x-reduct-time-"); });
+  size_t total_records = std::count_if(headers.begin(), headers.end(), [](const auto& header) {
+    return header.first.starts_with(kHeaderTimePrefix);
+  });
 
   std::map<std::string, std::string> ordered_headers(headers.begin(), headers.end());
   for (auto header = ordered_headers.begin(); header != ordered_headers.end(); ++header) {
-    if (!header->first.starts_with("x-reduct-time-")) {
+    if (!header->first.starts_with(kHeaderTimePrefix)) {
       continue;
     }
 
     auto [size, content_type, labels] = parse_csv(header->second);
 
     IBucket::ReadableRecord record;
-    record.timestamp = FromMicroseconds(header->first.substr(14));
+    record.timestamp = FromMicroseconds(std::string(header->first.substr(kHeaderTimePrefix.size())));
     record.size = size;
     record.content_type = content_type;
     record.labels = labels;
@@ -181,15 +183,15 @@ std::vector<IBucket::ReadableRecord> ParseAndBuildBatchedRecordsV1(
       return Error::kOk;
     };
 
-    record.last = (records.size() == total_records - 1 && headers["x-reduct-last"] == "true");
+    record.last = (records.size() == total_records - 1 && headers[std::string(kHeaderLast)] == "true");
     records.push_back(std::move(record));
   }
 
   return records;
 }
 
-Result<IBucket::WriteBatchErrors> ProcessBatchV1(IHttpClient* client, std::string_view bucket_path,
-                                                 std::string_view entry_name, IBucket::Batch batch, BatchType type) {
+Result<IBucket::BatchErrors> ProcessBatchV1(IHttpClient* client, std::string_view bucket_path,
+                                            std::string_view entry_name, IBucket::Batch batch, BatchType type) {
   auto ordered = SortRecords(batch, std::string(entry_name), false);
 
   std::set<std::string> unique_entries;
@@ -207,7 +209,7 @@ Result<IBucket::WriteBatchErrors> ProcessBatchV1(IHttpClient* client, std::strin
   IHttpClient::Headers headers;
   for (auto idx : ordered) {
     const auto& record = batch.records()[idx];
-    const auto key = fmt::format("x-reduct-time-{}", ToMicroseconds(record.timestamp));
+    const auto key = fmt::format("{}{}", kHeaderTimePrefix, ToMicroseconds(record.timestamp));
 
     switch (type) {
       case BatchType::kWrite: {
@@ -251,16 +253,17 @@ Result<IBucket::WriteBatchErrors> ProcessBatchV1(IHttpClient* client, std::strin
     return {{}, err};
   }
 
-  IBucket::WriteBatchErrors errors;
+  IBucket::BatchErrors errors;
   for (const auto& [key, value] : std::get<1>(resp)) {
-    if (key.starts_with("x-reduct-error-")) {
+    if (key.starts_with(kHeaderErrorPrefix)) {
       auto pos = value.find(',');
       if (pos == std::string::npos) {
         continue;
       }
       auto status = std::stoi(value.substr(0, pos));
       auto message = value.substr(pos + 1);
-      errors.emplace(FromMicroseconds(key.substr(15)), Error{.code = status, .message = message});
+      errors.emplace(FromMicroseconds(std::string(key.substr(kHeaderErrorPrefix.size()))),
+                     Error{.code = status, .message = message});
     }
   }
 
diff --git a/src/reduct/internal/batch_v1.h b/src/reduct/internal/batch_v1.h
index 71522ac..71b8965 100644
--- a/src/reduct/internal/batch_v1.h
+++ b/src/reduct/internal/batch_v1.h
@@ -29,8 +29,8 @@ std::vector<size_t> SortRecords(const IBucket::Batch& batch, const std::string&
 std::vector<IBucket::ReadableRecord> ParseAndBuildBatchedRecordsV1(
     std::deque<std::optional<std::string>>* data, std::mutex* mutex, bool head, IHttpClient::Headers&& headers);
 
-Result<IBucket::WriteBatchErrors> ProcessBatchV1(IHttpClient* client, std::string_view bucket_path,
-                                                 std::string_view entry_name, IBucket::Batch batch, BatchType type);
+Result<IBucket::BatchErrors> ProcessBatchV1(IHttpClient* client, std::string_view bucket_path,
+                                            std::string_view entry_name, IBucket::Batch batch, BatchType type);
 
 }  // namespace reduct::internal
 
diff --git a/src/reduct/internal/batch_v2.cc b/src/reduct/internal/batch_v2.cc
index 7f57c2e..276cde1 100644
--- a/src/reduct/internal/batch_v2.cc
+++ b/src/reduct/internal/batch_v2.cc
@@ -6,6 +6,7 @@
 #include <fmt/ranges.h>
 
 #include <algorithm>
+#include <cctype>
 #include <chrono>
 #include <deque>
 #include <limits>
@@ -20,7 +21,8 @@
 #include <unordered_map>
 #include <utility>
 #include <vector>
-#include <cctype>
+
+#include "reduct/internal/headers.h"
 
 namespace reduct::internal {
 
@@ -34,9 +36,9 @@ std::string EncodeEntryName(std::string_view entry) {
   std::string encoded;
   encoded.reserve(entry.size());
   for (const auto ch : entry) {
-    if (std::isalnum(static_cast<unsigned char>(ch)) ||
-        ch == '!' || ch == '#' || ch == '$' || ch == '%' || ch == '&' || ch == '\'' || ch == '*' || ch == '+' ||
-        ch == '-' || ch == '.' || ch == '^' || ch == '_' || ch == '`' || ch == '|' || ch == '~') {
+    if (std::isalnum(static_cast<unsigned char>(ch)) || ch == '!' || ch == '#' || ch == '$' || ch == '%' || ch == '&' ||
+        ch == '\'' || ch == '*' || ch == '+' || ch == '-' || ch == '.' || ch == '^' || ch == '_' || ch == '`' ||
+        ch == '|' || ch == '~') {
       encoded.push_back(ch);
     } else {
       encoded.append(fmt::format("%{:02X}", static_cast<unsigned char>(ch)));
@@ -94,11 +96,11 @@ static std::vector<std::string> ParseEncodedList(std::string_view raw) {
 }
 
 static std::optional<std::pair<size_t, uint64_t>> ParseBatchedHeaderNameV2(const std::string& name) {
-  if (!name.starts_with("x-reduct-") || name.starts_with("x-reduct-error-")) {
+  if (!name.starts_with(kHeaderPrefix) || name.starts_with(kHeaderErrorPrefix)) {
     return std::nullopt;
   }
 
-  auto suffix = name.substr(std::string("x-reduct-").size());
+  auto suffix = name.substr(kHeaderPrefix.size());
   auto dash = suffix.rfind('-');
   if (dash == std::string::npos) {
     return std::nullopt;
@@ -129,9 +131,8 @@ static std::vector<std::pair<std::string, std::optional<std::string>>> ParseLabe
     auto raw_key = Trim(raw.substr(pos, eq - pos));
     std::string key = raw_key;
     if (label_names) {
-      bool digits = !key.empty() && std::all_of(key.begin(), key.end(), [](char ch) {
-                        return std::isdigit(static_cast<unsigned char>(ch));
-                      });
+      bool digits = !key.empty() && std::all_of(key.begin(), key.end(),
+                                                [](char ch) { return std::isdigit(static_cast<unsigned char>(ch)); });
       if (digits) {
         auto idx = std::stoul(key);
         if (idx < label_names->size()) {
@@ -232,11 +233,12 @@ static std::optional<RecordHeaderV2> ParseRecordHeaderV2(const std::string& raw,
   return RecordHeaderV2{content_length, std::move(content_type), std::move(labels)};
 }
 
-std::vector<IBucket::ReadableRecord> ParseAndBuildBatchedRecordsV2(
-    std::deque<std::optional<std::string>>* data, std::mutex* mutex, bool head, IHttpClient::Headers&& headers) {
+std::vector<IBucket::ReadableRecord> ParseAndBuildBatchedRecordsV2(std::deque<std::optional<std::string>>* data,
+                                                                   std::mutex* mutex, bool head,
+                                                                   IHttpClient::Headers&& headers) {
   std::vector<IBucket::ReadableRecord> records;
-  auto entries_it = headers.find("x-reduct-entries");
-  auto start_ts_it = headers.find("x-reduct-start-ts");
+  auto entries_it = headers.find(std::string(kHeaderEntries));
+  auto start_ts_it = headers.find(std::string(kHeaderStartTs));
   if (entries_it == headers.end() || start_ts_it == headers.end()) {
     return records;
   }
@@ -254,7 +256,7 @@ std::vector<IBucket::ReadableRecord> ParseAndBuildBatchedRecordsV2(
   }
 
   std::optional<std::vector<std::string>> label_names;
-  if (auto labels_it = headers.find("x-reduct-labels"); labels_it != headers.end()) {
+  if (auto labels_it = headers.find(std::string(kHeaderLabels)); labels_it != headers.end()) {
     label_names = ParseEncodedList(labels_it->second);
   }
 
@@ -342,7 +344,7 @@ std::vector<IBucket::ReadableRecord> ParseAndBuildBatchedRecordsV2(
     records.push_back(std::move(record));
   }
 
-  if (!records.empty() && headers["x-reduct-last"] == "true") {
+  if (!records.empty() && headers[std::string(kHeaderLast)] == "true") {
     records.back().last = true;
   }
 
@@ -371,83 +373,105 @@ static std::string BuildHeaderValueV2(const IBucket::Batch::Record& record, Batc
   return "";
 }
 
-Result<IBucket::WriteBatchErrors> ProcessBatchV2(IHttpClient* client, std::string_view io_path,
-                                                 std::string_view entry_name, IBucket::Batch batch, BatchType type) {
-  auto ordered = SortRecords(batch, std::string(entry_name), true);
+struct BatchV2Request {
+  std::vector<size_t> ordered;
+  std::vector<std::string> entries;
+  uint64_t start_ts = 0;
+  IHttpClient::Headers headers;
+};
 
-  if (ordered.empty()) {
-    return {IBucket::WriteBatchErrors{}, Error::kOk};
+Result<BatchV2Request> BuildBatchV2Request(std::string_view default_entry, const IBucket::Batch& batch, BatchType type,
+                                           bool require_entry) {
+  BatchV2Request request;
+  request.ordered = SortRecords(batch, std::string(default_entry), true);
+  if (request.ordered.empty()) {
+    return {request, Error::kOk};
   }
 
-  uint64_t start_ts = std::numeric_limits<uint64_t>::max();
-  std::vector<std::string> entries;
+  request.start_ts = std::numeric_limits<uint64_t>::max();
   std::unordered_map<std::string, size_t> entry_indices;
-  for (auto idx : ordered) {
+  for (auto idx : request.ordered) {
     const auto& record = batch.records()[idx];
+    auto entry = RecordEntry(record, default_entry);
+    if (require_entry && entry.empty()) {
+      return {BatchV2Request{}, Error{.code = 400, .message = "Entry name is required"}};
+    }
     auto ts = static_cast<uint64_t>(ToMicroseconds(record.timestamp));
-    start_ts = std::min(start_ts, ts);
-
-    auto entry = RecordEntry(record, entry_name);
+    request.start_ts = std::min(request.start_ts, ts);
     if (!entry_indices.contains(entry)) {
-      entry_indices[entry] = entries.size();
-      entries.push_back(entry);
+      entry_indices[entry] = request.entries.size();
+      request.entries.push_back(entry);
     }
   }
 
   std::vector<std::string> encoded_entries;
-  encoded_entries.reserve(entries.size());
-  for (const auto& entry : entries) {
+  encoded_entries.reserve(request.entries.size());
+  for (const auto& entry : request.entries) {
     encoded_entries.push_back(EncodeEntryName(entry));
   }
 
-  IHttpClient::Headers headers;
-  headers.emplace("x-reduct-entries", fmt::format("{}", fmt::join(encoded_entries, ",")));
-  headers.emplace("x-reduct-start-ts", std::to_string(start_ts));
+  request.headers.emplace(std::string(kHeaderEntries), fmt::format("{}", fmt::join(encoded_entries, ",")));
+  request.headers.emplace(std::string(kHeaderStartTs), std::to_string(request.start_ts));
 
-  for (auto idx : ordered) {
+  for (auto idx : request.ordered) {
     const auto& record = batch.records()[idx];
-    const auto entry = RecordEntry(record, entry_name);
+    const auto entry = RecordEntry(record, default_entry);
     const auto entry_idx = entry_indices[entry];
-    const auto delta = static_cast<uint64_t>(ToMicroseconds(record.timestamp)) - start_ts;
+    const auto delta = static_cast<uint64_t>(ToMicroseconds(record.timestamp)) - request.start_ts;
 
-    auto key = fmt::format("x-reduct-{}-{}", entry_idx, delta);
-    headers.emplace(std::move(key), BuildHeaderValueV2(record, type));
+    auto key = fmt::format("{}{}-{}", kHeaderPrefix, entry_idx, delta);
+    request.headers.emplace(std::move(key), BuildHeaderValueV2(record, type));
   }
 
-  Result<std::tuple<std::string, IHttpClient::Headers>> resp_result;
+  return {request, Error::kOk};
+}
+
+Result<std::tuple<std::string, IHttpClient::Headers>> SendBatchV2(IHttpClient* client, std::string_view io_path,
+                                                                  BatchType type, IBucket::Batch batch,
+                                                                  std::vector<size_t> ordered,
+                                                                  IHttpClient::Headers headers) {
   switch (type) {
     case BatchType::kWrite: {
       const auto content_length = batch.size();
-      resp_result = client->Post(
-          fmt::format("{}/write", io_path), "application/octet-stream", content_length, std::move(headers),
-          [ordered = std::move(ordered), batch = std::move(batch)](size_t offset, size_t size) {
-            return std::pair{true, batch.Slice(ordered, offset, size)};
-          });
-      break;
+      return client->Post(fmt::format("{}/write", io_path), "application/octet-stream", content_length,
+                          std::move(headers),
+                          [ordered = std::move(ordered), batch = std::move(batch)](size_t offset, size_t size) {
+                            return std::pair{true, batch.Slice(ordered, offset, size)};
+                          });
     }
     case BatchType::kUpdate:
-      resp_result = client->Patch(fmt::format("{}/update", io_path), "", std::move(headers));
-      break;
-
+      return client->Patch(fmt::format("{}/update", io_path), "", std::move(headers));
     case BatchType::kRemove:
-      resp_result = client->Delete(fmt::format("{}/remove", io_path), std::move(headers));
-      break;
+      return client->Delete(fmt::format("{}/remove", io_path), std::move(headers));
+  }
+
+  return {{}, Error{.code = -1, .message = "Unsupported batch type"}};
+}
+
+Result<IBucket::BatchErrors> ProcessBatchV2(IHttpClient* client, std::string_view io_path, std::string_view entry_name,
+                                            IBucket::Batch batch, BatchType type) {
+  auto [request, request_err] = BuildBatchV2Request(entry_name, batch, type, false);
+  if (request_err) {
+    return {{}, std::move(request_err)};
+  }
+  if (request.ordered.empty()) {
+    return {IBucket::BatchErrors{}, Error::kOk};
   }
 
-  auto [resp, err] = resp_result;
+  auto [resp, err] =
+      SendBatchV2(client, io_path, type, std::move(batch), std::move(request.ordered), std::move(request.headers));
   if (err) {
     return {{}, err};
   }
 
-  IBucket::WriteBatchErrors errors;
+  IBucket::BatchErrors errors;
   for (const auto& [key, value] : std::get<1>(resp)) {
-    if (key.starts_with("x-reduct-error-")) {
-      auto prefix = key.substr(std::string("x-reduct-error-").size());
+    if (key.starts_with(kHeaderErrorPrefix)) {
+      auto prefix = key.substr(kHeaderErrorPrefix.size());
       auto dash = prefix.rfind('-');
       if (dash == std::string::npos) {
         continue;
       }
-      auto entry_idx = std::stoul(prefix.substr(0, dash));
       auto delta = std::stoull(prefix.substr(dash + 1));
       auto pos = value.find(',');
       if (pos == std::string::npos) {
@@ -455,7 +479,7 @@ Result<IBucket::WriteBatchErrors> ProcessBatchV2(IHttpClient* client, std::strin
       }
       auto status = std::stoi(value.substr(0, pos));
       auto message = value.substr(pos + 1);
-      errors.emplace(FromMicroseconds(std::to_string(start_ts + delta)),
+      errors.emplace(FromMicroseconds(std::to_string(request.start_ts + delta)),
                      Error{.code = status, .message = message});
     }
   }
@@ -463,4 +487,69 @@ Result<IBucket::WriteBatchErrors> ProcessBatchV2(IHttpClient* client, std::strin
   return {errors, Error::kOk};
 }
 
+Result<IBucket::BatchRecordErrors> ProcessBatchV2Records(IHttpClient* client, std::string_view io_path,
+                                                         IBucket::Batch batch, BatchType type) {
+  auto [request, request_err] = BuildBatchV2Request("", batch, type, true);
+  if (request_err) {
+    return {{}, std::move(request_err)};
+  }
+  if (request.ordered.empty()) {
+    return {IBucket::BatchRecordErrors{}, Error::kOk};
+  }
+
+  auto [resp, err] =
+      SendBatchV2(client, io_path, type, std::move(batch), std::move(request.ordered), std::move(request.headers));
+  if (err) {
+    return {{}, err};
+  }
+
+  const auto& resp_headers = std::get<1>(resp);
+  auto entries_it = resp_headers.find(std::string(kHeaderEntries));
+  auto start_ts_it = resp_headers.find(std::string(kHeaderStartTs));
+
+  std::vector<std::string> entries;
+  if (entries_it != resp_headers.end()) {
+    entries = ParseEncodedList(entries_it->second);
+  }
+  if (entries.empty()) {
+    entries = request.entries;
+  }
+
+  uint64_t start_ts = request.start_ts;
+  if (start_ts_it != resp_headers.end()) {
+    try {
+      start_ts = std::stoull(start_ts_it->second);
+    } catch (...) {
+      start_ts = request.start_ts;
+    }
+  }
+
+  IBucket::BatchRecordErrors errors;
+  for (const auto& [key, value] : std::get<1>(resp)) {
+    if (key.starts_with(kHeaderErrorPrefix)) {
+      auto prefix = key.substr(kHeaderErrorPrefix.size());
+      auto dash = prefix.rfind('-');
+      if (dash == std::string::npos) {
+        continue;
+      }
+      auto entry_idx = std::stoul(prefix.substr(0, dash));
+      if (entry_idx >= entries.size()) {
+        continue;
+      }
+      auto delta = std::stoull(prefix.substr(dash + 1));
+      auto pos = value.find(',');
+      if (pos == std::string::npos) {
+        continue;
+      }
+      auto status = std::stoi(value.substr(0, pos));
+      auto message = value.substr(pos + 1);
+      const auto& entry = entries[entry_idx];
+      errors[entry].emplace(FromMicroseconds(std::to_string(start_ts + delta)),
+                            Error{.code = status, .message = message});
+    }
+  }
+
+  return {errors, Error::kOk};
+}
+
 }  // namespace reduct::internal
diff --git a/src/reduct/internal/batch_v2.h b/src/reduct/internal/batch_v2.h
index 0d34d54..ba47a4f 100644
--- a/src/reduct/internal/batch_v2.h
+++ b/src/reduct/internal/batch_v2.h
@@ -15,10 +15,10 @@ namespace reduct::internal {
 std::vector<IBucket::ReadableRecord> ParseAndBuildBatchedRecordsV2(
     std::deque<std::optional<std::string>>* data, std::mutex* mutex, bool head, IHttpClient::Headers&& headers);
 
-Result<IBucket::WriteBatchErrors> ProcessBatchV2(IHttpClient* client, std::string_view io_path,
-                                                 std::string_view entry_name, IBucket::Batch batch, BatchType type);
-Result<IBucket::WriteBatchErrors> ProcessBatchV2(IHttpClient* client, std::string_view io_path,
-                                                 std::string_view entry_name, IBucket::Batch batch, BatchType type);
+Result<IBucket::BatchErrors> ProcessBatchV2(IHttpClient* client, std::string_view io_path,
+                                            std::string_view entry_name, IBucket::Batch batch, BatchType type);
+Result<IBucket::BatchRecordErrors> ProcessBatchV2Records(IHttpClient* client, std::string_view io_path,
+                                                         IBucket::Batch batch, BatchType type);
 
 }  // namespace reduct::internal
 
diff --git a/src/reduct/internal/headers.h b/src/reduct/internal/headers.h
new file mode 100644
index 0000000..8346233
--- /dev/null
+++ b/src/reduct/internal/headers.h
@@ -0,0 +1,24 @@
+// Copyright 2026 ReductSoftware UG
+#ifndef REDUCT_CPP_HEADERS_H
+#define REDUCT_CPP_HEADERS_H
+
+#include <string_view>
+
+namespace reduct::internal {
+
+constexpr std::string_view kHeaderPrefix = "x-reduct-";
+constexpr std::string_view kHeaderError = "x-reduct-error";
+constexpr std::string_view kHeaderErrorPrefix = "x-reduct-error-";
+constexpr std::string_view kHeaderApi = "x-reduct-api";
+constexpr std::string_view kHeaderQueryId = "x-reduct-query-id";
+constexpr std::string_view kHeaderTime = "x-reduct-time";
+constexpr std::string_view kHeaderTimePrefix = "x-reduct-time-";
+constexpr std::string_view kHeaderLast = "x-reduct-last";
+constexpr std::string_view kHeaderLabelPrefix = "x-reduct-label-";
+constexpr std::string_view kHeaderEntries = "x-reduct-entries";
+constexpr std::string_view kHeaderStartTs = "x-reduct-start-ts";
+constexpr std::string_view kHeaderLabels = "x-reduct-labels";
+
+}  // namespace reduct::internal
+
+#endif  // REDUCT_CPP_HEADERS_H
diff --git a/src/reduct/internal/http_client.cc b/src/reduct/internal/http_client.cc
index eea6827..d773651 100644
--- a/src/reduct/internal/http_client.cc
+++ b/src/reduct/internal/http_client.cc
@@ -1,6 +1,7 @@
 // Copyright 2022-2026 ReductSoftware UG
 
 #include "reduct/internal/http_client.h"
+#include "reduct/internal/headers.h"
 #undef CPPHTTPLIB_BROTLI_SUPPORT
 
 #include <fmt/format.h>
@@ -237,7 +238,7 @@ class HttpClient : public IHttpClient {
 
     auto status = res->status;
     if (status != 200) {
-      auto msg = res->headers.find("x-reduct-error");
+      auto msg = res->headers.find(std::string(kHeaderError));
       if (msg != res->headers.end()) {
         return Error{.code = status, .message = msg->second};
       }
@@ -245,7 +246,7 @@ class HttpClient : public IHttpClient {
       return Error{.code = status, .message = "Unknown error"};
     }
 
-    if (auto api_version = res->headers.find("x-reduct-api"); api_version != res->headers.end()) {
+    if (auto api_version = res->headers.find(std::string(kHeaderApi)); api_version != res->headers.end()) {
       const auto dot = api_version->second.find('.');
       if (dot == std::string::npos) {
         return Error{.code = -1, .message = "Invalid API version"};
diff --git a/src/reduct/internal/serialisation.cc b/src/reduct/internal/serialisation.cc
index 355995b..4d27c34 100644
--- a/src/reduct/internal/serialisation.cc
+++ b/src/reduct/internal/serialisation.cc
@@ -197,8 +197,8 @@ Result<IClient::FullReplicationInfo> ParseFullReplicationInfo(const nlohmann::js
         .dst_bucket = settings.at("dst_bucket"),
         .dst_host = settings.at("dst_host"),
         .entries = settings.at("entries"),
-        .mode = settings.contains("mode") ? ParseReplicationMode(settings.at("mode"))
-                                          : IClient::ReplicationMode::kEnabled,
+        .mode =
+            settings.contains("mode") ? ParseReplicationMode(settings.at("mode")) : IClient::ReplicationMode::kEnabled,
     };
 
     if (settings.contains("dst_token") && !settings.at("dst_token").is_null()) {
@@ -237,12 +237,18 @@ Result<IClient::FullReplicationInfo> ParseFullReplicationInfo(const nlohmann::js
   return {info, Error::kOk};
 }
 
-Result<nlohmann::ordered_json> QueryOptionsToJsonString(std::string_view type, std::optional<IBucket::Time> start,
+Result<nlohmann::ordered_json> QueryOptionsToJsonString(std::string_view type, const std::vector<std::string>& entries,
+                                                        std::optional<IBucket::Time> start,
                                                         std::optional<IBucket::Time> stop,
                                                         const IBucket::QueryOptions& options) {
   nlohmann::ordered_json json_data;
   json_data["query_type"] = type;
 
+  json_data["entries"] = nlohmann::ordered_json::array();
+  for (const auto& entry : entries) {
+    json_data["entries"].push_back(entry);
+  }
+
   if (start) {
     json_data["start"] = std::chrono::duration_cast<std::chrono::microseconds>(start->time_since_epoch()).count();
   }
@@ -294,14 +300,16 @@ Result<nlohmann::ordered_json> QueryOptionsToJsonString(std::string_view type, s
   return {json_data, Error::kOk};
 }
 
-Result<nlohmann::json> QueryLinkOptionsToJsonString(std::string_view bucket, std::string_view entry_name,
-                                                    const IBucket::QueryLinkOptions& options) {
-  nlohmann::json json_data;
+Result<nlohmann::ordered_json> QueryLinkOptionsToJsonString(std::string_view bucket,
+                                                            const std::vector<std::string>& entries,
+                                                            const IBucket::QueryLinkOptions& options) {
+  nlohmann::ordered_json json_data;
 
   json_data["bucket"] = bucket;
-  json_data["entry"] = entry_name;
   json_data["index"] = options.record_index;
-  auto [query_json, query_err] = QueryOptionsToJsonString("QUERY", options.start, options.stop, options.query_options);
+  json_data["entry"] = entries.at(0);
+  auto [query_json, query_err] =
+      QueryOptionsToJsonString("QUERY", entries, options.start, options.stop, options.query_options);
   if (query_err) {
     return {{}, std::move(query_err)};
   }
diff --git a/src/reduct/internal/serialisation.h b/src/reduct/internal/serialisation.h
index 3a843c7..d2fdca0 100644
--- a/src/reduct/internal/serialisation.h
+++ b/src/reduct/internal/serialisation.h
@@ -3,10 +3,11 @@
 #ifndef REDUCTCPP_SERIALISATION_H
 #define REDUCTCPP_SERIALISATION_H
 
-#include <string>
-
 #include <nlohmann/json.hpp>
 
+#include <string>
+#include <vector>
+
 #include "reduct/bucket.h"
 #include "reduct/client.h"
 
@@ -60,12 +61,14 @@ Result<nlohmann::json> ReplicationSettingsToJsonString(IClient::ReplicationSetti
  */
 Result<IClient::FullReplicationInfo> ParseFullReplicationInfo(const nlohmann::json& data);
 
-Result<nlohmann::ordered_json> QueryOptionsToJsonString(std::string_view type, std::optional<IBucket::Time> start,
-                                                std::optional<IBucket::Time> stop,
-                                                const IBucket::QueryOptions& options);
+Result<nlohmann::ordered_json> QueryOptionsToJsonString(std::string_view type, const std::vector<std::string>& entries,
+                                                        std::optional<IBucket::Time> start,
+                                                        std::optional<IBucket::Time> stop,
+                                                        const IBucket::QueryOptions& options);
 
-Result<nlohmann::json> QueryLinkOptionsToJsonString(std::string_view bucket, std::string_view entry_name,
-                                                    const IBucket::QueryLinkOptions& options);
+Result<nlohmann::ordered_json> QueryLinkOptionsToJsonString(std::string_view type,
+                                                            const std::vector<std::string>& entries,
+                                                            const IBucket::QueryLinkOptions& options);
 
 /**
  * @brief Parse status from JSON
diff --git a/tests/fixture.h b/tests/fixture.h
index bcc9b14..1cf3d11 100644
--- a/tests/fixture.h
+++ b/tests/fixture.h
@@ -1,4 +1,4 @@
-// Copyright 2022 ReductSoftware UG
+// Copyright 2022-2026 ReductSoftware UG
 
 #ifndef REDUCT_CPP_HELPERS_H
 #define REDUCT_CPP_HELPERS_H
@@ -7,6 +7,7 @@
 
 #include <cstdlib>
 #include <random>
+#include <thread>
 
 #include "reduct/client.h"
 
@@ -35,6 +36,8 @@ struct Fixture {
       [[maybe_unused]] auto ret = bucket->Remove();
     }
 
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));  // wait for bucket removal
+
     for (auto&& t : client->GetTokenList().result) {
       if (!t.name.starts_with("test_token")) {
         continue;
diff --git a/tests/reduct/bucket_api_test.cc b/tests/reduct/bucket_api_test.cc
index bf8eb6b..53289d4 100644
--- a/tests/reduct/bucket_api_test.cc
+++ b/tests/reduct/bucket_api_test.cc
@@ -2,6 +2,8 @@
 
 #include <catch2/catch.hpp>
 
+#include <vector>
+
 #include "fixture.h"
 #include "reduct/client.h"
 #include "reduct/internal/http_client.h"
@@ -88,6 +90,7 @@ TEST_CASE("reduct::IBucket should have settings", "[bucket_api]") {
 
     SECTION("and return HTTP status") {
       REQUIRE(bucket->Remove() == Error::kOk);
+      std::this_thread::sleep_for(std::chrono::milliseconds(100));  // wait for bucket deletion
       REQUIRE(bucket->GetSettings() ==
               Error{.code = 404, .message = fmt::format("Bucket '{}' is not found", kBucketName)});
     }
@@ -115,12 +118,6 @@ TEST_CASE("reduct::IBucket should have settings", "[bucket_api]") {
       auto [settings, get_error] = bucket->GetSettings();
       REQUIRE(kNewSettings == settings);
     }
-
-    SECTION("and return HTTP status") {
-      REQUIRE(bucket->Remove() == Error::kOk);
-      REQUIRE(bucket->GetSettings() ==
-              Error{.code = 404, .message = fmt::format("Bucket '{}' is not found", kBucketName)});
-    }
   }
 }
 
@@ -181,6 +178,7 @@ TEST_CASE("reduct::IBucket should remove a bucket", "[bucket_api]") {
   auto [bucket, _] = ctx.client->CreateBucket(kBucketName);
 
   REQUIRE(bucket->Remove() == Error::kOk);
+  std::this_thread::sleep_for(std::chrono::milliseconds(100));  // wait for bucket deletion
   REQUIRE(bucket->Remove() == Error{.code = 404, .message = fmt::format("Bucket '{}' is not found", kBucketName)});
 }
 
@@ -228,6 +226,28 @@ TEST_CASE("reduct::IBucket should create a query link", "[bucket_api][1_17]") {
   REQUIRE(data == "data-1");
 }
 
+TEST_CASE("reduct::IBucket should create a query link for multiple entries", "[bucket_api][1_18]") {
+  Fixture ctx;
+  auto [bucket, _] = ctx.client->GetBucket("test_bucket_1");
+
+  auto [link, err] = bucket->CreateQueryLink(std::vector<std::string>{"entry-1", "entry-2"},
+                                             IBucket::QueryLinkOptions{});
+  REQUIRE(err == Error::kOk);
+
+  auto [data, http_err] = download_link(link);
+  REQUIRE(http_err == Error::kOk);
+  REQUIRE(data == "data-1");
+}
+
+TEST_CASE("reduct::IBucket should reject empty entry list for query link", "[bucket_api][1_18]") {
+  Fixture ctx;
+  auto [bucket, _] = ctx.client->GetBucket("test_bucket_1");
+
+  auto [link, err] = bucket->CreateQueryLink(std::vector<std::string>{}, IBucket::QueryLinkOptions{});
+  REQUIRE(err == Error{.code = -1, .message = "At least one entry name is required"});
+  REQUIRE(link.empty());
+}
+
 TEST_CASE("reduct::IBucket should create a query link with index", "[bucket_api][1_17]") {
   Fixture ctx;
   auto [bucket, _] = ctx.client->GetBucket("test_bucket_1");
diff --git a/tests/reduct/entry_api_test.cc b/tests/reduct/entry_api_test.cc
index 75586f1..400682c 100644
--- a/tests/reduct/entry_api_test.cc
+++ b/tests/reduct/entry_api_test.cc
@@ -246,19 +246,19 @@ TEST_CASE("reduct::IBucket should query records", "[entry_api][1_13]") {
 
   SECTION("order") {
     auto err = bucket->Query("entry", ts, ts + us(3),
-                         {
-                             .when = R"({"$not": [ {"$has": "score"} ], "$limit": 2})",
-                             .strict = false,
-                         },
-                         [&all_data](auto record) {
-                           auto read_err = record.Read([&all_data](auto data) {
-                             all_data.append(data);
-                             return true;
-                           });
-
-                           REQUIRE(read_err == Error::kOk);
-                           return true;
-                         });
+                             {
+                                 .when = R"({"$not": [ {"$has": "score"} ], "$limit": 2})",
+                                 .strict = false,
+                             },
+                             [&all_data](auto record) {
+                               auto read_err = record.Read([&all_data](auto data) {
+                                 all_data.append(data);
+                                 return true;
+                               });
+
+                               REQUIRE(read_err == Error::kOk);
+                               return true;
+                             });
 
     REQUIRE(err == Error::kOk);
     REQUIRE(all_data == "some_data2some_data3");
@@ -305,18 +305,30 @@ TEST_CASE("reduct::IBucket should query multiple entries", "[entry_api][1_18]")
   REQUIRE(bucket->Write("entry-b", ts + us(1), [](auto rec) { rec->WriteAll("bbb"); }) == Error::kOk);
 
   std::map<std::string, std::string> received;
-  auto err = bucket->Query("entry-a, entry-b", ts, ts + us(2), {}, [&received](auto record) {
-    auto [data, read_err] = record.ReadAll();
-    REQUIRE(read_err == Error::kOk);
-    REQUIRE(!record.entry.empty());
-    received[record.entry] = data;
-    return true;
-  });
+  auto err =
+      bucket->Query(std::vector<std::string>{"entry-a", "entry-b"}, ts, ts + us(2), {}, [&received](auto record) {
+        auto [data, read_err] = record.ReadAll();
+        REQUIRE(read_err == Error::kOk);
+        REQUIRE(!record.entry.empty());
+        received[record.entry] = data;
+        return true;
+      });
 
   REQUIRE(err == Error::kOk);
   REQUIRE(received == std::map<std::string, std::string>{{"entry-a", "aaa"}, {"entry-b", "bbb"}});
 }
 
+TEST_CASE("reduct::IBucket should reject empty entry list for batch query", "[entry_api][1_18]") {
+  Fixture ctx;
+  auto [bucket, _] = ctx.client->CreateBucket(kBucketName);
+  REQUIRE(bucket);
+
+  auto err = bucket->Query(std::vector<std::string>{}, std::nullopt, std::nullopt, {}, [](auto) { return true; });
+
+  REQUIRE(err.code == -1);
+  REQUIRE(err.message == "No entry names provided");
+}
+
 TEST_CASE("reduct::IBucket should update a batch across entries", "[entry_api][1_18]") {
   Fixture ctx;
   auto [bucket, _] = ctx.client->CreateBucket(kBucketName);
@@ -354,7 +366,7 @@ TEST_CASE("reduct::IBucket should remove records across entries via query", "[en
   REQUIRE(bucket->Write("entry-a", ts, [](auto rec) { rec->WriteAll("aaa"); }) == Error::kOk);
   REQUIRE(bucket->Write("entry-b", ts + us(1), [](auto rec) { rec->WriteAll("bbb"); }) == Error::kOk);
 
-  auto [removed, err] = bucket->RemoveQuery("entry-a, entry-b", ts, ts + us(2), {});
+  auto [removed, err] = bucket->RemoveQuery(std::vector<std::string>{"entry-a", "entry-b"}, ts, ts + us(2), {});
   REQUIRE(err == Error::kOk);
   REQUIRE(removed == 2);
 
@@ -364,6 +376,18 @@ TEST_CASE("reduct::IBucket should remove records across entries via query", "[en
           Error{.code = 404, .message = "No record with timestamp 1"});
 }
 
+TEST_CASE("reduct::IBucket should reject empty entry list for batch remove query", "[entry_api][1_18]") {
+  Fixture ctx;
+  auto [bucket, _] = ctx.client->CreateBucket(kBucketName);
+  REQUIRE(bucket);
+
+  auto [removed, err] = bucket->RemoveQuery(std::vector<std::string>{}, std::nullopt, std::nullopt, {});
+
+  REQUIRE(removed == 0);
+  REQUIRE(err.code == -1);
+  REQUIRE(err.message == "No entry names provided");
+}
+
 TEST_CASE("reduct::IBucket should remove a batch across entries", "[entry_api][1_18]") {
   Fixture ctx;
   auto [bucket, _] = ctx.client->CreateBucket(kBucketName);
@@ -575,9 +599,7 @@ TEST_CASE("reduct::IBucket should remove a record", "[bucket_api][1_12]") {
 
   REQUIRE(bucket->RemoveRecord("entry-1", t) == Error::kOk);
 
-  REQUIRE(bucket->Read("entry-1", t, [](auto record) { return true; }) ==
-          Error{.code = 404, .message = "No record with timestamp 0"});
-
+  REQUIRE(bucket->Read("entry-1", t, [](auto record) { return true; }).code == 404);
   REQUIRE(bucket->Read("entry-1", t + us(1), [](auto record) { return true; }) == Error::kOk);
 }
 
@@ -625,8 +647,7 @@ TEST_CASE("reduct::IBucket should remove records by query", "[bucket_api][1_15]"
     return true;
   }) == Error::kOk);
 
-  REQUIRE(bucket->Read("entry-1", t + us(1), [](auto record) { return true; }) ==
-          Error{.code = 404, .message = "No record with timestamp 1"});
+  REQUIRE(bucket->Read("entry-1", t + us(1), [](auto record) { return true; }).code == 404);
 
   REQUIRE(bucket->Read("entry-1", t + us(2), [](auto record) {
     REQUIRE(record.ReadAll().result == "some_data3");
@@ -649,16 +670,14 @@ TEST_CASE("reduct::IBucket should remove records by query with when condition",
     REQUIRE(err == Error::kOk);
     REQUIRE(removed_records == 1);
 
-    REQUIRE(bucket->Read("entry-1", t, [](auto record) { return true; }) ==
-            Error{.code = 404, .message = "No record with timestamp 0"});
+    REQUIRE(bucket->Read("entry-1", t, [](auto record) { return true; }).code == 404);
 
     REQUIRE(bucket->Read("entry-1", t + us(1), [](auto record) {
       REQUIRE(record.ReadAll().result == "some_data2");
       return true;
     }) == Error::kOk);
 
-    REQUIRE(bucket->Read("entry-1", t + us(2), [](auto record) { return true; }) ==
-            Error{.code = 404, .message = "No record with timestamp 2"});
+    REQUIRE(bucket->Read("entry-1", t + us(2), [](auto record) { return true; }).code == 404);
   }
 
   SECTION("strict") {
diff --git a/tests/reduct/replication_api_test.cc b/tests/reduct/replication_api_test.cc
index cda2f7d..255da98 100644
--- a/tests/reduct/replication_api_test.cc
+++ b/tests/reduct/replication_api_test.cc
@@ -92,7 +92,7 @@ TEST_CASE("reduct::Client should set replication mode", "[replication_api][1_18]
   REQUIRE(replication.info == IClient::ReplicationInfo{
                                   .name = "test_replication",
                                   .mode = IClient::ReplicationMode::kPaused,
-                                  .is_active = false,
+                                  .is_active = true,
                                   .is_provisioned = false,
                                   .pending_records = 0,
                               });