diff --git a/CHANGELOG.md b/CHANGELOG.md
index ed9d7e0..0bca6d4 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -11,6 +11,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Add communication timeouts to client settings, [PR-101](https://github.com/reductstore/reduct-cpp/pull/101)
 - Support replication modes (`enabled`, `paused`, `disabled`) and mode updates via PATCH, [PR-103](https://github.com/reductstore/reduct-cpp/pull/103)
+- Add batch protocol v2 support for multiple entries and entry-aware records/batches, [PR-107](https://github.com/reductstore/reduct-cpp/pull/107)
 
 ### Fixed
 
diff --git a/LICENSE b/LICENSE
index 8b1984c..5c99808 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025 ReductSoftware UG
+Copyright (c) 2025-2026 ReductSoftware UG
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/examples/subscription.cc b/examples/subscription.cc
index 02c6231..1a7ddcc 100644
--- a/examples/subscription.cc
+++ b/examples/subscription.cc
@@ -1,4 +1,4 @@
-// Copyright 2023 Alexey Timin
+// Copyright 2023 ReductSoftware UG
 
 #include <reduct/client.h>
 
diff --git a/examples/usage_example.cc b/examples/usage_example.cc
index a71f990..a777b50 100644
--- a/examples/usage_example.cc
+++ b/examples/usage_example.cc
@@ -1,4 +1,4 @@
-// Copyright 2022 Alexey Timin
+// Copyright 2022 ReductSoftware UG
 
 #include <reduct/client.h>
 
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index a09c0e3..4d786cd 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -1,4 +1,6 @@
 set(SRC_FILES
+    reduct/internal/batch_v1.cc
+    reduct/internal/batch_v2.cc
     reduct/internal/http_client.cc
     reduct/internal/serialisation.cc
     reduct/bucket.cc
diff --git a/src/reduct/bucket.cc b/src/reduct/bucket.cc
index 18fa507..a25fd73 100644
--- a/src/reduct/bucket.cc
+++ b/src/reduct/bucket.cc
@@ -1,9 +1,8 @@
-// Copyright 2022-2024 Alexey Timin
+// Copyright 2022-2024 ReductSoftware UG
 
 #include "reduct/bucket.h"
 #define FMT_HEADER_ONLY 1
 #include <fmt/core.h>
-#include <fmt/ranges.h>
 #ifdef CONCURRENTQUEUE_H_FILEPATH
 #include CONCURRENTQUEUE_H_FILEPATH
 #else
@@ -12,11 +11,18 @@
 
 #include <nlohmann/json.hpp>
 
+#include <atomic>
+#include <cctype>
+#include <chrono>
+#include <deque>
 #include <future>
 #include <mutex>
-#include <queue>
+#include <optional>
+#include <set>
 #include <thread>
 
+#include "reduct/internal/batch_v1.h"
+#include "reduct/internal/batch_v2.h"
 #include "reduct/internal/http_client.h"
 #include "reduct/internal/serialisation.h"
 
@@ -27,11 +33,17 @@ using internal::ParseStatus;
 using internal::QueryOptionsToJsonString;
 
 class Bucket : public IBucket {
+  using BatchType = internal::BatchType;
+
  public:
-  Bucket(std::string_view url, std::string_view name, const HttpOptions& options)
-      : path_(fmt::format("/b/{}", name)), stop_{} {
+  Bucket(std::string_view url, std::string_view name, const HttpOptions& options,
+         std::optional<std::string> api_version = std::nullopt)
+      : path_(fmt::format("/b/{}", name)), io_path_(fmt::format("/io/{}", name)), stop_{} {
     name_ = name;
     client_ = IHttpClient::Build(url, options);
+    if (api_version) {
+      client_->SetApiVersion(api_version);
+    }
 
     worker_ = std::thread([this] {
       while (!stop_) {
@@ -130,7 +142,7 @@ class Bucket : public IBucket {
   }
 
   Error RemoveRecord(std::string_view entry_name, Time timestamp) const noexcept override {
-    return client_->Delete(fmt::format("{}/{}?ts={}", path_, entry_name, ToMicroseconds(timestamp)));
+    return client_->Delete(fmt::format("{}/{}?ts={}", path_, entry_name, internal::ToMicroseconds(timestamp)));
   }
 
   Error Write(std::string_view entry_name, std::optional<Time> ts,
@@ -143,7 +155,8 @@ class Bucket : public IBucket {
     WritableRecord record;
     callback(&record);
 
-    const auto time = options.timestamp ? ToMicroseconds(*options.timestamp) : ToMicroseconds(Time::clock::now());
+    const auto time =
+        options.timestamp ? internal::ToMicroseconds(*options.timestamp) : internal::ToMicroseconds(Time::clock::now());
     const auto content_type = options.content_type.empty() ? "application/octet-stream" : options.content_type;
 
     IHttpClient::Headers headers = MakeHeadersFromLabels(options);
@@ -168,7 +181,7 @@ class Bucket : public IBucket {
       return Error{.code = 400, .message = "Timestamp is required"};
     }
 
-    const auto time = ToMicroseconds(*options.timestamp);
+    const auto time = internal::ToMicroseconds(*options.timestamp);
     IHttpClient::Headers headers = MakeHeadersFromLabels(options);
     return client_->Patch(fmt::format("{}/{}?ts={}", path_, entry_name, time), "", std::move(headers));
   }
@@ -176,7 +189,7 @@ class Bucket : public IBucket {
   Error Read(std::string_view entry_name, std::optional<Time> ts, ReadRecordCallback callback) const noexcept override {
     auto path = fmt::format("{}/{}", path_, entry_name);
     if (ts) {
-      path.append(fmt::format("?ts={}", ToMicroseconds(*ts)));
+      path.append(fmt::format("?ts={}", internal::ToMicroseconds(*ts)));
     }
 
     auto record_err = ReadRecord(std::move(path), ReadType::kSingle, false, callback);
@@ -186,7 +199,7 @@ class Bucket : public IBucket {
   Error Head(std::string_view entry_name, std::optional<Time> ts, ReadRecordCallback callback) const noexcept override {
     auto path = fmt::format("{}/{}", path_, entry_name);
     if (ts) {
-      path.append(fmt::format("?ts={}", ToMicroseconds(*ts)));
+      path.append(fmt::format("?ts={}", internal::ToMicroseconds(*ts)));
     }
 
     auto record_err = ReadRecord(std::move(path), ReadType::kSingle, true, callback);
@@ -195,6 +208,15 @@ 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);
+    }
+
+    return QueryV1(entry_name, 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);
     if (json_err) {
@@ -240,8 +262,69 @@ 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);
+    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) {
+      return resp_err;
+    }
+
+    uint64_t id;
+    try {
+      auto data = nlohmann::json::parse(resp);
+      id = data["id"];
+    } catch (const std::exception& ex) {
+      return Error{.code = -1, .message = ex.what()};
+    }
+
+    while (true) {
+      auto [stopped, record_err] = ReadRecordV2(id, options.head_only, callback);
+
+      if (stopped) {
+        break;
+      }
+
+      if (record_err) {
+        if (record_err.code == 204) {
+          if (options.continuous) {
+            std::this_thread::sleep_for(options.poll_interval);
+            continue;
+          }
+          break;
+        }
+
+        return record_err;
+      }
+    }
+
+    return Error::kOk;
+  }
+
   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);
+    }
+
+    return RemoveQueryV1(entry_name, 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);
     if (json_err) {
@@ -263,6 +346,34 @@ 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);
+    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);
+    }
+
+    auto [resp, resp_err] = client_->PostWithResponse(fmt::format("{}/q", io_path_), json_payload.dump());
+    if (resp_err) {
+      return {0, std::move(resp_err)};
+    }
+
+    try {
+      auto data = nlohmann::json::parse(resp);
+      return {data.at("removed_records"), Error::kOk};
+    } catch (const std::exception& ex) {
+      return {0, Error{.code = -1, .message = ex.what()}};
+    }
+  }
+
   Error RenameEntry(std::string_view old_name, std::string_view new_name) const noexcept override {
     nlohmann::json data;
     data["new_name"] = new_name;
@@ -277,6 +388,7 @@ class Bucket : public IBucket {
       return err;
     }
     path_ = fmt::format("/b/{}", new_name);
+    io_path_ = fmt::format("/io/{}", new_name);
     return Error::kOk;
   }
 
@@ -285,8 +397,7 @@ class Bucket : public IBucket {
 
     auto file_name =
         options.file_name ? *options.file_name : fmt::format("{}_{}.bin", entry_name, options.record_index);
-    auto [body, err] = client_->PostWithResponse(fmt::format("/links/{}", file_name),
-                                                 json_payload.dump());
+    auto [body, err] = client_->PostWithResponse(fmt::format("/links/{}", file_name), json_payload.dump());
     if (err) {
       return {{}, std::move(err)};
     }
@@ -316,7 +427,7 @@ class Bucket : public IBucket {
                                            this](IHttpClient::Headers&& headers) {
       std::vector<ReadableRecord> records;
       if (type == ReadType::kBatched) {
-        records = ParseAndBuildBatchedRecords(&data, &data_mutex, head, std::move(headers));
+        records = internal::ParseAndBuildBatchedRecordsV1(&data, &data_mutex, head, std::move(headers));
       } else {
         records.emplace_back(ParseAndBuildSingleRecord(&data, &data_mutex, head, std::move(headers)));
       }
@@ -369,11 +480,72 @@ class Bucket : public IBucket {
     return {stopped, err};
   }
 
+  Result<bool> ReadRecordV2(uint64_t query_id, bool head, const ReadRecordCallback& callback) const noexcept {
+    std::deque<std::optional<std::string>> data;
+    std::mutex data_mutex;
+    std::future<void> future;
+    bool stopped = false;
+
+    IHttpClient::Headers request_headers;
+    request_headers.emplace("x-reduct-query-id", std::to_string(query_id));
+
+    auto parse_headers_and_receive_data = [&stopped, &data, &data_mutex, &callback, &future, head,
+                                           this](IHttpClient::Headers&& headers) {
+      auto records = internal::ParseAndBuildBatchedRecordsV2(&data, &data_mutex, head, std::move(headers));
+      for (auto& record : records) {
+        Task task([record = std::move(record), &callback, &stopped] {
+          if (stopped) {
+            return;
+          }
+          stopped = !callback(record);
+          if (!stopped) {
+            stopped = record.last;
+          }
+        });
+
+        future = task.get_future();
+        task_queue_.enqueue(std::move(task));
+      }
+    };
+
+    Error err;
+    if (head) {
+      auto ret = client_->Head(fmt::format("{}/read", io_path_), std::move(request_headers));
+      if (ret.error) {
+        err = ret.error;
+      } else {
+        parse_headers_and_receive_data(std::move(ret.result));
+      }
+    } else {
+      err = client_->Get(fmt::format("{}/read", io_path_), std::move(request_headers), parse_headers_and_receive_data,
+                         [&data, &data_mutex](auto chunk) {
+                           {
+                             std::lock_guard lock(data_mutex);
+                             data.emplace_back(std::string(chunk));
+                           }
+                           return true;
+                         });
+    }
+
+    if (!err) {
+      if (!head) {
+        std::lock_guard lock(data_mutex);
+        data.emplace_back(std::nullopt);
+      }
+
+      if (future.valid()) {
+        future.wait();
+      }
+    }
+
+    return {stopped, err};
+  }
+
   static ReadableRecord ParseAndBuildSingleRecord(std::deque<std::optional<std::string>>* data, std::mutex* mutex,
                                                   bool head, IHttpClient::Headers&& headers) {
     ReadableRecord record;
 
-    record.timestamp = FromMicroseconds(headers["x-reduct-time"]);
+    record.timestamp = internal::FromMicroseconds(headers["x-reduct-time"]);
     record.size = std::stoi(headers["content-length"]);
     record.content_type = headers["content-type"];
     record.last = headers["x-reduct-last"] == "1";
@@ -418,128 +590,6 @@ class Bucket : public IBucket {
     return record;
   }
 
-  static std::vector<ReadableRecord> ParseAndBuildBatchedRecords(std::deque<std::optional<std::string>>* data,
-                                                                 std::mutex* mutex, bool head,
-                                                                 IHttpClient::Headers&& headers) {
-    auto parse_csv = [](const std::string& csv) {
-      std::vector<std::string> items;
-      std::string escaped, item;
-      std::stringstream ss(csv);
-
-      while (std::getline(ss, item, ',')) {
-        if (item.starts_with("\"") && escaped.empty()) {
-          escaped = item.substr(1);
-        }
-
-        if (!escaped.empty()) {
-          if (item.ends_with("\"")) {
-            escaped = escaped.substr(0, escaped.size() - 2);
-            items.push_back(escaped);
-            escaped = "";
-          } else {
-            escaped += item;
-          }
-        } else {
-          items.push_back(item);
-        }
-      }
-
-      auto size = std::stoll(items[0]);
-      // eslint-disable-next-line prefer-destructuring
-      auto content_type = items[1];
-      LabelMap labels = {};
-
-      for (auto i = 2; i < items.size(); i++) {
-        auto pos = items[i].find('=');
-        if (pos == std::string::npos) {
-          continue;
-        }
-
-        auto key = items[i].substr(0, pos);
-        labels[key] = items[i].substr(pos + 1);
-      }
-
-      return std::tuple{
-          size,
-          content_type,
-          labels,
-      };
-    };
-
-    std::vector<ReadableRecord> records;
-    size_t total_records = std::count_if(headers.begin(), headers.end(),
-                                         [](const auto& header) { return header.first.starts_with("x-reduct-time-"); });
-
-    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-")) {
-        continue;
-      }
-
-      auto [size, content_type, labels] = parse_csv(header->second);
-
-      ReadableRecord record;
-      record.timestamp = FromMicroseconds(header->first.substr(14));
-      record.size = size;
-      record.content_type = content_type;
-      record.labels = labels;
-      record.Read = [data, mutex, size, head](auto record_callback) {
-        if (head) {
-          return Error::kOk;
-        }
-
-        size_t total = 0;
-        while (true) {
-          std::optional<std::string> chunk = "";
-          {
-            std::lock_guard lock(*mutex);
-            if (!data->empty()) {
-              chunk = std::move(data->front());
-              data->pop_front();
-
-              if (chunk->size() > size - total) {
-                auto tmp = chunk->substr(0, size - total);
-                data->push_front(chunk->substr(size - total));
-                chunk = std::move(tmp);
-              }
-            }
-          }
-
-          if (!chunk) {
-            break;
-          }
-
-          if (chunk->empty()) {
-            std::this_thread::sleep_for(std::chrono::microseconds(100));
-            continue;
-          }
-
-          total += chunk->size();
-          if (!record_callback(std::move(*chunk))) {
-            break;
-          }
-
-          if (total >= size) {
-            break;
-          }
-        }
-
-        return Error::kOk;
-      };
-
-      record.last = (records.size() == total_records - 1 && headers["x-reduct-last"] == "true");
-      records.push_back(std::move(record));
-    }
-
-    return records;
-  }
-
-  static int64_t ToMicroseconds(const Time& ts) {
-    return std::chrono::duration_cast<std::chrono::microseconds>(ts.time_since_epoch()).count();
-  }
-
-  static Time FromMicroseconds(const std::string& ts) { return Time() + std::chrono::microseconds(std::stoul(ts)); }
-
   IHttpClient::Headers MakeHeadersFromLabels(const WriteOptions& options) const {
     IHttpClient::Headers headers;
     for (const auto& [key, value] : options.labels) {
@@ -548,89 +598,63 @@ class Bucket : public IBucket {
     return headers;
   }
 
-  enum class BatchType { kWrite, kUpdate, kRemove };
+  bool SupportsBatchProtocolV2() const {
+    auto api_version = client_->ApiVersion();
+    return api_version && internal::IsCompatible("1.18", *api_version);
+  }
 
-  Result<WriteBatchErrors> ProcessBatch(std::string_view entry_name, BatchCallback callback,
-                                        BatchType type) const noexcept {
-    Batch batch;
-    callback(&batch);
+  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));
+  }
 
-    IHttpClient::Headers headers;
-    for (const auto& [time, record] : batch.records()) {
-      std::vector<std::string> labels;
-      for (const auto& [label_key, label_value] : record.labels) {
-        if (label_key.find(',') == std::string::npos) {
-          labels.push_back(fmt::format("{}={}", label_key, label_value));
-        } else {
-          labels.push_back(fmt::format("{}=\"{}\"", label_key, label_value));
-        }
+  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));
       }
-
-      const auto key = fmt::format("x-reduct-time-{}", ToMicroseconds(time));
-
-      switch (type) {
-        case BatchType::kWrite: {
-          const auto value = fmt::format("{},{},{}", record.size, record.content_type, fmt::join(labels, ","));
-          headers.emplace(key, value);
-
-          break;
-        }
-        case BatchType::kUpdate: {
-          const auto value = fmt::format("0,,{}", fmt::join(labels, ","));
-          headers.emplace(key, value);
-          break;
-        }
-        case BatchType::kRemove: {
-          headers.emplace(key, "0,");
-          break;
-        }
+      if (comma == std::string_view::npos) {
+        break;
       }
+      start = comma + 1;
     }
 
-    Result<std::tuple<std::string, IHttpClient::Headers>> resp_result;
-    switch (type) {
-      case BatchType::kWrite: {
-        const auto content_length = batch.size();
-        resp_result =
-            client_->Post(fmt::format("{}/{}/batch", path_, entry_name), "application/octet-stream", content_length,
-                          std::move(headers), [batch = std::move(batch)](size_t offset, size_t size) {
-                            return std::pair{true, batch.Slice(offset, size)};
-                          });
-        break;
+    if (entries.empty() && !entries_raw.empty()) {
+      auto trimmed = TrimWhitespace(entries_raw);
+      if (!trimmed.empty()) {
+        entries.emplace_back(std::move(trimmed));
       }
-      case BatchType::kUpdate:
-        resp_result = client_->Patch(fmt::format("{}/{}/batch", path_, entry_name), "", std::move(headers));
-        break;
-
-      case BatchType::kRemove:
-        resp_result = client_->Delete(fmt::format("{}/{}/batch", path_, entry_name), std::move(headers));
-        break;
     }
 
-    auto [resp, err] = resp_result;
-    if (err) {
-      return {{}, err};
-    }
+    return entries;
+  }
 
-    WriteBatchErrors errors;
-    for (const auto& [key, value] : std::get<1>(resp)) {
-      if (key.starts_with("x-reduct-error-")) {
-        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});
-      }
+  Result<WriteBatchErrors> ProcessBatch(std::string_view entry_name, BatchCallback callback,
+                                        BatchType type) const noexcept {
+    Batch batch;
+    callback(&batch);
+
+    if (SupportsBatchProtocolV2()) {
+      return internal::ProcessBatchV2(client_.get(), io_path_, entry_name, std::move(batch), type);
     }
 
-    return {errors, Error::kOk};
+    return internal::ProcessBatchV1(client_.get(), path_, entry_name, std::move(batch), type);
   }
 
   std::unique_ptr<internal::IHttpClient> client_;
   std::string name_;
   std::string path_;
+  std::string io_path_;
   std::thread worker_;
 
   using Task = std::packaged_task<void()>;
@@ -643,6 +667,11 @@ 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 {
+  return std::make_unique<Bucket>(server_url, name, options, std::move(api_version));
+}
+
 // Settings
 std::ostream& operator<<(std::ostream& os, const reduct::IBucket::Settings& settings) {
   os << internal::BucketSettingToJsonString(settings).dump();
@@ -662,8 +691,7 @@ std::ostream& operator<<(std::ostream& os, const IBucket::BucketInfo& info) {
 std::ostream& operator<<(std::ostream& os, const IBucket::EntryInfo& info) {
   os << fmt::format(
       "<EntryInfo name={}, record_count={}, block_count={}, size={}, oldest_record={}, latest_record={}, status={}>",
-      info.name, info.record_count, info.block_count, info.size,
-      info.oldest_record.time_since_epoch().count() / 1000,
+      info.name, info.record_count, info.block_count, info.size, info.oldest_record.time_since_epoch().count() / 1000,
       info.latest_record.time_since_epoch().count() / 1000,
       info.status == IBucket::Status::kReady ? "READY" : "DELETING");
   return os;
diff --git a/src/reduct/bucket.h b/src/reduct/bucket.h
index 489f7e4..13bc9c4 100644
--- a/src/reduct/bucket.h
+++ b/src/reduct/bucket.h
@@ -1,4 +1,4 @@
-// Copyright 2022-2025 Alexey Timin
+// Copyright 2022-2025 ReductSoftware UG
 #ifndef REDUCT_CPP_BUCKET_H
 #define REDUCT_CPP_BUCKET_H
 
@@ -89,6 +89,7 @@ class IBucket {
    * ReadableRecord
    */
   struct ReadableRecord {
+    std::string entry;
     Time timestamp;
     size_t size;
     bool last;
@@ -168,10 +169,12 @@ class IBucket {
   class Batch {
    public:
     struct Record {
+      std::string entry;
       Time timestamp;
       size_t size;
       std::string content_type;
       LabelMap labels;
+      std::optional<size_t> data_index;
     };
 
     /**
@@ -182,30 +185,48 @@ class IBucket {
      * @param labels
      */
     void AddRecord(Time timestamp, std::string data, std::string content_type = "", LabelMap labels = {}) {
-      records_[timestamp] = Record{timestamp, data.size(), std::move(content_type), std::move(labels)};
-      size_ += data.size();
+      AddRecord("", timestamp, std::move(data), std::move(content_type), std::move(labels));
+    }
+
+    void AddRecord(std::string entry, Time timestamp, std::string data, std::string content_type = "",
+                   LabelMap labels = {}) {
+      const auto index = body_.size();
       body_.push_back(std::move(data));
+      size_ += body_.back().size();
+      records_.push_back(
+          Record{std::move(entry), timestamp, body_.back().size(), std::move(content_type), std::move(labels), index});
     }
 
     /**
      * Add an empty record to batch (use for removing)
      * @param timestamp
      */
-    void AddRecord(Time timestamp) { records_[timestamp] = Record{timestamp, 0, "", {}}; }
+    void AddRecord(Time timestamp) { records_.push_back(Record{{}, timestamp, 0, "", {}, std::nullopt}); }
+
+    void AddRecord(std::string entry, Time timestamp) {
+      records_.push_back(Record{std::move(entry), timestamp, 0, "", {}, std::nullopt});
+    }
+
+    void AddOnlyLabels(Time timestamp, LabelMap labels) { AddOnlyLabels("", timestamp, std::move(labels)); }
 
-    void AddOnlyLabels(Time timestamp, LabelMap labels) {
-      records_[timestamp] = Record{timestamp, 0, "", std::move(labels)};
+    void AddOnlyLabels(std::string entry, Time timestamp, LabelMap labels) {
+      records_.push_back(Record{std::move(entry), timestamp, 0, "", std::move(labels), std::nullopt});
     }
 
-    [[nodiscard]] const std::map<Time, Record>& records() const { return records_; }
+    [[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(const std::optional<std::vector<size_t>>& order, size_t offset,
+                                    size_t size) const {
       if (offset >= size_) {
         return "";
       }
 
       std::string result;
-      for (const auto& data : body_) {
+      const auto process_data = [&](const std::string& data) {
         if (offset < data.size()) {
           auto n = std::min(size, data.size() - offset);
           result.append(data.substr(offset, n));
@@ -214,9 +235,25 @@ class IBucket {
         } else {
           offset -= data.size();
         }
+      };
 
-        if (size == 0) {
-          break;
+      if (order) {
+        for (auto idx : *order) {
+          const auto& record = records_.at(idx);
+          if (!record.data_index) {
+            continue;
+          }
+          process_data(body_.at(*record.data_index));
+          if (size == 0) {
+            break;
+          }
+        }
+      } else {
+        for (const auto& data : body_) {
+          process_data(data);
+          if (size == 0) {
+            break;
+          }
         }
       }
 
@@ -226,7 +263,7 @@ class IBucket {
     [[nodiscard]] uint64_t size() const { return size_; }
 
    private:
-    std::map<Time, Record> records_;
+    std::vector<Record> records_;
     std::vector<std::string> body_;
     uint64_t size_ = 0;
   };
@@ -457,11 +494,14 @@ class IBucket {
    * @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,
+                                        std::optional<std::string> api_version) noexcept;
 };
 }  // namespace reduct
 
diff --git a/src/reduct/client.cc b/src/reduct/client.cc
index 1f7be85..209874c 100644
--- a/src/reduct/client.cc
+++ b/src/reduct/client.cc
@@ -111,7 +111,7 @@ class Client : public IClient {
       return {{}, std::move(err)};
     }
 
-    return {IBucket::Build(url_, name, options_), {}};
+    return {IBucket::Build(url_, name, options_, client_->ApiVersion()), {}};
   }
 
   [[nodiscard]] UPtrResult<IBucket> CreateBucket(std::string_view name,
@@ -122,7 +122,7 @@ class Client : public IClient {
       return {nullptr, std::move(err)};
     }
 
-    return {IBucket::Build(url_, name, options_), {}};
+    return {IBucket::Build(url_, name, options_, client_->ApiVersion()), {}};
   }
 
   UPtrResult<IBucket> GetOrCreateBucket(std::string_view name, IBucket::Settings settings) const noexcept override {
diff --git a/src/reduct/client.h b/src/reduct/client.h
index e68ac7a..1a7f4e5 100644
--- a/src/reduct/client.h
+++ b/src/reduct/client.h
@@ -1,4 +1,4 @@
-// Copyright 2022-2024 Alexey Timin
+// Copyright 2022-2024 ReductSoftware UG
 
 #ifndef REDUCT_CPP_CLIENT_H
 #define REDUCT_CPP_CLIENT_H
diff --git a/src/reduct/diagnostics.h b/src/reduct/diagnostics.h
index 315f9b4..780ab18 100644
--- a/src/reduct/diagnostics.h
+++ b/src/reduct/diagnostics.h
@@ -1,4 +1,4 @@
-// Copyright 2024 Alexey Timin
+// Copyright 2024 ReductSoftware UG
 
 #ifndef REDUCT_CPP_DIAGNOSTICS_H
 #define REDUCT_CPP_DIAGNOSTICS_H
diff --git a/src/reduct/error.cc b/src/reduct/error.cc
index 2a5dbb4..4471fb8 100644
--- a/src/reduct/error.cc
+++ b/src/reduct/error.cc
@@ -1,4 +1,4 @@
-// Copyright 2022 Alexey Timin
+// Copyright 2022 ReductSoftware UG
 
 #include "reduct/error.h"
 #define FMT_HEADER_ONLY 1
diff --git a/src/reduct/error.h b/src/reduct/error.h
index 7c21b16..f8c7a45 100644
--- a/src/reduct/error.h
+++ b/src/reduct/error.h
@@ -1,4 +1,4 @@
-// Copyright 2022 Alexey Timin
+// Copyright 2022 ReductSoftware UG
 
 #ifndef REDUCT_ERROR_H
 #define REDUCT_ERROR_H
diff --git a/src/reduct/http_options.h b/src/reduct/http_options.h
index ee0e386..e73bf0b 100644
--- a/src/reduct/http_options.h
+++ b/src/reduct/http_options.h
@@ -1,4 +1,4 @@
-// Copyright 2022 Alexey Timin
+// Copyright 2022 ReductSoftware UG
 // Copyright 2024-2025 ReductSoftware UG
 
 #ifndef REDUCTCPP_HTTP_OPTIONS_H
diff --git a/src/reduct/internal/batch_v1.cc b/src/reduct/internal/batch_v1.cc
new file mode 100644
index 0000000..ab96f76
--- /dev/null
+++ b/src/reduct/internal/batch_v1.cc
@@ -0,0 +1,270 @@
+// Copyright 2026 ReductSoftware UG
+
+#include "reduct/internal/batch_v1.h"
+
+#include <fmt/core.h>
+#include <fmt/ranges.h>
+
+#include <algorithm>
+#include <chrono>
+#include <deque>
+#include <map>
+#include <mutex>
+#include <optional>
+#include <set>
+#include <sstream>
+#include <string>
+#include <string_view>
+#include <thread>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+namespace reduct::internal {
+
+int64_t ToMicroseconds(const IBucket::Time& ts) {
+  return std::chrono::duration_cast<std::chrono::microseconds>(ts.time_since_epoch()).count();
+}
+
+IBucket::Time FromMicroseconds(const std::string& ts) {
+  return IBucket::Time() + std::chrono::microseconds(std::stoul(ts));
+}
+
+std::string RecordEntry(const IBucket::Batch::Record& record, std::string_view default_entry) {
+  return record.entry.empty() ? std::string(default_entry) : record.entry;
+}
+
+std::string FormatLabels(const IBucket::LabelMap& labels) {
+  std::vector<std::string> formatted;
+  formatted.reserve(labels.size());
+  for (const auto& [label_key, label_value] : labels) {
+    auto value = label_value;
+    if (value.find(',') != std::string::npos) {
+      value = fmt::format("\"{}\"", value);
+    }
+    formatted.push_back(fmt::format("{}={}", label_key, value));
+  }
+
+  return fmt::format("{}", fmt::join(formatted, ","));
+}
+
+std::vector<size_t> SortRecords(const IBucket::Batch& batch, const std::string& default_entry, bool sort_by_entry) {
+  std::vector<size_t> order;
+  order.reserve(batch.records().size());
+  for (size_t i = 0; i < batch.records().size(); ++i) {
+    order.push_back(i);
+  }
+
+  std::sort(order.begin(), order.end(), [&](auto lhs, auto rhs) {
+    const auto& left = batch.records()[lhs];
+    const auto& right = batch.records()[rhs];
+    if (sort_by_entry) {
+      auto left_entry = RecordEntry(left, default_entry);
+      auto right_entry = RecordEntry(right, default_entry);
+      if (left_entry != right_entry) {
+        return left_entry < right_entry;
+      }
+    }
+    if (left.timestamp == right.timestamp) {
+      return RecordEntry(left, default_entry) < RecordEntry(right, default_entry);
+    }
+    return left.timestamp < right.timestamp;
+  });
+
+  return order;
+}
+
+std::vector<IBucket::ReadableRecord> ParseAndBuildBatchedRecordsV1(
+    std::deque<std::optional<std::string>>* data, std::mutex* mutex, bool head, IHttpClient::Headers&& headers) {
+  auto parse_csv = [](const std::string& csv) {
+    std::vector<std::string> items;
+    std::string escaped, item;
+    std::stringstream ss(csv);
+
+    while (std::getline(ss, item, ',')) {
+      if (item.starts_with("\"") && escaped.empty()) {
+        escaped = item.substr(1);
+      }
+
+      if (!escaped.empty()) {
+        if (item.ends_with("\"")) {
+          escaped = escaped.substr(0, escaped.size() - 2);
+          items.push_back(escaped);
+          escaped = "";
+        } else {
+          escaped += item;
+        }
+      } else {
+        items.push_back(item);
+      }
+    }
+
+    auto size = std::stoll(items[0]);
+    auto content_type = items[1];
+    IBucket::LabelMap labels = {};
+
+    for (auto i = 2; i < items.size(); i++) {
+      auto pos = items[i].find('=');
+      if (pos == std::string::npos) {
+        continue;
+      }
+
+      auto key = items[i].substr(0, pos);
+      labels[key] = items[i].substr(pos + 1);
+    }
+
+    return std::tuple{
+        size,
+        content_type,
+        labels,
+    };
+  };
+
+  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-"); });
+
+  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-")) {
+      continue;
+    }
+
+    auto [size, content_type, labels] = parse_csv(header->second);
+
+    IBucket::ReadableRecord record;
+    record.timestamp = FromMicroseconds(header->first.substr(14));
+    record.size = size;
+    record.content_type = content_type;
+    record.labels = labels;
+    record.Read = [data, mutex, size, head](auto record_callback) {
+      if (head) {
+        return Error::kOk;
+      }
+
+      size_t total = 0;
+      while (true) {
+        std::optional<std::string> chunk = "";
+        {
+          std::lock_guard lock(*mutex);
+          if (!data->empty()) {
+            chunk = std::move(data->front());
+            data->pop_front();
+
+            if (chunk->size() > size - total) {
+              auto tmp = chunk->substr(0, size - total);
+              data->push_front(chunk->substr(size - total));
+              chunk = std::move(tmp);
+            }
+          }
+        }
+
+        if (!chunk) {
+          break;
+        }
+
+        if (chunk->empty()) {
+          std::this_thread::sleep_for(std::chrono::microseconds(100));
+          continue;
+        }
+
+        total += chunk->size();
+        if (!record_callback(std::move(*chunk))) {
+          break;
+        }
+
+        if (total >= size) {
+          break;
+        }
+      }
+
+      return Error::kOk;
+    };
+
+    record.last = (records.size() == total_records - 1 && headers["x-reduct-last"] == "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) {
+  auto ordered = SortRecords(batch, std::string(entry_name), false);
+
+  std::set<std::string> unique_entries;
+  for (auto idx : ordered) {
+    unique_entries.insert(RecordEntry(batch.records()[idx], entry_name));
+  }
+
+  if (unique_entries.size() > 1) {
+    return {
+        {},
+        Error{.code = -1, .message = "Batch protocol v2 is required to target multiple entries in one request"},
+    };
+  }
+
+  IHttpClient::Headers headers;
+  for (auto idx : ordered) {
+    const auto& record = batch.records()[idx];
+    const auto key = fmt::format("x-reduct-time-{}", ToMicroseconds(record.timestamp));
+
+    switch (type) {
+      case BatchType::kWrite: {
+        const auto value = fmt::format("{},{},{}", record.size, record.content_type, FormatLabels(record.labels));
+        headers.emplace(key, value);
+        break;
+      }
+      case BatchType::kUpdate: {
+        const auto value = fmt::format("0,,{}", FormatLabels(record.labels));
+        headers.emplace(key, value);
+        break;
+      }
+      case BatchType::kRemove:
+        headers.emplace(key, "0,");
+        break;
+    }
+  }
+
+  Result<std::tuple<std::string, IHttpClient::Headers>> resp_result;
+  switch (type) {
+    case BatchType::kWrite: {
+      const auto content_length = batch.size();
+      resp_result = client->Post(fmt::format("{}/{}/batch", bucket_path, entry_name), "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;
+    }
+    case BatchType::kUpdate:
+      resp_result = client->Patch(fmt::format("{}/{}/batch", bucket_path, entry_name), "", std::move(headers));
+      break;
+
+    case BatchType::kRemove:
+      resp_result = client->Delete(fmt::format("{}/{}/batch", bucket_path, entry_name), std::move(headers));
+      break;
+  }
+
+  auto [resp, err] = resp_result;
+  if (err) {
+    return {{}, err};
+  }
+
+  IBucket::WriteBatchErrors errors;
+  for (const auto& [key, value] : std::get<1>(resp)) {
+    if (key.starts_with("x-reduct-error-")) {
+      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});
+    }
+  }
+
+  return {errors, Error::kOk};
+}
+
+}  // namespace reduct::internal
diff --git a/src/reduct/internal/batch_v1.h b/src/reduct/internal/batch_v1.h
new file mode 100644
index 0000000..71522ac
--- /dev/null
+++ b/src/reduct/internal/batch_v1.h
@@ -0,0 +1,37 @@
+// Copyright 2026 ReductSoftware UG
+#ifndef REDUCT_CPP_BATCH_V1_H
+#define REDUCT_CPP_BATCH_V1_H
+
+#include <chrono>
+#include <deque>
+#include <mutex>
+#include <optional>
+#include <string_view>
+#include <string>
+#include <vector>
+
+#include "reduct/bucket.h"
+#include "reduct/internal/http_client.h"
+#include "reduct/result.h"
+
+namespace reduct::internal {
+
+enum class BatchType { kWrite, kUpdate, kRemove };
+
+int64_t ToMicroseconds(const IBucket::Time& ts);
+IBucket::Time FromMicroseconds(const std::string& ts);
+
+std::string RecordEntry(const IBucket::Batch::Record& record, std::string_view default_entry);
+std::string FormatLabels(const IBucket::LabelMap& labels);
+std::vector<size_t> SortRecords(const IBucket::Batch& batch, const std::string& default_entry,
+                                bool sort_by_entry);
+
+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);
+
+}  // namespace reduct::internal
+
+#endif  // REDUCT_CPP_BATCH_V1_H
diff --git a/src/reduct/internal/batch_v2.cc b/src/reduct/internal/batch_v2.cc
new file mode 100644
index 0000000..7f57c2e
--- /dev/null
+++ b/src/reduct/internal/batch_v2.cc
@@ -0,0 +1,466 @@
+// Copyright 2026 ReductSoftware UG
+
+#include "reduct/internal/batch_v2.h"
+
+#include <fmt/core.h>
+#include <fmt/ranges.h>
+
+#include <algorithm>
+#include <chrono>
+#include <deque>
+#include <limits>
+#include <mutex>
+#include <optional>
+#include <set>
+#include <sstream>
+#include <string>
+#include <string_view>
+#include <thread>
+#include <tuple>
+#include <unordered_map>
+#include <utility>
+#include <vector>
+#include <cctype>
+
+namespace reduct::internal {
+
+struct RecordHeaderV2 {
+  uint64_t content_length;
+  std::string content_type;
+  IBucket::LabelMap labels;
+};
+
+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 == '~') {
+      encoded.push_back(ch);
+    } else {
+      encoded.append(fmt::format("%{:02X}", static_cast<unsigned char>(ch)));
+    }
+  }
+  return encoded;
+}
+
+static std::string Trim(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::optional<std::string> DecodeEntryName(std::string_view encoded) {
+  std::string decoded;
+  decoded.reserve(encoded.size());
+  for (size_t i = 0; i < encoded.size(); ++i) {
+    if (encoded[i] == '%') {
+      if (i + 2 >= encoded.size()) {
+        return std::nullopt;
+      }
+
+      auto hex = encoded.substr(i + 1, 2);
+      try {
+        auto value = static_cast<char>(std::stoi(std::string(hex), nullptr, 16));
+        decoded.push_back(value);
+        i += 2;
+      } catch (...) {
+        return std::nullopt;
+      }
+    } else {
+      decoded.push_back(encoded[i]);
+    }
+  }
+
+  return decoded;
+}
+
+static std::vector<std::string> ParseEncodedList(std::string_view raw) {
+  std::vector<std::string> items;
+  std::stringstream ss{std::string(raw)};
+  std::string item;
+  while (std::getline(ss, item, ',')) {
+    item = Trim(item);
+    if (auto decoded = DecodeEntryName(item)) {
+      items.push_back(std::move(*decoded));
+    }
+  }
+  return items;
+}
+
+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-")) {
+    return std::nullopt;
+  }
+
+  auto suffix = name.substr(std::string("x-reduct-").size());
+  auto dash = suffix.rfind('-');
+  if (dash == std::string::npos) {
+    return std::nullopt;
+  }
+
+  auto entry_str = suffix.substr(0, dash);
+  auto delta_str = suffix.substr(dash + 1);
+
+  try {
+    auto entry_idx = static_cast<size_t>(std::stoul(entry_str));
+    auto delta = std::stoull(delta_str);
+    return std::pair{entry_idx, delta};
+  } catch (...) {
+    return std::nullopt;
+  }
+}
+
+static std::vector<std::pair<std::string, std::optional<std::string>>> ParseLabelDeltaOps(
+    std::string_view raw, const std::optional<std::vector<std::string>>& label_names) {
+  std::vector<std::pair<std::string, std::optional<std::string>>> ops;
+  size_t pos = 0;
+  while (pos < raw.size()) {
+    auto eq = raw.find('=', pos);
+    if (eq == std::string::npos) {
+      break;
+    }
+
+    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));
+                      });
+      if (digits) {
+        auto idx = std::stoul(key);
+        if (idx < label_names->size()) {
+          key = label_names->at(idx);
+        }
+      }
+    }
+
+    pos = eq + 1;
+    std::optional<std::string> value;
+
+    if (pos < raw.size() && raw[pos] == '"') {
+      ++pos;
+      auto quote = raw.find('"', pos);
+      if (quote == std::string::npos) {
+        break;
+      }
+      value = std::string(raw.substr(pos, quote - pos));
+      pos = quote + 1;
+    } else {
+      auto comma = raw.find(',', pos);
+      auto slice = raw.substr(pos, comma == std::string::npos ? raw.size() - pos : comma - pos);
+      auto trimmed_value = Trim(slice);
+      if (!trimmed_value.empty()) {
+        value = std::move(trimmed_value);
+      }
+      pos = comma == std::string::npos ? raw.size() : comma;
+    }
+
+    ops.emplace_back(std::move(key), std::move(value));
+    if (pos < raw.size() && raw[pos] == ',') {
+      ++pos;
+    }
+    while (pos < raw.size() && std::isspace(static_cast<unsigned char>(raw[pos]))) {
+      ++pos;
+    }
+  }
+
+  return ops;
+}
+
+static IBucket::LabelMap ApplyLabelDelta(std::string_view raw, const IBucket::LabelMap& base,
+                                         const std::optional<std::vector<std::string>>& label_names) {
+  IBucket::LabelMap labels = base;
+  for (auto& [key, value] : ParseLabelDeltaOps(raw, label_names)) {
+    if (value) {
+      labels[key] = *value;
+    } else {
+      labels.erase(key);
+    }
+  }
+  return labels;
+}
+
+static std::optional<RecordHeaderV2> ParseRecordHeaderV2(const std::string& raw,
+                                                         const std::optional<RecordHeaderV2>& previous,
+                                                         const std::optional<std::vector<std::string>>& label_names) {
+  auto first_comma = raw.find(',');
+  auto length_str =
+      Trim(first_comma == std::string::npos ? std::string_view(raw) : std::string_view(raw).substr(0, first_comma));
+  if (length_str.empty()) {
+    return std::nullopt;
+  }
+
+  uint64_t content_length = 0;
+  try {
+    content_length = std::stoull(length_str);
+  } catch (...) {
+    return std::nullopt;
+  }
+
+  std::string content_type;
+  std::optional<std::string> labels_raw;
+  if (first_comma != std::string::npos) {
+    auto rest = std::string_view(raw).substr(first_comma + 1);
+    auto second_comma = rest.find(',');
+    if (second_comma == std::string::npos) {
+      content_type = Trim(rest);
+    } else {
+      content_type = Trim(rest.substr(0, second_comma));
+      labels_raw = std::string(rest.substr(second_comma + 1));
+    }
+  }
+
+  if (content_type.empty()) {
+    if (previous) {
+      content_type = previous->content_type;
+    } else {
+      content_type = "application/octet-stream";
+    }
+  }
+
+  auto labels = previous ? previous->labels : IBucket::LabelMap{};
+  if (labels_raw) {
+    labels = ApplyLabelDelta(*labels_raw, labels, label_names);
+  }
+
+  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> records;
+  auto entries_it = headers.find("x-reduct-entries");
+  auto start_ts_it = headers.find("x-reduct-start-ts");
+  if (entries_it == headers.end() || start_ts_it == headers.end()) {
+    return records;
+  }
+
+  auto entries = ParseEncodedList(entries_it->second);
+  if (entries.empty()) {
+    return records;
+  }
+
+  uint64_t start_ts = 0;
+  try {
+    start_ts = std::stoull(start_ts_it->second);
+  } catch (...) {
+    return records;
+  }
+
+  std::optional<std::vector<std::string>> label_names;
+  if (auto labels_it = headers.find("x-reduct-labels"); labels_it != headers.end()) {
+    label_names = ParseEncodedList(labels_it->second);
+  }
+
+  std::vector<std::tuple<size_t, uint64_t, std::string>> parsed_headers;
+  parsed_headers.reserve(headers.size());
+  for (const auto& [key, value] : headers) {
+    auto parsed = ParseBatchedHeaderNameV2(key);
+    if (!parsed) {
+      continue;
+    }
+    parsed_headers.emplace_back(parsed->first, parsed->second, value);
+  }
+
+  std::sort(parsed_headers.begin(), parsed_headers.end(), [](const auto& lhs, const auto& rhs) {
+    if (std::get<0>(lhs) == std::get<0>(rhs)) {
+      return std::get<1>(lhs) < std::get<1>(rhs);
+    }
+    return std::get<0>(lhs) < std::get<0>(rhs);
+  });
+
+  std::vector<std::optional<RecordHeaderV2>> last_header(entries.size());
+  for (const auto& [entry_idx, delta, value] : parsed_headers) {
+    if (entry_idx >= entries.size()) {
+      continue;
+    }
+
+    auto header = ParseRecordHeaderV2(value, last_header[entry_idx], label_names);
+    if (!header) {
+      continue;
+    }
+
+    last_header[entry_idx] = header;
+
+    IBucket::ReadableRecord record;
+    record.entry = entries[entry_idx];
+    record.timestamp = IBucket::Time() + std::chrono::microseconds(start_ts + delta);
+    record.size = header->content_length;
+    record.content_type = header->content_type;
+    record.labels = header->labels;
+    record.last = false;
+    record.Read = [data, mutex, head, size = header->content_length](auto record_callback) {
+      if (head) {
+        return Error::kOk;
+      }
+
+      size_t total = 0;
+      while (true) {
+        std::optional<std::string> chunk = "";
+        {
+          std::lock_guard lock(*mutex);
+          if (!data->empty()) {
+            chunk = std::move(data->front());
+            data->pop_front();
+
+            if (chunk && chunk->size() > size - total) {
+              auto tmp = chunk->substr(0, size - total);
+              data->push_front(chunk->substr(size - total));
+              chunk = std::move(tmp);
+            }
+          }
+        }
+
+        if (!chunk) {
+          break;
+        }
+
+        if (chunk->empty()) {
+          std::this_thread::sleep_for(std::chrono::microseconds(100));
+          continue;
+        }
+
+        total += chunk->size();
+        if (!record_callback(std::move(*chunk))) {
+          break;
+        }
+
+        if (total >= size) {
+          break;
+        }
+      }
+
+      return Error::kOk;
+    };
+
+    records.push_back(std::move(record));
+  }
+
+  if (!records.empty() && headers["x-reduct-last"] == "true") {
+    records.back().last = true;
+  }
+
+  return records;
+}
+
+static std::string BuildHeaderValueV2(const IBucket::Batch::Record& record, BatchType type) {
+  switch (type) {
+    case BatchType::kRemove:
+      return "";
+    case BatchType::kUpdate: {
+      auto labels = FormatLabels(record.labels);
+      if (labels.empty()) {
+        return "0";
+      }
+      return fmt::format("0,,{}", labels);
+    }
+    case BatchType::kWrite: {
+      auto labels = FormatLabels(record.labels);
+      if (labels.empty()) {
+        return fmt::format("{},{}", record.size, record.content_type);
+      }
+      return fmt::format("{},{},{}", record.size, record.content_type, labels);
+    }
+  }
+  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);
+
+  if (ordered.empty()) {
+    return {IBucket::WriteBatchErrors{}, Error::kOk};
+  }
+
+  uint64_t start_ts = std::numeric_limits<uint64_t>::max();
+  std::vector<std::string> entries;
+  std::unordered_map<std::string, size_t> entry_indices;
+  for (auto idx : ordered) {
+    const auto& record = batch.records()[idx];
+    auto ts = static_cast<uint64_t>(ToMicroseconds(record.timestamp));
+    start_ts = std::min(start_ts, ts);
+
+    auto entry = RecordEntry(record, entry_name);
+    if (!entry_indices.contains(entry)) {
+      entry_indices[entry] = entries.size();
+      entries.push_back(entry);
+    }
+  }
+
+  std::vector<std::string> encoded_entries;
+  encoded_entries.reserve(entries.size());
+  for (const auto& entry : 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));
+
+  for (auto idx : ordered) {
+    const auto& record = batch.records()[idx];
+    const auto entry = RecordEntry(record, entry_name);
+    const auto entry_idx = entry_indices[entry];
+    const auto delta = static_cast<uint64_t>(ToMicroseconds(record.timestamp)) - start_ts;
+
+    auto key = fmt::format("x-reduct-{}-{}", entry_idx, delta);
+    headers.emplace(std::move(key), BuildHeaderValueV2(record, type));
+  }
+
+  Result<std::tuple<std::string, IHttpClient::Headers>> resp_result;
+  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;
+    }
+    case BatchType::kUpdate:
+      resp_result = client->Patch(fmt::format("{}/update", io_path), "", std::move(headers));
+      break;
+
+    case BatchType::kRemove:
+      resp_result = client->Delete(fmt::format("{}/remove", io_path), std::move(headers));
+      break;
+  }
+
+  auto [resp, err] = resp_result;
+  if (err) {
+    return {{}, err};
+  }
+
+  IBucket::WriteBatchErrors 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());
+      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) {
+        continue;
+      }
+      auto status = std::stoi(value.substr(0, pos));
+      auto message = value.substr(pos + 1);
+      errors.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
new file mode 100644
index 0000000..0d34d54
--- /dev/null
+++ b/src/reduct/internal/batch_v2.h
@@ -0,0 +1,25 @@
+// Copyright 2026 ReductSoftware UG
+#ifndef REDUCT_CPP_BATCH_V2_H
+#define REDUCT_CPP_BATCH_V2_H
+
+#include <deque>
+#include <mutex>
+#include <optional>
+#include <string_view>
+#include <vector>
+
+#include "reduct/internal/batch_v1.h"
+
+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);
+
+}  // namespace reduct::internal
+
+#endif  // REDUCT_CPP_BATCH_V2_H
diff --git a/src/reduct/internal/http_client.cc b/src/reduct/internal/http_client.cc
index afe89bb..eea6827 100644
--- a/src/reduct/internal/http_client.cc
+++ b/src/reduct/internal/http_client.cc
@@ -1,4 +1,4 @@
-// Copyright 2022-2024 Alexey Timin
+// Copyright 2022-2026 ReductSoftware UG
 
 #include "reduct/internal/http_client.h"
 #undef CPPHTTPLIB_BROTLI_SUPPORT
