diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b6ee075b..000ab663 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -13,7 +13,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: Build cpplint image
-        run: pip install cpplint
+        run: pip install "cpplint<2"
       - name: Check code in /src
         run: find src/ -name "*.cc" -o -name "*.h"  | xargs cpplint
       - name: Check code in /tests
@@ -56,7 +56,7 @@ jobs:
           - reductstore_version: "main"
             exclude_api_version_tag: ""
           - reductstore_version: "latest"
-            exclude_api_version_tag: "~[1_12]"
+            exclude_api_version_tag: "~[1_13]"
           - license_file: ""
             exclude_license_tag: "~[license]"
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index aed095ad..e3c4fd61 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## Added
+
+- RS-543: Support conditional query, [PR-79](https://github.com/reductstore/reduct-cpp/pull/79)
+
 ## [1.12.0] = 2024-10-04
 
 ### Added
diff --git a/README.md b/README.md
index 57958ce8..223f684a 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@ in C++20. It allows developers to easily interact with the database from their C
 ## Features
 
 * Written in C++20
-* Support ReductStore [HTTP API v1.12](https://www.reduct.store/docs/next/http-api)
+* Support ReductStore [HTTP API v1.13](https://www.reduct.store/docs/next/http-api)
 * Support HTTP and HTTPS protocols
 * Support Linux AMD64 and Windows
 
diff --git a/src/reduct/bucket.cc b/src/reduct/bucket.cc
index 44ee1872..d67b63a4 100644
--- a/src/reduct/bucket.cc
+++ b/src/reduct/bucket.cc
@@ -23,6 +23,7 @@
 namespace reduct {
 
 using internal::IHttpClient;
+using internal::QueryOptionsToJsonString;
 
 class Bucket : public IBucket {
  public:
@@ -174,8 +175,8 @@ class Bucket : public IBucket {
       path.append(fmt::format("?ts={}", ToMicroseconds(*ts)));
     }
 
-    auto record_err = ReadRecord(std::move(path), false, false, callback);
-    return record_err;
+    auto record_err = ReadRecord(std::move(path), ReadType::kSingle, false, callback);
+    return record_err.error;
   }
 
   Error Head(std::string_view entry_name, std::optional<Time> ts, ReadRecordCallback callback) const noexcept override {
@@ -184,31 +185,46 @@ class Bucket : public IBucket {
       path.append(fmt::format("?ts={}", ToMicroseconds(*ts)));
     }
 
-    auto record_err = ReadRecord(std::move(path), false, true, callback);
-    return record_err;
+    auto record_err = ReadRecord(std::move(path), ReadType::kSingle, true, callback);
+    return record_err.error;
   }
 
   Error Query(std::string_view entry_name, std::optional<Time> start, std::optional<Time> stop, QueryOptions options,
               ReadRecordCallback callback) const noexcept override {
-    std::string url = BuildQueryUrl(start, stop, entry_name, options);
-    auto [body, err] = client_->Get(url);
-    if (err) {
-      return err;
+    std::string body;
+    if (options.when) {
+      auto [json_payload, json_err] = QueryOptionsToJsonString("QUERY", start, stop, options);
+      if (json_err) {
+        return json_err;
+      }
+
+      auto [resp, resp_err] = client_->PostWithResponse(fmt::format("{}/{}/q", path_, entry_name), json_payload.dump());
+      if (resp_err) {
+        return resp_err;
+      }
+
+      body = std::move(resp);
+    } else {
+      std::string url = BuildQueryUrl(start, stop, entry_name, options);
+      auto [resp, err] = client_->Get(url);
+      if (err) {
+        return err;
+      }
+
+      body = std::move(resp);
     }
 
     uint64_t id;
     try {
       auto data = nlohmann::json::parse(body);
-      id = data.at("id");
+      id = data["id"];
     } catch (const std::exception& ex) {
       return Error{.code = -1, .message = ex.what()};
     }
 
     while (true) {
-      bool batched = internal::IsCompatible("1.5", client_->api_version());
-      auto [stopped, record_err] =
-          ReadRecord(fmt::format("{}/{}{}?q={}", path_, entry_name, batched ? "/batch" : "", id), batched,
-                     options.head_only, callback);
+      auto [stopped, record_err] = ReadRecord(fmt::format("{}/{}/batch?q={}", path_, entry_name, id),
+                                              ReadType::kBatched, options.head_only, callback);
 
       if (stopped) {
         break;
@@ -232,14 +248,31 @@ 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 {
-    std::string url = BuildQueryUrl(start, stop, entry_name, options);
-    auto [resp, err] = client_->Delete(url);
-    if (err) {
-      return {0, std::move(err)};
+    std::string body;
+    if (options.when) {
+      auto [json_payload, json_err] = QueryOptionsToJsonString("REMOVE", start, stop, options);
+      if (json_err) {
+        return {0, std::move(json_err)};
+      }
+
+      auto [resp, resp_err] = client_->PostWithResponse(fmt::format("{}/{}/q", path_, entry_name), json_payload.dump());
+      if (resp_err) {
+        return {0, std::move(resp_err)};
+      }
+
+      body = std::move(resp);
+    } else {
+      std::string url = BuildQueryUrl(start, stop, entry_name, options);
+      auto [resp, err] = client_->Delete(url);
+      if (err) {
+        return {0, std::move(err)};
+      }
+
+      body = std::get<0>(resp);
     }
 
     try {
-      auto data = nlohmann::json::parse(std::get<0>(resp));
+      auto data = nlohmann::json::parse(body);
       return {data.at("removed_records"), Error::kOk};
     } catch (const std::exception& ex) {
       return {0, Error{.code = -1, .message = ex.what()}};
@@ -306,22 +339,26 @@ class Bucket : public IBucket {
     return url;
   }
 
-  Result<bool> ReadRecord(std::string&& path, bool batched, bool head,
+  enum class ReadType {
+    kSingle,
+    kBatched,
+  };
+
+  Result<bool> ReadRecord(std::string&& path, ReadType type, 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;
 
-    auto parse_headers_and_receive_data = [&stopped, &data, &data_mutex, &callback, &future, batched, head,
+    auto parse_headers_and_receive_data = [&type, &stopped, &data, &data_mutex, &callback, &future, head,
                                            this](IHttpClient::Headers&& headers) {
       std::vector<ReadableRecord> records;
-      if (batched) {
+      if (type == ReadType::kBatched) {
         records = ParseAndBuildBatchedRecords(&data, &data_mutex, head, std::move(headers));
       } else {
-        records.push_back(ParseAndBuildSingleRecord(&data, &data_mutex, head, std::move(headers)));
+        records.emplace_back(ParseAndBuildSingleRecord(&data, &data_mutex, head, std::move(headers)));
       }
-
       for (auto& record : records) {
         Task task([record = std::move(record), &callback, &stopped] {
           if (stopped) {
@@ -362,7 +399,10 @@ class Bucket : public IBucket {
         std::lock_guard lock(data_mutex);
         data.emplace_back(std::nullopt);
       }
-      future.wait();
+
+      if (future.valid()) {
+        future.wait();
+      }
     }
 
     return {stopped, err};
diff --git a/src/reduct/bucket.h b/src/reduct/bucket.h
index f2bdb078..c24f6229 100644
--- a/src/reduct/bucket.h
+++ b/src/reduct/bucket.h
@@ -313,13 +313,16 @@ class IBucket {
    */
   [[nodiscard]] virtual Result<BatchErrors> UpdateBatch(std::string_view entry_name,
                                                         BatchCallback callback) const noexcept = 0;
-
   /**
    * Query options
    */
   struct QueryOptions {
-    LabelMap include;              ///< include labels
-    LabelMap exclude;              ///< exclude labels
+    [[deprecated("Use when instead")]] LabelMap include;              ///< include labels
+    [[deprecated("Use when instead")]] LabelMap exclude;              ///< exclude labels
+
+    std::optional<std::string> when;  ///< query condition
+    std::optional<bool> strict;        ///< strict mode
+
     std::optional<double> each_s;  ///< return one record each S seconds
     std::optional<size_t> each_n;  ///< return each N-th record
     std::optional<size_t> limit;   ///< limit number of records
diff --git a/src/reduct/internal/serialisation.cc b/src/reduct/internal/serialisation.cc
index 702d0bab..1e86e5d6 100644
--- a/src/reduct/internal/serialisation.cc
+++ b/src/reduct/internal/serialisation.cc
@@ -179,4 +179,61 @@ Result<IClient::FullReplicationInfo> ParseFullReplicationInfo(const nlohmann::js
   return {info, Error::kOk};
 }
 
+Result<nlohmann::json> QueryOptionsToJsonString(std::string_view type, std::optional<IBucket::Time> start,
+                                                std::optional<IBucket::Time> stop,
+                                                const IBucket::QueryOptions& options) {
+  nlohmann::json json_data;
+  json_data["query_type"] = type;
+
+  if (start) {
+    json_data["start"] = std::chrono::duration_cast<std::chrono::microseconds>(start->time_since_epoch()).count();
+  }
+
+  if (stop) {
+    json_data["stop"] = std::chrono::duration_cast<std::chrono::microseconds>(stop->time_since_epoch()).count();
+  }
+
+  for (const auto& [key, value] : options.include) {
+    json_data["include"][key] = value;
+  }
+
+  for (const auto& [key, value] : options.exclude) {
+    json_data["exclude"][key] = value;
+  }
+
+  if (options.each_s) {
+    json_data["each_s"] = *options.each_s;
+  }
+
+  if (options.each_n) {
+    json_data["each_n"] = *options.each_n;
+  }
+
+  if (options.limit) {
+    json_data["limit"] = *options.limit;
+  }
+
+  if (options.ttl) {
+    json_data["ttl"] = options.ttl->count() / 1000;
+  }
+
+  if (options.continuous) {
+    json_data["continuous"] = true;
+  }
+
+  if (options.when) {
+    try {
+      json_data["when"] = nlohmann::json::parse(*options.when);
+    } catch (const std::exception& ex) {
+      return {{}, Error{.code = -1, .message = ex.what()}};
+    }
+  }
+
+  if (options.strict) {
+    json_data["strict"] = *options.strict;
+  }
+
+  return {json_data, Error::kOk};
+}
+
 }  // namespace reduct::internal
diff --git a/src/reduct/internal/serialisation.h b/src/reduct/internal/serialisation.h
index b3df6f4e..a9542d53 100644
--- a/src/reduct/internal/serialisation.h
+++ b/src/reduct/internal/serialisation.h
@@ -5,8 +5,8 @@
 
 #include <nlohmann/json.hpp>
 
-#include "reduct/client.h"
 #include "reduct/bucket.h"
+#include "reduct/client.h"
 
 namespace reduct::internal {
 
@@ -30,7 +30,6 @@ Result<IBucket::Settings> ParseBucketSettings(const nlohmann::json& json);
  */
 Result<IClient::FullTokenInfo> ParseTokenInfo(const nlohmann::json& json);
 
-
 /**
  * @brief Parse list of replication info from JSON string
  * @param json
@@ -38,7 +37,6 @@ Result<IClient::FullTokenInfo> ParseTokenInfo(const nlohmann::json& json);
  */
 Result<std::vector<IClient::ReplicationInfo>> ParseReplicationList(const nlohmann::json& data);
 
-
 /**
  * @brief Serialize replication settings
  * @param settings to serialize
@@ -53,6 +51,10 @@ nlohmann::json ReplicationSettingsToJsonString(IClient::ReplicationSettings sett
  */
 Result<IClient::FullReplicationInfo> ParseFullReplicationInfo(const nlohmann::json& data);
 
+Result<nlohmann::json> QueryOptionsToJsonString(std::string_view type, std::optional<IBucket::Time> start,
+                                                std::optional<IBucket::Time> stop,
+                                                const IBucket::QueryOptions& options);
+
 };  // namespace reduct::internal
 
 #endif  // REDUCTCPP_SERIALISATION_H
diff --git a/tests/reduct/entry_api_test.cc b/tests/reduct/entry_api_test.cc
index 28377871..21406335 100644
--- a/tests/reduct/entry_api_test.cc
+++ b/tests/reduct/entry_api_test.cc
@@ -25,13 +25,12 @@ TEST_CASE("reduct::IBucket should write/read a record", "[entry_api]") {
 
   IBucket::Time ts = IBucket::Time() + std::chrono::microseconds(123109210);
   std::string blob = "some blob of data";
-  REQUIRE(bucket->Write("entry",
-                        IBucket::WriteOptions{
-                            .timestamp = ts,
-                            .labels = {{"label1", "value1"}, {"label2", "value2"}},
-                            .content_type = "text/plain",
-                        },
-                        [&blob](auto rec) { rec->WriteAll(blob); }) == Error::kOk);
+  err = bucket->Write(
+      "entry",
+      IBucket::WriteOptions{
+          .timestamp = ts, .labels = {{"label1", "value1"}, {"label2", "value2"}}, .content_type = "text/plain"},
+      [&blob](auto rec) { rec->WriteAll(blob); });
+  REQUIRE(err == Error::kOk);
 
   std::string received_data;
   err = bucket->Read("entry", ts, [&received_data, ts](auto record) {
@@ -130,7 +129,7 @@ TEST_CASE("reduct::IBucket should write a record in chunks", "[entry_api]") {
   REQUIRE(err == Error::kOk);
 }
 
-TEST_CASE("reduct::IBucket should query records", "[entry_api]") {
+TEST_CASE("reduct::IBucket should query records", "[entry_api][1_13]") {
   auto [head, content] = GENERATE(std::make_tuple(false, "some_data1some_data2some_data3"), std::make_tuple(true, ""));
   CAPTURE(head);
 
@@ -142,7 +141,7 @@ TEST_CASE("reduct::IBucket should query records", "[entry_api]") {
   REQUIRE(bucket->Write("entry",
                         IBucket::WriteOptions{
                             .timestamp = ts,
-                            .labels = {{"label1", "value1"}},
+                            .labels = {{"score", "10"}},
                         },
                         [](auto rec) { rec->WriteAll("some_data1"); }) == Error::kOk);
   REQUIRE(bucket->Write("entry", ts + us(1), [](auto rec) { rec->WriteAll("some_data2"); }) == Error::kOk);
@@ -189,8 +188,27 @@ TEST_CASE("reduct::IBucket should query records", "[entry_api]") {
     REQUIRE(err == Error::kOk);
   }
 
-  SECTION("include labels") {
-    auto err = bucket->Query("entry", ts, ts + us(3), IBucket::QueryOptions{.include = {{"label1", "value1"}}},
+  SECTION("with condition") {
+    auto err = bucket->Query("entry", ts, ts + us(3), {.when = R"({"&score": {"$gt": 0}})"}, [&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_data1");
+  }
+
+  SECTION("with strict condition") {
+    auto err = bucket->Query("entry", ts, ts + us(3),
+                             {
+                                 .when = R"({"&NOT_EXIST": {"$gt": 0}})",
+                                 .strict = true,
+                             },
                              [&all_data](auto record) {
                                auto read_err = record.Read([&all_data](auto data) {
                                  all_data.append(data);
@@ -201,12 +219,15 @@ TEST_CASE("reduct::IBucket should query records", "[entry_api]") {
                                return true;
                              });
 
-    REQUIRE(err == Error::kOk);
-    REQUIRE(all_data == "some_data1");
+    REQUIRE(err == Error{.code = 404, .message = "Reference 'NOT_EXIST' not found"});
   }
 
-  SECTION("exclude labels") {
-    auto err = bucket->Query("entry", ts, ts + us(3), IBucket::QueryOptions{.exclude = {{"label1", "value1"}}},
+  SECTION("with non strict condition") {
+    auto err = bucket->Query("entry", ts, ts + us(3),
+                             {
+                                 .when = R"({"&NOT_EXIST": {"$gt": 0}})",
+                                 .strict = false,
+                             },
                              [&all_data](auto record) {
                                auto read_err = record.Read([&all_data](auto data) {
                                  all_data.append(data);
@@ -218,7 +239,7 @@ TEST_CASE("reduct::IBucket should query records", "[entry_api]") {
                              });
 
     REQUIRE(err == Error::kOk);
-    REQUIRE(all_data == "some_data2some_data3");
+    REQUIRE(all_data.empty());
   }
 }
 
@@ -487,6 +508,47 @@ TEST_CASE("reduct::IBucket should remove records by query", "[bucket_api][1_12]"
           Error{.code = 404, .message = "No record with timestamp 2"});
 }
 
+TEST_CASE("reduct::IBucket should remove records by query with when condition", "[bucket_api][1_13]") {
+  Fixture ctx;
+  auto [bucket, _] = ctx.client->CreateBucket(kBucketName);
+
+  auto t = IBucket::Time();
+  REQUIRE(bucket->Write("entry-1", IBucket::WriteOptions{.timestamp = t, .labels = {{"score", "10"}}},
+                        [](auto rec) { rec->WriteAll("some_data1"); }) == Error::kOk);
+  REQUIRE(bucket->Write("entry-1", IBucket::WriteOptions{.timestamp = t + us(1), .labels = {{"score", "20"}}},
+                        [](auto rec) { rec->WriteAll("some_data2"); }) == Error::kOk);
+
+  SECTION("ok") {
+    auto [removed_records, err] = bucket->RemoveQuery("entry-1", t, t + us(3), {.when = R"({"&score": {"$lt": 20}})"});
+    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 + 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"});
+  }
+
+  SECTION("strict") {
+    auto [removed_records, err] =
+        bucket->RemoveQuery("entry-1", t, t + us(3), {.when = R"({"&NOT_EXIST": {"$lt": 20}})", .strict = true});
+    REQUIRE(err == Error{.code = 404, .message = "Reference 'NOT_EXIST' not found"});
+  }
+
+  SECTION("non-strict") {
+    auto [removed_records, err] =
+        bucket->RemoveQuery("entry-1", t, t + us(3), {.when = R"({"&NOT_EXIST": {"$lt": 20}})", .strict = false});
+    REQUIRE(err == Error::kOk);
+    REQUIRE(removed_records == 0);
+  }
+}
+
 TEST_CASE("reduct::IBucket should rename an entry", "[bucket_api][1_12]") {
   Fixture ctx;
   auto [bucket, _] = ctx.client->CreateBucket(kBucketName);