@@ -8,6 +8,8 @@
 #include <nlohmann/json.hpp>
 
 #include <algorithm>
+#include <mutex>
+#include <optional>
 #include <string>
 
 namespace reduct::internal {
@@ -77,24 +79,34 @@ class HttpClient : public IHttpClient {
   }
 
   Error Get(std::string_view path, ResponseCallback resp_callback, ReadCallback read_callback) const noexcept override {
+    return Get(path, {}, std::move(resp_callback), std::move(read_callback));
+  }
+
+  Error Get(std::string_view path, Headers headers, ResponseCallback resp_callback,
+            ReadCallback read_callback) const noexcept override {
+    httplib::Headers httplib_headers;
+    for (auto& [k, v] : headers) {
+      httplib_headers.emplace(k, v);
+    }
+
     Error err = Error::kOk;
     std::string err_body;
     auto res = client_->Get(
-        AddApiPrefix(path),
+        AddApiPrefix(path), httplib_headers,
         [&](const auto& response) {
           if (response.status != 200) {
             err.code = response.status;
           }
 
-          Headers headers;
+          Headers normalized_headers;
           for (auto& [k, v] : response.headers) {
             std::string lowcase_header = k;
             std::transform(k.begin(), k.end(), lowcase_header.begin(), [](auto ch) { return std::tolower(ch); });
-            headers[lowcase_header] = v;
+            normalized_headers[lowcase_header] = v;
           }
 
           if (!err) {
-            resp_callback(std::move(headers));
+            resp_callback(std::move(normalized_headers));
           }
           return true;
         },
@@ -109,21 +121,28 @@ class HttpClient : public IHttpClient {
     return CheckRequest(res);
   }
 
-  Result<Headers> Head(std::string_view path) const noexcept override {
-    auto res = client_->Head(AddApiPrefix(path).data());
+  Result<Headers> Head(std::string_view path) const noexcept override { return Head(path, {}); }
+
+  Result<Headers> Head(std::string_view path, Headers headers) const noexcept override {
+    httplib::Headers httplib_headers;
+    for (auto& [k, v] : headers) {
+      httplib_headers.emplace(k, v);
+    }
+
+    auto res = client_->Head(AddApiPrefix(path).data(), httplib_headers);
     auto err = CheckRequest(res);
     if (err) {
       return {{}, std::move(err)};
     }
 
-    Headers headers;
+    Headers normalized_headers;
     for (auto& [k, v] : res->headers) {
       std::string lowcase_header = k;
       std::transform(k.begin(), k.end(), lowcase_header.begin(), [](auto ch) { return std::tolower(ch); });
-      headers[lowcase_header] = v;
+      normalized_headers[lowcase_header] = v;
     }
 
-    return {std::move(headers), Error::kOk};
+    return {std::move(normalized_headers), Error::kOk};
   }
 
   Error Post(std::string_view path, std::string_view body, std::string_view mime) const noexcept override {
@@ -200,8 +219,18 @@ class HttpClient : public IHttpClient {
     return {{content, NormalizeHeaders(std::move(res)).result}};
   }
 
+  [[nodiscard]] std::optional<std::string> ApiVersion() const noexcept override {
+    std::lock_guard lock(api_version_mutex_);
+    return api_version_;
+  }
+
+  void SetApiVersion(std::optional<std::string> version) noexcept override {
+    std::lock_guard lock(api_version_mutex_);
+    api_version_ = std::move(version);
+  }
+
  private:
-  static Error CheckRequest(const httplib::Result& res) noexcept {
+  Error CheckRequest(const httplib::Result& res) const noexcept {
     if (res.error() != httplib::Error::Success) {
       return Error{.code = -1, .message = httplib::to_string(res.error())};
     }
@@ -234,6 +263,11 @@ class HttpClient : public IHttpClient {
                   << ", please update the server up to " << REDUCT_CPP_MAJOR_VERSION << "." << REDUCT_CPP_MINOR_VERSION
                   << std::endl;
       }
+
+      {
+        std::lock_guard lock(api_version_mutex_);
+        api_version_ = api_version->second;
+      }
     }
 
     return Error::kOk;
@@ -245,6 +279,8 @@ class HttpClient : public IHttpClient {
   std::string api_token_;
   std::string api_prefix_;
   mutable std::string access_token_;
+  mutable std::optional<std::string> api_version_;
+  mutable std::mutex api_version_mutex_;
 };
 
 std::unique_ptr<IHttpClient> IHttpClient::Build(std::string_view url, const HttpOptions& options) {
diff --git a/src/reduct/internal/http_client.h b/src/reduct/internal/http_client.h
index e494367..41cc0ef 100644
--- a/src/reduct/internal/http_client.h
+++ b/src/reduct/internal/http_client.h
@@ -1,10 +1,11 @@
-// Copyright 2022-2023 Alexey Timin
+// Copyright 2022-2023 ReductSoftware UG
 
 #ifndef REDUCT_CPP_HTTP_CLIENT_H
 #define REDUCT_CPP_HTTP_CLIENT_H
 
 #include <functional>
 #include <memory>
+#include <optional>
 #include <string_view>
 
 #include "reduct/http_options.h"
@@ -18,6 +19,7 @@ namespace reduct::internal {
 class IHttpClient {
  public:
   virtual Result<std::string> Get(std::string_view path) const noexcept = 0;
+  using WriteCallback = std::function<std::pair<bool, std::string>(size_t offset, size_t size)>;
 
   using ReadCallback = std::function<bool(std::string_view)>;
   using Headers = std::unordered_map<std::string, std::string>;
@@ -25,15 +27,18 @@ class IHttpClient {
 
   virtual Error Get(std::string_view path, ResponseCallback, ReadCallback) const noexcept = 0;
 
+  virtual Error Get(std::string_view path, Headers headers, ResponseCallback, ReadCallback) const noexcept = 0;
+
   virtual Result<Headers> Head(std::string_view path) const noexcept = 0;
 
+  virtual Result<Headers> Head(std::string_view path, Headers headers) const noexcept = 0;
+
   virtual Error Post(std::string_view path, std::string_view body,
                      std::string_view mime = "application/json") const noexcept = 0;
 
   virtual Result<std::string> PostWithResponse(std::string_view path, std::string_view body,
                                                std::string_view mime = "application/json") const noexcept = 0;
 
-  using WriteCallback = std::function<std::pair<bool, std::string>(size_t offset, size_t size)>;
   virtual Result<std::tuple<std::string, Headers>> Post(std::string_view path, std::string_view mime,
                                                         size_t content_length, Headers headers,
                                                         WriteCallback) const noexcept = 0;
@@ -47,6 +52,9 @@ class IHttpClient {
   virtual Result<std::tuple<std::string, Headers>> Delete(std::string_view path,
                                                           Headers headers = {}) const noexcept = 0;
 
+  [[nodiscard]] virtual std::optional<std::string> ApiVersion() const noexcept = 0;
+  virtual void SetApiVersion(std::optional<std::string> version) noexcept = 0;
+
   static std::unique_ptr<IHttpClient> Build(std::string_view url, const HttpOptions &options);
 };
 
diff --git a/src/reduct/internal/serialisation.h b/src/reduct/internal/serialisation.h
index 2affa3e..3a843c7 100644
--- a/src/reduct/internal/serialisation.h
+++ b/src/reduct/internal/serialisation.h
@@ -1,4 +1,4 @@
-// Copyright 2022 Alexey Timin
+// Copyright 2022 ReductSoftware UG
 
 #ifndef REDUCTCPP_SERIALISATION_H
 #define REDUCTCPP_SERIALISATION_H
diff --git a/src/reduct/result.h b/src/reduct/result.h
index ecde445..7fb0ffe 100644
--- a/src/reduct/result.h
+++ b/src/reduct/result.h
@@ -1,4 +1,4 @@
-// Copyright 2022 Alexey Timin
+// Copyright 2022 ReductSoftware UG
 
 #ifndef REDUCT_CPP_RESULT_H
 #define REDUCT_CPP_RESULT_H
diff --git a/tests/fixture.h b/tests/fixture.h
index b7d3c89..bcc9b14 100644
--- a/tests/fixture.h
+++ b/tests/fixture.h
@@ -1,4 +1,4 @@
-// Copyright 2022 Alexey Timin
+// Copyright 2022 ReductSoftware UG
 
 #ifndef REDUCT_CPP_HELPERS_H
 #define REDUCT_CPP_HELPERS_H
diff --git a/tests/reduct/bucket_api_test.cc b/tests/reduct/bucket_api_test.cc
index c439662..bf8eb6b 100644
--- a/tests/reduct/bucket_api_test.cc
+++ b/tests/reduct/bucket_api_test.cc
@@ -1,4 +1,4 @@
-// Copyright 2022-2025 Alexey Timin
+// Copyright 2022-2025 ReductSoftware UG
 
 #include <catch2/catch.hpp>
 
diff --git a/tests/reduct/entry_api_test.cc b/tests/reduct/entry_api_test.cc
index 83b8cb1..75586f1 100644
--- a/tests/reduct/entry_api_test.cc
+++ b/tests/reduct/entry_api_test.cc
@@ -1,9 +1,11 @@
-// Copyright 2022-2024 Alexey Timin
+// Copyright 2022-2024 ReductSoftware UG
 
 #include <catch2/catch.hpp>
 
 #include <fstream>
+#include <map>
 #include <sstream>
+#include <vector>
 
 #include "fixture.h"
 #include "reduct/client.h"
@@ -293,6 +295,98 @@ TEST_CASE("reduct::IBucket should query records (huge blobs)", "[entry_api]") {
   REQUIRE(received_data[1] == blob2);
 }
 
+TEST_CASE("reduct::IBucket should query multiple entries", "[entry_api][1_18]") {
+  Fixture ctx;
+  auto [bucket, _] = ctx.client->CreateBucket(kBucketName);
+  REQUIRE(bucket);
+
+  IBucket::Time ts{};
+  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);
+
+  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;
+  });
+
+  REQUIRE(err == Error::kOk);
+  REQUIRE(received == std::map<std::string, std::string>{{"entry-a", "aaa"}, {"entry-b", "bbb"}});
+}
+
+TEST_CASE("reduct::IBucket should update a batch across entries", "[entry_api][1_18]") {
+  Fixture ctx;
+  auto [bucket, _] = ctx.client->CreateBucket(kBucketName);
+  REQUIRE(bucket);
+
+  IBucket::Time ts{};
+  REQUIRE(bucket->Write("entry-a", ts, [](auto rec) { rec->WriteAll("aaa"); }) == Error::kOk);
+  REQUIRE(bucket->Write("entry-b", ts, [](auto rec) { rec->WriteAll("bbb"); }) == Error::kOk);
+
+  auto [errors, err] = bucket->UpdateBatch("entry-a", [ts](IBucket::Batch* batch) {
+    batch->AddOnlyLabels("entry-a", ts, {{"x", "1"}});
+    batch->AddOnlyLabels("entry-b", ts, {{"y", "2"}});
+  });
+
+  REQUIRE(err == Error::kOk);
+  REQUIRE(errors.empty());
+
+  REQUIRE(bucket->Read("entry-a", ts, [](auto record) {
+    REQUIRE(record.labels == std::map<std::string, std::string>{{"x", "1"}});
+    return true;
+  }) == Error::kOk);
+
+  REQUIRE(bucket->Read("entry-b", ts, [](auto record) {
+    REQUIRE(record.labels == std::map<std::string, std::string>{{"y", "2"}});
+    return true;
+  }) == Error::kOk);
+}
+
+TEST_CASE("reduct::IBucket should remove records across entries via query", "[entry_api][1_18]") {
+  Fixture ctx;
+  auto [bucket, _] = ctx.client->CreateBucket(kBucketName);
+  REQUIRE(bucket);
+
+  IBucket::Time ts{};
+  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), {});
+  REQUIRE(err == Error::kOk);
+  REQUIRE(removed == 2);
+
+  REQUIRE(bucket->Read("entry-a", ts, [](auto) { return true; }) ==
+          Error{.code = 404, .message = "No record with timestamp 0"});
+  REQUIRE(bucket->Read("entry-b", ts + us(1), [](auto) { return true; }) ==
+          Error{.code = 404, .message = "No record with timestamp 1"});
+}
+
+TEST_CASE("reduct::IBucket should remove a batch across entries", "[entry_api][1_18]") {
+  Fixture ctx;
+  auto [bucket, _] = ctx.client->CreateBucket(kBucketName);
+  REQUIRE(bucket);
+
+  IBucket::Time ts{};
+  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 [errors, err] = bucket->RemoveBatch("entry-a", [ts](IBucket::Batch* batch) {
+    batch->AddRecord("entry-a", ts);
+    batch->AddRecord("entry-b", ts + us(1));
+  });
+
+  REQUIRE(err == Error::kOk);
+  REQUIRE(errors.empty());
+
+  REQUIRE(bucket->Read("entry-a", ts, [](auto) { return true; }) ==
+          Error{.code = 404, .message = "No record with timestamp 0"});
+  REQUIRE(bucket->Read("entry-b", ts + us(1), [](auto) { return true; }) ==
+          Error{.code = 404, .message = "No record with timestamp 1"});
+}
+
 TEST_CASE("reduct::IBucket should resample data", "[entry_api][1_10]") {
   Fixture ctx;
   auto [bucket, _] = ctx.client->CreateBucket(kBucketName);
@@ -598,6 +692,37 @@ TEST_CASE("reduct::IBucket should rename an entry", "[bucket_api][1_12]") {
   }) == Error::kOk);
 }
 
+TEST_CASE("reduct::IBucket should write a batch to multiple entries", "[entry_api][1_18]") {
+  Fixture ctx;
+  auto [bucket, _] = ctx.client->CreateBucket(kBucketName);
+  REQUIRE(bucket);
+
+  auto t = IBucket::Time();
+  auto [errors, err] = bucket->WriteBatch("default-entry", [t](IBucket::Batch* batch) {
+    batch->AddRecord("entry-a", t, "aaa", "text/plain", {{"label", "one"}});
+    batch->AddRecord("entry-b", t + us(1), "bbb");
+  });
+
+  REQUIRE(err == Error::kOk);
+  REQUIRE(errors.empty());
+
+  REQUIRE(bucket->Read("entry-a", t, [](auto record) {
+    auto [data, read_err] = record.ReadAll();
+    REQUIRE(read_err == Error::kOk);
+    REQUIRE(data == "aaa");
+    REQUIRE(record.labels == std::map<std::string, std::string>{{"label", "one"}});
+    REQUIRE(record.content_type == "text/plain");
+    return true;
+  }) == Error::kOk);
+
+  REQUIRE(bucket->Read("entry-b", t + us(1), [](auto record) {
+    auto [data, read_err] = record.ReadAll();
+    REQUIRE(read_err == Error::kOk);
+    REQUIRE(data == "bbb");
+    return true;
+  }) == Error::kOk);
+}
+
 TEST_CASE("Batch should slice data", "[batch]") {
   auto batch = IBucket::Batch();
 
@@ -624,4 +749,10 @@ TEST_CASE("Batch should slice data", "[batch]") {
   SECTION("slice all record") { REQUIRE(batch.Slice(0, 30) == "111111111122222222223333333333"); }
 
   SECTION("slice out of range") { REQUIRE(batch.Slice(0, 31) == "111111111122222222223333333333"); }
+
+  SECTION("slice with custom order") {
+    std::vector<size_t> order{2, 0, 1};
+    REQUIRE(batch.Slice(order, 0, 30) == "333333333311111111112222222222");
+    REQUIRE(batch.Slice(order, 5, 10) == "3333311111");
+  }
 }
diff --git a/tests/reduct/replication_api_test.cc b/tests/reduct/replication_api_test.cc
index ce36c22..cda2f7d 100644
--- a/tests/reduct/replication_api_test.cc
+++ b/tests/reduct/replication_api_test.cc
@@ -1,4 +1,4 @@
-// Copyright 2022-2024 Alexey Timin
+// Copyright 2022-2024 ReductSoftware UG
 
 #include <catch2/catch.hpp>
 
diff --git a/tests/reduct/server_api_test.cc b/tests/reduct/server_api_test.cc
index f3bfedf..7c4f7f4 100644
--- a/tests/reduct/server_api_test.cc
+++ b/tests/reduct/server_api_test.cc
@@ -1,4 +1,4 @@
-// Copyright 2022-2025 Alexey Timin
+// Copyright 2022-2025 ReductSoftware UG
 
 #include <catch2/catch.hpp>
 
diff --git a/tests/reduct/token_api_test.cc b/tests/reduct/token_api_test.cc
index bff480a..e732323 100644
--- a/tests/reduct/token_api_test.cc
+++ b/tests/reduct/token_api_test.cc
@@ -1,4 +1,4 @@
-// Copyright 2022-2024 Alexey Timin
+// Copyright 2022-2024 ReductSoftware UG
 
 #include <catch2/catch.hpp>
 
diff --git a/tests/test.cc b/tests/test.cc
index c65f3f5..d34c4f4 100644
--- a/tests/test.cc
+++ b/tests/test.cc
@@ -1,4 +1,4 @@
-// Copyright 2022 Alexey Timin
+// Copyright 2022 ReductSoftware UG
 #define CATCH_CONFIG_RUNNER
 
 #include <catch2/catch.hpp>