diff --git a/docs/src/main/asciidoc/redis-reference.adoc b/docs/src/main/asciidoc/redis-reference.adoc
index 0d5f969364a0f..2a07b990f48b2 100644
--- a/docs/src/main/asciidoc/redis-reference.adoc
+++ b/docs/src/main/asciidoc/redis-reference.adoc
@@ -277,6 +277,7 @@ As mentioned above, the API is divided into groups:
 - stream (not available yet)
 - string - `.value(valueType)`
 - transactions - `withTransaction`
+- json - `.json()` (requires the https://redis.com/modules/redis-json/[redis-json] module on the server side)
 
 Each of these methods returns an object that lets you execute the commands related to the group.
 The following snippet demonstrates how to use the _hash_ group:
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/ReactiveRedisDataSource.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/ReactiveRedisDataSource.java
index 3004aaccfd595..4026035911272 100644
--- a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/ReactiveRedisDataSource.java
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/ReactiveRedisDataSource.java
@@ -7,6 +7,7 @@
 import io.quarkus.redis.datasource.geo.ReactiveGeoCommands;
 import io.quarkus.redis.datasource.hash.ReactiveHashCommands;
 import io.quarkus.redis.datasource.hyperloglog.ReactiveHyperLogLogCommands;
+import io.quarkus.redis.datasource.json.ReactiveJsonCommands;
 import io.quarkus.redis.datasource.keys.ReactiveKeyCommands;
 import io.quarkus.redis.datasource.list.ReactiveListCommands;
 import io.quarkus.redis.datasource.pubsub.ReactivePubSubCommands;
@@ -372,7 +373,7 @@ default ReactiveBitMapCommands<String> bitmap() {
     }
 
     /**
-     * Gets the objects to publish and receive messages.
+     * Gets the object to publish and receive messages.
      *
      * @param messageType the type of message
      * @param <V> the type of message
@@ -380,6 +381,25 @@ default ReactiveBitMapCommands<String> bitmap() {
      */
     <V> ReactivePubSubCommands<V> pubsub(Class<V> messageType);
 
+    /**
+     * Gets the object to manipulate JSON values.
+     * This group requires the <a href="https://redis.io/docs/stack/json/">RedisJSON module</a>.
+     *
+     * @return the object to manipulate JSON values.
+     */
+    default ReactiveJsonCommands<String> json() {
+        return json(String.class);
+    }
+
+    /**
+     * Gets the object to manipulate JSON values.
+     * This group requires the <a href="https://redis.io/docs/stack/json/">RedisJSON module</a>.
+     *
+     * @param <K> the type of keys
+     * @return the object to manipulate JSON values.
+     */
+    <K> ReactiveJsonCommands<K> json(Class<K> redisKeyType);
+
     /**
      * Executes a command.
      * This method is used to execute commands not offered by the API.
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/RedisDataSource.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/RedisDataSource.java
index 10783371f62d7..298900e8ede64 100644
--- a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/RedisDataSource.java
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/RedisDataSource.java
@@ -8,6 +8,7 @@
 import io.quarkus.redis.datasource.geo.GeoCommands;
 import io.quarkus.redis.datasource.hash.HashCommands;
 import io.quarkus.redis.datasource.hyperloglog.HyperLogLogCommands;
+import io.quarkus.redis.datasource.json.JsonCommands;
 import io.quarkus.redis.datasource.keys.KeyCommands;
 import io.quarkus.redis.datasource.list.ListCommands;
 import io.quarkus.redis.datasource.pubsub.PubSubCommands;
@@ -369,6 +370,25 @@ default BitMapCommands<String> bitmap() {
         return bitmap(String.class);
     }
 
+    /**
+     * Gets the object to manipulate JSON values.
+     * This group requires the <a href="https://redis.io/docs/stack/json/">RedisJSON module</a>.
+     *
+     * @return the object to manipulate JSON values.
+     */
+    default JsonCommands<String> json() {
+        return json(String.class);
+    }
+
+    /**
+     * Gets the object to manipulate JSON values.
+     * This group requires the <a href="https://redis.io/docs/stack/json/">RedisJSON module</a>.
+     *
+     * @param <K> the type of keys
+     * @return the object to manipulate JSON values.
+     */
+    <K> JsonCommands<K> json(Class<K> redisKeyType);
+
     /**
      * Gets the objects to publish and receive messages.
      *
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/JsonCommands.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/JsonCommands.java
new file mode 100644
index 0000000000000..04392391cbc2f
--- /dev/null
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/JsonCommands.java
@@ -0,0 +1,546 @@
+package io.quarkus.redis.datasource.json;
+
+import java.util.List;
+import java.util.OptionalInt;
+
+import io.quarkus.redis.datasource.RedisCommands;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+
+/**
+ * Allows executing commands from the {@code json} group (requires the Redis stack).
+ * See <a href="https://redis.io/commands/?group=json">the json command list</a> for further information about these commands.
+ * <p>
+ * Redis JSON lets you store, update, and retrieve JSON values in a Redis database, similar to any other Redis data type.
+ * <p>
+ * Ths API is based on the {@link JsonObject} and {@link JsonArray} types.
+ * Some methods also allows direct <em>mapping</em> from and to objects. In the case of deserialization, the
+ * {@link Class Class<T>} must be passed.
+ *
+ * @param <K> the type of the key
+ */
+public interface JsonCommands<K> extends RedisCommands {
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value, encoded to JSON
+     * @param <T> the type for the value
+     **/
+    <T> void jsonSet(K key, String path, T value);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param value the value, encoded to JSON
+     * @param <T> the type for the value
+     **/
+    default <T> void jsonSet(K key, T value) {
+        jsonSet(key, "$", value);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON object to store, must not be {@code null}
+     **/
+    void jsonSet(K key, String path, JsonObject json);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     * <p>
+     * This variant uses {@code $} as path.
+     *
+     * @param key the key, must not be {@code null}
+     * @param json the JSON object to store, must not be {@code null}
+     **/
+    default void jsonSet(K key, JsonObject json) {
+        jsonSet(key, "$", json);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON object to store, must not be {@code null}
+     * @param args the extra arguments
+     **/
+    void jsonSet(K key, String path, JsonObject json, JsonSetArgs args);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON array to store, must not be {@code null}
+     **/
+    void jsonSet(K key, String path, JsonArray json);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param json the JSON array to store, must not be {@code null}
+     **/
+    default void jsonSet(K key, JsonArray json) {
+        jsonSet(key, "$", json);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON array to store, must not be {@code null}
+     * @param args the extra arguments
+     **/
+    void jsonSet(K key, String path, JsonArray json, JsonSetArgs args);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value to store, encoded to JSON.
+     * @param args the extra arguments
+     **/
+    <T> void jsonSet(K key, String path, T value, JsonSetArgs args);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     * This method uses the root path ({@code $}).
+     * It map the retrieve JSON document to an object of type {@code <T>}.
+     *
+     * @param key the key, must not be {@code null}
+     * @param clazz the type of object to recreate from the JSON content
+     * @return the object, {@code null} if it does not exist
+     **/
+    <T> T jsonGet(K key, Class<T> clazz);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     * This method uses the root path ({@code $}).
+     * Unlike {@link #jsonGet(Object, Class)}, it returns a {@link JsonObject}.
+     *
+     * @param key the key, must not be {@code null}
+     * @return the stored JSON object, {@code null} if it does not exist
+     **/
+    JsonObject jsonGetObject(K key);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     * This method uses the root path ({@code $}).
+     * Unlike {@link #jsonGet(Object, Class)}, it returns a {@link JsonArray}.
+     *
+     * @param key the key, must not be {@code null}
+     * @return the stored JSON array, {@code null} if it does not exist
+     **/
+    JsonArray jsonGetArray(K key);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @return the JSON array containing the different results, {@code null} if it does not exist.
+     **/
+    JsonArray jsonGet(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param paths the paths, must not be {@code null}. If no path are passed, this is equivalent to
+     *        {@link #jsonGetObject(Object)},
+     *        if multiple paths are passed, the produced JSON object contains the result (as a json array) for each path.
+     * @return the stored JSON object, {@code null} if it does not exist.
+     *         If no path are passed, this is equivalent to {@link #jsonGetObject(Object)}.
+     *         If multiple paths are passed, the produced JSON object contains the result for each pass as a JSON array.
+     **/
+    JsonObject jsonGet(K key, String... paths);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrappend/">JSON.ARRAPPEND</a>.
+     * Summary: Append the json values into the array at path after the last element in it.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param values the values to append, encoded to JSON
+     * @param <T> the type of value
+     * @return a list with the new sizes of each modified array (in order) or {@code null} (instead of
+     *         the size) if the point object was not an array.
+     **/
+    <T> List<Integer> jsonArrAppend(K key, String path, T... values);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrindex/">JSON.ARRINDEX</a>.
+     * Summary: Searches for the first occurrence of a scalar JSON value in an array.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value to be searched, encoded to JSON
+     * @param start the start index
+     * @param end the end index
+     * @param <T> the type of value
+     * @return a list with the first position in the array of each JSON value that matches the path,
+     *         {@code -1} if not found in the array, or {@code null} if the matching JSON value is not an array.
+     **/
+    <T> List<Integer> jsonArrIndex(K key, String path, T value, int start, int end);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrindex/">JSON.ARRINDEX</a>.
+     * Summary: Searches for the first occurrence of a scalar JSON value in an array.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value to be searched, encoded to JSON
+     * @param <T> the type of value
+     * @return a list with the first position in the array of each JSON value that matches the path,
+     *         {@code -1} if not found in the array, or {@code null} if the matching JSON value is not an array.
+     **/
+    default <T> List<Integer> jsonArrIndex(K key, String path, T value) {
+        return jsonArrIndex(key, path, value, 0, 0);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrinsert/">JSON.ARRINSERT</a>.
+     * Summary: Inserts the json values into the array at path before the index (shifts to the right).
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param index the index. The index must be in the array's range. Inserting at index 0 prepends to the array.
+     *        Negative index values start from the end of the array.
+     * @param values the values to insert, encoded to JSON
+     * @param <T> the type of value
+     * @return a list of integer containing for each path, the array's new size or {@code null} if the
+     *         matching JSON value is not an array.
+     **/
+    <T> List<Integer> jsonArrInsert(K key, String path, int index, T... values);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrlen/">JSON.ARRLEN</a>.
+     * Summary: Reports the length of the JSON Array at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, {@code null} means {@code $}
+     * @return a list of integer containing for each path, the array's length, or @{code null} if the
+     *         matching JSON value is not an array.
+     **/
+    List<Integer> jsonArrLen(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrlen/">JSON.ARRLEN</a>.
+     * Summary: Reports the length of the JSON Array at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @return an optional containing the array's length, empty if the matching JSON value is not an array.
+     **/
+    default OptionalInt jsonArrLen(K key) {
+        List<Integer> list = jsonArrLen(key, null);
+        if (list.get(0) == null) {
+            return OptionalInt.empty();
+        }
+        return OptionalInt.of(list.get(0));
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrpop/">JSON.ARRPOP</a>.
+     * Summary: Removes and returns an element from the index in the array.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param clazz the type of the popped object
+     * @param path path the path, defaults to root if not provided.
+     * @param index is the position in the array to start popping from (defaults to -1, meaning the last element).
+     *        Out-of-range indexes round to their respective array ends.
+     * @return a list of T including for each path, an instance of T rebuilt from the JSON value, or
+     *         {@code null} if the matching JSON value is not an array. Popping an empty array produces {@code null}.
+     **/
+    <T> List<T> jsonArrPop(K key, Class<T> clazz, String path, int index);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrpop/">JSON.ARRPOP</a>.
+     * Summary: Removes and returns an element from the index in the array.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param clazz the type of the popped object
+     * @param path path the path, defaults to root if not provided.
+     * @return a list of T including for each path, an instance of T rebuilt from the JSON value, or
+     *         {@code null} if the matching JSON value is not an array. Popping an empty array produces {@code null}.
+     **/
+    default <T> List<T> jsonArrPop(K key, Class<T> clazz, String path) {
+        return jsonArrPop(key, clazz, path, -1);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrpop/">JSON.ARRPOP</a>.
+     * Summary: Removes and returns an element from the index in the array.
+     * Group: json
+     * <p>
+     * <p>
+     * This variant popped from the root object (must be a JSON array), and returns a single item.
+     *
+     * @param key the key, must not be {@code null}
+     * @param clazz the type of the popped object
+     * @return an instance of T.
+     **/
+    default <T> T jsonArrPop(K key, Class<T> clazz) {
+        List<T> list = jsonArrPop(key, clazz, null, -1);
+        return list.get(0);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrtrim/">JSON.ARRTRIM</a>.
+     * Summary: Trims an array so that it contains only the specified inclusive range of elements.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, must not be {@code null}
+     * @param start the start index
+     * @param stop the stop index
+     * @return a list of integer containing, for each path, the array's new size, or {@code null} if
+     *         the matching JSON value is not an array.
+     **/
+    List<Integer> jsonArrTrim(K key, String path, int start, int stop);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.clear/">JSON.CLEAR</a>.
+     * Summary: Clears container values (Arrays/Objects), and sets numeric values to 0.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided. Non-existing paths are ignored.
+     * @return the number of value cleared
+     **/
+    int jsonClear(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.clear/">JSON.CLEAR</a>.
+     * Summary: Clears container values (Arrays/Objects), and sets numeric values to 0.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @return the number of value cleared
+     **/
+    default int jsonClear(K key) {
+        return jsonClear(key, null);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.del/">JSON.DEL</a>.
+     * Summary: Deletes a value.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided. Non-existing paths are ignored.
+     * @return the number of path deleted
+     **/
+    int jsonDel(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.del/">JSON.DEL</a>.
+     * Summary: Deletes a value.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @return the number of path deleted (0 or more)
+     **/
+    default int jsonDel(K key) {
+        return jsonDel(key, null);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.mget/">JSON.MGET</a>.
+     * Summary: Returns the values at path from multiple key arguments. Returns {@code null} for nonexistent keys
+     * and nonexistent paths.
+     * Group: json
+     * <p>
+     *
+     * @param path path the path
+     * @param keys the keys, must not be {@code null}, must not contain {@code null}
+     * @return a list of JsonArray containing each retrieved value
+     **/
+    List<JsonArray> jsonMget(String path, K... keys);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.numincrby/">JSON.NUMINCRBY</a>.
+     * Summary: Increments the number value stored at path by number.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided. Non-existing paths are ignored.
+     * @param value the value to add
+     **/
+    void jsonNumincrby(K key, String path, double value);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.objkeys/">JSON.OBJKEYS</a>.
+     * Summary: Returns the keys in the object that's referenced by path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @return a list containing, for each matching path, the list of keys, or {@code null} if the
+     *         matching JSON value is not an object.
+     **/
+    List<List<String>> jsonObjKeys(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.objkeys/">JSON.OBJKEYS</a>.
+     * Summary: Returns the keys in the object that's referenced by path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @return a list containing the list of keys, or {@code null} if the stored value is not a JSON object.
+     **/
+    default List<String> jsonObjKeys(K key) {
+        List<List<String>> lists = jsonObjKeys(key, null);
+        return lists.get(0);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.objlen/">JSON.OBJLEN</a>.
+     * Summary: Reports the number of keys in the JSON Object at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @return a list containing, for each path, the length of the object, {@code null} if the matching
+     *         JSON value is not an object
+     **/
+    List<Integer> jsonObjLen(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.objlen/">JSON.OBJLEN</a>.
+     * Summary: Reports the number of keys in the JSON Object at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @return the length of the JSON object, {@code null} if the matching JSON value is not an object
+     **/
+    default OptionalInt jsonObjLen(K key) {
+        List<Integer> integers = jsonObjLen(key, null);
+        if (integers.get(0) == null) {
+            return OptionalInt.empty();
+        }
+        return OptionalInt.of(integers.get(0));
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.strappend/">JSON.STRAPPEND</a>.
+     * Summary: Appends the json-string values to the string at path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @param value the string to append, must not be {@code null}
+     * @return a list containing, for each path, the new string length, {@code null} if the matching JSON
+     *         value is not a string.
+     **/
+    List<Integer> jsonStrAppend(K key, String path, String value);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.strlen/">JSON.STRLEN</a>.
+     * Summary: Reports the length of the JSON String at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @return a list containing, for each path, the length of the string, {@code null} if the matching JSON
+     *         value is not a string. Returns {@code null} if the key or path do not exist.
+     **/
+    List<Integer> jsonStrLen(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.toggle/">JSON.TOGGLE</a>.
+     * Summary: Toggle a boolean value stored at path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, must not be {@code null}
+     * @return a list containing, for each path, the new boolean value, {@code null} if the matching JSON
+     *         value is not a boolean.
+     **/
+    List<Boolean> jsonToggle(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.type/">JSON.TYPE</a>.
+     * Summary: Reports the type of JSON value at path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @return a list containing, for each path, the json type as String (string, integer, number, boolean,
+     *         object, array), empty if no match.
+     **/
+    List<String> jsonType(K key, String path);
+
+}
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/JsonSetArgs.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/JsonSetArgs.java
new file mode 100644
index 0000000000000..cb5f37c0dd8db
--- /dev/null
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/JsonSetArgs.java
@@ -0,0 +1,47 @@
+package io.quarkus.redis.datasource.json;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import io.quarkus.redis.datasource.RedisCommandExtraArguments;
+
+public class JsonSetArgs implements RedisCommandExtraArguments {
+
+    private boolean nx = false;
+    private boolean xx = false;
+
+    /**
+     * Don't update already existing elements. Always add new elements.
+     *
+     * @return the current {@code GeoaddArgs}
+     **/
+    public JsonSetArgs nx() {
+        this.nx = true;
+        return this;
+    }
+
+    /**
+     * Only update elements that already exist. Never add elements.
+     *
+     * @return the current {@code GeoaddArgs}
+     **/
+    public JsonSetArgs xx() {
+        this.xx = true;
+        return this;
+    }
+
+    @Override
+    public List<String> toArgs() {
+        if (xx && nx) {
+            throw new IllegalArgumentException("Cannot set XX and NX together");
+        }
+        List<String> args = new ArrayList<>();
+        if (xx) {
+            args.add("XX");
+        }
+        if (nx) {
+            args.add("NX");
+        }
+        return args;
+    }
+}
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/ReactiveJsonCommands.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/ReactiveJsonCommands.java
new file mode 100644
index 0000000000000..629e353b91a30
--- /dev/null
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/ReactiveJsonCommands.java
@@ -0,0 +1,495 @@
+package io.quarkus.redis.datasource.json;
+
+import java.util.Collections;
+import java.util.List;
+
+import io.quarkus.redis.datasource.ReactiveRedisCommands;
+import io.smallrye.mutiny.Uni;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+
+/**
+ * Allows executing commands from the {@code json} group (requires the Redis stack).
+ * See <a href="https://redis.io/commands/?group=json">the json command list</a> for further information about these commands.
+ * <p>
+ * Redis JSON lets you store, update, and retrieve JSON values in a Redis database, similar to any other Redis data type.
+ * <p>
+ * Ths API is based on the {@link JsonObject} and {@link JsonArray} types.
+ * Some methods also allows direct <em>mapping</em> from and to objects. In the case of deserialization, the
+ * {@link Class Class<T>} must be passed.
+ *
+ * @param <K> the type of the key
+ */
+public interface ReactiveJsonCommands<K> extends ReactiveRedisCommands {
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value, encoded to JSON
+     * @param <T> the type for the value
+     * @return A uni emitting {@code null} when the operation completes
+     **/
+    <T> Uni<Void> jsonSet(K key, String path, T value);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON object to store, must not be {@code null}
+     * @return A uni emitting {@code null} when the operation completes
+     **/
+    Uni<Void> jsonSet(K key, String path, JsonObject json);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON object to store, must not be {@code null}
+     * @param args the extra arguments
+     * @return A uni emitting {@code null} when the operation completes
+     **/
+    Uni<Void> jsonSet(K key, String path, JsonObject json, JsonSetArgs args);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON array to store, must not be {@code null}
+     * @return A uni emitting {@code null} when the operation completes
+     **/
+    Uni<Void> jsonSet(K key, String path, JsonArray json);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON array to store, must not be {@code null}
+     * @param args the extra arguments
+     * @return A uni emitting {@code null} when the operation completes
+     **/
+    Uni<Void> jsonSet(K key, String path, JsonArray json, JsonSetArgs args);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value to store, encoded to JSON.
+     * @param args the extra arguments
+     * @return A uni emitting {@code null} when the operation completes
+     **/
+    <T> Uni<Void> jsonSet(K key, String path, T value, JsonSetArgs args);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     * This method uses the root path ({@code $}).
+     * It map the retrieve JSON document to an object of type {@code <T>}.
+     *
+     * @param key the key, must not be {@code null}
+     * @param clazz the type of object to recreate from the JSON content
+     * @return a uni emitting the object, {@code null} if it does not exist
+     **/
+    <T> Uni<T> jsonGet(K key, Class<T> clazz);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     * This method uses the root path ({@code $}).
+     * Unlike {@link #jsonGet(Object, Class)}, it returns a {@link JsonObject}.
+     *
+     * @param key the key, must not be {@code null}
+     * @return a uni emitting the stored JSON object, {@code null} if it does not exist
+     **/
+    Uni<JsonObject> jsonGetObject(K key);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     * This method uses the root path ({@code $}).
+     * Unlike {@link #jsonGet(Object, Class)}, it returns a {@link JsonArray}.
+     *
+     * @param key the key, must not be {@code null}
+     * @return a uni emitting the stored JSON array, {@code null} if it does not exist
+     **/
+    Uni<JsonArray> jsonGetArray(K key);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @return a uni emitting the JSON array containing the different results, {@code null} if it does not exist.
+     **/
+    Uni<JsonArray> jsonGet(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param paths the paths, must not be {@code null}. If no path are passed, this is equivalent to
+     *        {@link #jsonGetObject(Object)},
+     *        if multiple paths are passed, the produced JSON object contains the result (as a json array) for each path.
+     * @return a uni emitting the stored JSON object, {@code null} if it does not exist.
+     *         If no path are passed, this is equivalent to {@link #jsonGetObject(Object)}.
+     *         If multiple paths are passed, the produced JSON object contains the result for each pass as a JSON array.
+     **/
+    Uni<JsonObject> jsonGet(K key, String... paths);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrappend/">JSON.ARRAPPEND</a>.
+     * Summary: Append the json values into the array at path after the last element in it.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param values the values to append, encoded to JSON
+     * @param <T> the type of value
+     * @return a uni emitting a list with the new sizes of each modified array (in order) or {@code null} (instead of
+     *         the size) if the point object was not an array.
+     **/
+    <T> Uni<List<Integer>> jsonArrAppend(K key, String path, T... values);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrindex/">JSON.ARRINDEX</a>.
+     * Summary: Searches for the first occurrence of a scalar JSON value in an array.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value to be searched, encoded to JSON
+     * @param start the start index
+     * @param end the end index
+     * @param <T> the type of value
+     * @return a uni emitting a list with the first position in the array of each JSON value that matches the path,
+     *         {@code -1} if not found in the array, or {@code null} if the matching JSON value is not an array.
+     **/
+    <T> Uni<List<Integer>> jsonArrIndex(K key, String path, T value, int start, int end);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrindex/">JSON.ARRINDEX</a>.
+     * Summary: Searches for the first occurrence of a scalar JSON value in an array.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value to be searched, encoded to JSON
+     * @param <T> the type of value
+     * @return a uni emitting a list with the first position in the array of each JSON value that matches the path,
+     *         {@code -1} if not found in the array, or {@code null} if the matching JSON value is not an array.
+     **/
+    default <T> Uni<List<Integer>> jsonArrIndex(K key, String path, T value) {
+        return jsonArrIndex(key, path, value, 0, 0);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrinsert/">JSON.ARRINSERT</a>.
+     * Summary: Inserts the json values into the array at path before the index (shifts to the right).
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param index the index. The index must be in the array's range. Inserting at index 0 prepends to the array.
+     *        Negative index values start from the end of the array.
+     * @param values the values to insert, encoded to JSON
+     * @param <T> the type of value
+     * @return a uni emitting a list of integer containing for each path, the array's new size or {@code null} if the
+     *         matching JSON value is not an array.
+     **/
+    <T> Uni<List<Integer>> jsonArrInsert(K key, String path, int index, T... values);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrlen/">JSON.ARRLEN</a>.
+     * Summary: Reports the length of the JSON Array at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, {@code null} means {@code $}
+     * @return a uni emitting a list of integer containing for each path, the array's length, or @{code null} if the
+     *         matching JSON value is not an array.
+     **/
+    Uni<List<Integer>> jsonArrLen(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrlen/">JSON.ARRLEN</a>.
+     * Summary: Reports the length of the JSON Array at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @return a uni emitting the array's length, or @{code null} if the matching JSON value is not an array.
+     **/
+    default Uni<Integer> jsonArrLen(K key) {
+        return jsonArrLen(key, null).map(l -> l.get(0));
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrpop/">JSON.ARRPOP</a>.
+     * Summary: Removes and returns an element from the index in the array.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param clazz the type of the popped object
+     * @param path path the path, defaults to root if not provided.
+     * @param index is the position in the array to start popping from (defaults to -1, meaning the last element).
+     *        Out-of-range indexes round to their respective array ends.
+     * @return a uni emitting a list of T including for each path, an instance of T rebuilt from the JSON value, or
+     *         {@code null} if the matching JSON value is not an array. Popping an empty array produces {@code null}.
+     **/
+    <T> Uni<List<T>> jsonArrPop(K key, Class<T> clazz, String path, int index);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrpop/">JSON.ARRPOP</a>.
+     * Summary: Removes and returns an element from the index in the array.
+     * Group: json
+     * <p>
+     * <p>
+     * This variant popped from the root object (must be a JSON array), and returns a single item.
+     *
+     * @param key the key, must not be {@code null}
+     * @param clazz the type of the popped object
+     * @return a uni emitting an instance of T.
+     **/
+    default <T> Uni<T> jsonArrPop(K key, Class<T> clazz) {
+        return jsonArrPop(key, clazz, null, -1).map(l -> l.get(0));
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrtrim/">JSON.ARRTRIM</a>.
+     * Summary: Trims an array so that it contains only the specified inclusive range of elements.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, must not be {@code null}
+     * @param start the start index
+     * @param stop the stop index
+     * @return a uni emitting a list of integer containing, for each path, the array's new size, or {@code null} if
+     *         the matching JSON value is not an array.
+     **/
+    Uni<List<Integer>> jsonArrTrim(K key, String path, int start, int stop);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.clear/">JSON.CLEAR</a>.
+     * Summary: Clears container values (Arrays/Objects), and sets numeric values to 0.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided. Non-existing paths are ignored.
+     * @return a uni emitting the number of value cleared
+     **/
+    Uni<Integer> jsonClear(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.clear/">JSON.CLEAR</a>.
+     * Summary: Clears container values (Arrays/Objects), and sets numeric values to 0.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @return a uni emitting the number of value cleared
+     **/
+    default Uni<Integer> jsonClear(K key) {
+        return jsonClear(key, null);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.del/">JSON.DEL</a>.
+     * Summary: Deletes a value.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided. Non-existing paths are ignored.
+     * @return a uni emitting the number of path deleted
+     **/
+    Uni<Integer> jsonDel(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.del/">JSON.DEL</a>.
+     * Summary: Deletes a value.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @return a uni emitting the number of path deleted (0 or more)
+     **/
+    default Uni<Integer> jsonDel(K key) {
+        return jsonDel(key, null);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.mget/">JSON.MGET</a>.
+     * Summary: Returns the values at path from multiple key arguments. Returns {@code null} for nonexistent keys
+     * and nonexistent paths.
+     * Group: json
+     * <p>
+     *
+     * @param path path the path
+     * @param keys the keys, must not be {@code null}, must not contain {@code null}
+     * @return a uni emitting a list of JsonArray containing each retrieved value
+     **/
+    Uni<List<JsonArray>> jsonMget(String path, K... keys);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.numincrby/">JSON.NUMINCRBY</a>.
+     * Summary: Increments the number value stored at path by number.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided. Non-existing paths are ignored.
+     * @param value the value to add
+     * @return a uni emitting {@code null} when the operation completes
+     **/
+    Uni<Void> jsonNumincrby(K key, String path, double value);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.objkeys/">JSON.OBJKEYS</a>.
+     * Summary: Returns the keys in the object that's referenced by path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @return a uni emitting a list containing, for each matching path, the list of keys, or {@code null} if the
+     *         matching JSON value is not an object.
+     **/
+    Uni<List<List<String>>> jsonObjKeys(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.objkeys/">JSON.OBJKEYS</a>.
+     * Summary: Returns the keys in the object that's referenced by path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @return a uni emitting a list containing the list of keys, or {@code null} if the stored value is not a JSON object.
+     **/
+    default Uni<List<String>> jsonObjKeys(K key) {
+        return jsonObjKeys(key, null).map(l -> {
+            if (l != null && !l.isEmpty()) {
+                return l.get(0);
+            }
+            return Collections.emptyList();
+        });
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.objlen/">JSON.OBJLEN</a>.
+     * Summary: Reports the number of keys in the JSON Object at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @return a uni emitting a list containing, for each path, the length of the object, {@code null} if the matching
+     *         JSON value is not an object
+     **/
+    Uni<List<Integer>> jsonObjLen(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.objlen/">JSON.OBJLEN</a>.
+     * Summary: Reports the number of keys in the JSON Object at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @return a uni emitting the length of the JSON object, {@code null} if the matching JSON value is not an object
+     **/
+    default Uni<Integer> jsonObjLen(K key) {
+        return jsonObjLen(key, null)
+                .map(l -> l.get(0));
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.strappend/">JSON.STRAPPEND</a>.
+     * Summary: Appends the json-string values to the string at path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @param value the string to append, must not be {@code null}
+     * @return a uni emitting a list containing, for each path, the new string length, {@code null} if the matching JSON
+     *         value is not a string.
+     **/
+    Uni<List<Integer>> jsonStrAppend(K key, String path, String value);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.strlen/">JSON.STRLEN</a>.
+     * Summary: Reports the length of the JSON String at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @return a uni emitting a list containing, for each path, the length of the string, {@code null} if the matching JSON
+     *         value is not a string. Returns {@code null} if the key or path do not exist.
+     **/
+    Uni<List<Integer>> jsonStrLen(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.toggle/">JSON.TOGGLE</a>.
+     * Summary: Toggle a boolean value stored at path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, must not be {@code null}
+     * @return a uni emitting a list containing, for each path, the new boolean value, {@code null} if the matching JSON
+     *         value is not a boolean.
+     **/
+    Uni<List<Boolean>> jsonToggle(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.type/">JSON.TYPE</a>.
+     * Summary: Reports the type of JSON value at path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @return a uni emitting a list containing, for each path, the json type as String (string, integer, number, boolean,
+     *         object, array), empty if no match.
+     **/
+    Uni<List<String>> jsonType(K key, String path);
+
+}
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/ReactiveTransactionalJsonCommands.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/ReactiveTransactionalJsonCommands.java
new file mode 100644
index 0000000000000..a71ba1a74fbf8
--- /dev/null
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/ReactiveTransactionalJsonCommands.java
@@ -0,0 +1,434 @@
+package io.quarkus.redis.datasource.json;
+
+import io.quarkus.redis.datasource.ReactiveTransactionalRedisCommands;
+import io.smallrye.mutiny.Uni;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+
+public interface ReactiveTransactionalJsonCommands<K> extends ReactiveTransactionalRedisCommands {
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value, encoded to JSON
+     * @param <T> the type for the value
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    <T> Uni<Void> jsonSet(K key, String path, T value);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON object to store, must not be {@code null}
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonSet(K key, String path, JsonObject json);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON object to store, must not be {@code null}
+     * @param args the extra arguments
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonSet(K key, String path, JsonObject json, JsonSetArgs args);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON array to store, must not be {@code null}
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonSet(K key, String path, JsonArray json);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON array to store, must not be {@code null}
+     * @param args the extra arguments
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonSet(K key, String path, JsonArray json, JsonSetArgs args);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value to store, encoded to JSON.
+     * @param args the extra arguments
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    <T> Uni<Void> jsonSet(K key, String path, T value, JsonSetArgs args);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     * This method uses the root path ({@code $}).
+     * It maps the retrieve JSON document to an object of type {@code <T>}.
+     *
+     * @param key the key, must not be {@code null}
+     * @param clazz the type of object to recreate from the JSON content
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    <T> Uni<Void> jsonGet(K key, Class<T> clazz);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     * This method uses the root path ({@code $}).
+     * Unlike {@link #jsonGet(Object, Class)}, it returns a {@link JsonObject}.
+     *
+     * @param key the key, must not be {@code null}
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonGetObject(K key);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     * This method uses the root path ({@code $}).
+     * Unlike {@link #jsonGet(Object, Class)}, it returns a {@link JsonArray}.
+     *
+     * @param key the key, must not be {@code null}
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonGetArray(K key);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonGet(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param paths the paths, must not be {@code null}. If no path are passed, this is equivalent to
+     *        {@link #jsonGetObject(Object)},
+     *        if multiple paths are passed, the produced JSON object contains the result (as a json array) for each path.
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonGet(K key, String... paths);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrappend/">JSON.ARRAPPEND</a>.
+     * Summary: Append the json values into the array at path after the last element in it.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param values the values to append, encoded to JSON
+     * @param <T> the type of value
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    <T> Uni<Void> jsonArrAppend(K key, String path, T... values);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrindex/">JSON.ARRINDEX</a>.
+     * Summary: Searches for the first occurrence of a scalar JSON value in an array.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value to be searched, encoded to JSON
+     * @param start the start index
+     * @param end the end index
+     * @param <T> the type of value
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    <T> Uni<Void> jsonArrIndex(K key, String path, T value, int start, int end);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrindex/">JSON.ARRINDEX</a>.
+     * Summary: Searches for the first occurrence of a scalar JSON value in an array.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value to be searched, encoded to JSON
+     * @param <T> the type of value
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    default <T> Uni<Void> jsonArrIndex(K key, String path, T value) {
+        return jsonArrIndex(key, path, value, 0, 0);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrinsert/">JSON.ARRINSERT</a>.
+     * Summary: Inserts the json values into the array at path before the index (shifts to the right).
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param index the index. The index must be in the array's range. Inserting at index 0 prepends to the array.
+     *        Negative index values start from the end of the array.
+     * @param values the values to insert, encoded to JSON
+     * @param <T> the type of value
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    <T> Uni<Void> jsonArrInsert(K key, String path, int index, T... values);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrlen/">JSON.ARRLEN</a>.
+     * Summary: Reports the length of the JSON Array at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, {@code null} means {@code $}
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonArrLen(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrpop/">JSON.ARRPOP</a>.
+     * Summary: Removes and returns an element from the index in the array.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param clazz the type of the popped object
+     * @param path path the path, defaults to root if not provided.
+     * @param index is the position in the array to start popping from (defaults to -1, meaning the last element).
+     *        Out-of-range indexes round to their respective array ends.
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    <T> Uni<Void> jsonArrPop(K key, Class<T> clazz, String path, int index);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrtrim/">JSON.ARRTRIM</a>.
+     * Summary: Trims an array so that it contains only the specified inclusive range of elements.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, must not be {@code null}
+     * @param start the start index
+     * @param stop the stop index
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonArrTrim(K key, String path, int start, int stop);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.clear/">JSON.CLEAR</a>.
+     * Summary: Clears container values (Arrays/Objects), and sets numeric values to 0.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided. Non-existing paths are ignored.
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonClear(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.clear/">JSON.CLEAR</a>.
+     * Summary: Clears container values (Arrays/Objects), and sets numeric values to 0.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    default Uni<Void> jsonClear(K key) {
+        return jsonClear(key, null);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.del/">JSON.DEL</a>.
+     * Summary: Deletes a value.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided. Non-existing paths are ignored.
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonDel(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.del/">JSON.DEL</a>.
+     * Summary: Deletes a value.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    default Uni<Void> jsonDel(K key) {
+        return jsonDel(key, null);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.mget/">JSON.MGET</a>.
+     * Summary: Returns the values at path from multiple key arguments. Returns {@code null} for nonexistent keys
+     * and nonexistent paths.
+     * Group: json
+     * <p>
+     *
+     * @param path path the path
+     * @param keys the keys, must not be {@code null}, must not contain {@code null}
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonMget(String path, K... keys);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.numincrby/">JSON.NUMINCRBY</a>.
+     * Summary: Increments the number value stored at path by number.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided. Non-existing paths are ignored.
+     * @param value the value to add
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonNumincrby(K key, String path, double value);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.objkeys/">JSON.OBJKEYS</a>.
+     * Summary: Returns the keys in the object that's referenced by path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonObjKeys(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.objlen/">JSON.OBJLEN</a>.
+     * Summary: Reports the number of keys in the JSON Object at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonObjLen(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.strappend/">JSON.STRAPPEND</a>.
+     * Summary: Appends the json-string values to the string at path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @param value the string to append, must not be {@code null}
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonStrAppend(K key, String path, String value);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.strlen/">JSON.STRLEN</a>.
+     * Summary: Reports the length of the JSON String at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonStrLen(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.toggle/">JSON.TOGGLE</a>.
+     * Summary: Toggle a boolean value stored at path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, must not be {@code null}
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonToggle(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.type/">JSON.TYPE</a>.
+     * Summary: Reports the type of JSON value at path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @return A {@code Uni} emitting {@code null} when the command has been enqueued successfully in the transaction, a failure
+     *         otherwise. In the case of failure, the transaction is discarded.
+     */
+    Uni<Void> jsonType(K key, String path);
+
+}
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/TransactionalJsonCommands.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/TransactionalJsonCommands.java
new file mode 100644
index 0000000000000..cd44cdd07bffc
--- /dev/null
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/json/TransactionalJsonCommands.java
@@ -0,0 +1,372 @@
+package io.quarkus.redis.datasource.json;
+
+import io.quarkus.redis.datasource.TransactionalRedisCommands;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+
+public interface TransactionalJsonCommands<K> extends TransactionalRedisCommands {
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value, encoded to JSON
+     * @param <T> the type for the value
+     */
+    <T> void jsonSet(K key, String path, T value);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON object to store, must not be {@code null}
+     */
+    void jsonSet(K key, String path, JsonObject json);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON object to store, must not be {@code null}
+     * @param args the extra arguments
+     */
+    void jsonSet(K key, String path, JsonObject json, JsonSetArgs args);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON array to store, must not be {@code null}
+     */
+    void jsonSet(K key, String path, JsonArray json);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param json the JSON array to store, must not be {@code null}
+     * @param args the extra arguments
+     */
+    void jsonSet(K key, String path, JsonArray json, JsonSetArgs args);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.set/">JSON.SET</a>.
+     * Summary: Sets the JSON value at path in key.
+     * Group: json
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value to store, encoded to JSON.
+     * @param args the extra arguments
+     */
+    <T> void jsonSet(K key, String path, T value, JsonSetArgs args);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     * This method uses the root path ({@code $}).
+     * It maps the retrieve JSON document to an object of type {@code <T>}.
+     *
+     * @param key the key, must not be {@code null}
+     * @param clazz the type of object to recreate from the JSON content
+     */
+    <T> void jsonGet(K key, Class<T> clazz);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     * This method uses the root path ({@code $}).
+     * Unlike {@link #jsonGet(Object, Class)}, it returns a {@link JsonObject}.
+     *
+     * @param key the key, must not be {@code null}
+     */
+    void jsonGetObject(K key);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     * This method uses the root path ({@code $}).
+     * Unlike {@link #jsonGet(Object, Class)}, it returns a {@link JsonArray}.
+     *
+     * @param key the key, must not be {@code null}
+     */
+    void jsonGetArray(K key);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     */
+    void jsonGet(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.get/">JSON.GET</a>.
+     * Summary: Returns the value at path in JSON serialized form.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param paths the paths, must not be {@code null}. If no path are passed, this is equivalent to
+     *        {@link #jsonGetObject(Object)},
+     *        if multiple paths are passed, the produced JSON object contains the result (as a json array) for each path.
+     */
+    void jsonGet(K key, String... paths);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrappend/">JSON.ARRAPPEND</a>.
+     * Summary: Append the json values into the array at path after the last element in it.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param values the values to append, encoded to JSON
+     * @param <T> the type of value
+     */
+    <T> void jsonArrAppend(K key, String path, T... values);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrindex/">JSON.ARRINDEX</a>.
+     * Summary: Searches for the first occurrence of a scalar JSON value in an array.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value to be searched, encoded to JSON
+     * @param start the start index
+     * @param end the end index
+     * @param <T> the type of value
+     */
+    <T> void jsonArrIndex(K key, String path, T value, int start, int end);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrindex/">JSON.ARRINDEX</a>.
+     * Summary: Searches for the first occurrence of a scalar JSON value in an array.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param value the value to be searched, encoded to JSON
+     * @param <T> the type of value
+     */
+    default <T> void jsonArrIndex(K key, String path, T value) {
+        jsonArrIndex(key, path, value, 0, 0);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrinsert/">JSON.ARRINSERT</a>.
+     * Summary: Inserts the json values into the array at path before the index (shifts to the right).
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, must not be {@code null}
+     * @param index the index. The index must be in the array's range. Inserting at index 0 prepends to the array.
+     *        Negative index values start from the end of the array.
+     * @param values the values to insert, encoded to JSON
+     * @param <T> the type of value
+     */
+    <T> void jsonArrInsert(K key, String path, int index, T... values);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrlen/">JSON.ARRLEN</a>.
+     * Summary: Reports the length of the JSON Array at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path the path, {@code null} means {@code $}
+     */
+    void jsonArrLen(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrpop/">JSON.ARRPOP</a>.
+     * Summary: Removes and returns an element from the index in the array.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param clazz the type of the popped object
+     * @param path path the path, defaults to root if not provided.
+     * @param index is the position in the array to start popping from (defaults to -1, meaning the last element).
+     *        Out-of-range indexes round to their respective array ends.
+     */
+    <T> void jsonArrPop(K key, Class<T> clazz, String path, int index);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.arrtrim/">JSON.ARRTRIM</a>.
+     * Summary: Trims an array so that it contains only the specified inclusive range of elements.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, must not be {@code null}
+     * @param start the start index
+     * @param stop the stop index
+     */
+    void jsonArrTrim(K key, String path, int start, int stop);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.clear/">JSON.CLEAR</a>.
+     * Summary: Clears container values (Arrays/Objects), and sets numeric values to 0.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided. Non-existing paths are ignored.
+     */
+    void jsonClear(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.clear/">JSON.CLEAR</a>.
+     * Summary: Clears container values (Arrays/Objects), and sets numeric values to 0.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     */
+    default void jsonClear(K key) {
+        jsonClear(key, null);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.del/">JSON.DEL</a>.
+     * Summary: Deletes a value.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided. Non-existing paths are ignored.
+     */
+    void jsonDel(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.del/">JSON.DEL</a>.
+     * Summary: Deletes a value.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     */
+    default void jsonDel(K key) {
+        jsonDel(key, null);
+    }
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.mget/">JSON.MGET</a>.
+     * Summary: Returns the values at path from multiple key arguments. Returns {@code null} for nonexistent keys
+     * and nonexistent paths.
+     * Group: json
+     * <p>
+     *
+     * @param path path the path
+     * @param keys the keys, must not be {@code null}, must not contain {@code null}
+     */
+    void jsonMget(String path, K... keys);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.numincrby/">JSON.NUMINCRBY</a>.
+     * Summary: Increments the number value stored at path by number.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided. Non-existing paths are ignored.
+     * @param value the value to add
+     */
+    void jsonNumincrby(K key, String path, double value);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.objkeys/">JSON.OBJKEYS</a>.
+     * Summary: Returns the keys in the object that's referenced by path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     */
+    void jsonObjKeys(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.objlen/">JSON.OBJLEN</a>.
+     * Summary: Reports the number of keys in the JSON Object at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     */
+    void jsonObjLen(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.strappend/">JSON.STRAPPEND</a>.
+     * Summary: Appends the json-string values to the string at path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     * @param value the string to append, must not be {@code null}
+     */
+    void jsonStrAppend(K key, String path, String value);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.strlen/">JSON.STRLEN</a>.
+     * Summary: Reports the length of the JSON String at path in key.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     */
+    void jsonStrLen(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.toggle/">JSON.TOGGLE</a>.
+     * Summary: Toggle a boolean value stored at path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, must not be {@code null}
+     */
+    void jsonToggle(K key, String path);
+
+    /**
+     * Execute the command <a href="https://redis.io/commands/json.type/">JSON.TYPE</a>.
+     * Summary: Reports the type of JSON value at path.
+     * Group: json
+     * <p>
+     *
+     * @param key the key, must not be {@code null}
+     * @param path path the path, path defaults to {@code $} if not provided.
+     */
+    void jsonType(K key, String path);
+}
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/transactions/ReactiveTransactionalRedisDataSource.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/transactions/ReactiveTransactionalRedisDataSource.java
index d5bc340eb0d93..cf99a063b5d76 100644
--- a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/transactions/ReactiveTransactionalRedisDataSource.java
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/transactions/ReactiveTransactionalRedisDataSource.java
@@ -4,6 +4,7 @@
 import io.quarkus.redis.datasource.geo.ReactiveTransactionalGeoCommands;
 import io.quarkus.redis.datasource.hash.ReactiveTransactionalHashCommands;
 import io.quarkus.redis.datasource.hyperloglog.ReactiveTransactionalHyperLogLogCommands;
+import io.quarkus.redis.datasource.json.ReactiveTransactionalJsonCommands;
 import io.quarkus.redis.datasource.keys.ReactiveTransactionalKeyCommands;
 import io.quarkus.redis.datasource.list.ReactiveTransactionalListCommands;
 import io.quarkus.redis.datasource.set.ReactiveTransactionalSetCommands;
@@ -269,6 +270,25 @@ default ReactiveTransactionalBitMapCommands<String> bitmap() {
         return bitmap(String.class);
     }
 
+    /**
+     * Gets the object to manipulate JSON values.
+     * This group requires the <a href="https://redis.io/docs/stack/json/">RedisJSON module</a>.
+     *
+     * @return the object to manipulate JSON values.
+     */
+    default ReactiveTransactionalJsonCommands<String> json() {
+        return json(String.class);
+    }
+
+    /**
+     * Gets the object to manipulate JSON values.
+     * This group requires the <a href="https://redis.io/docs/stack/json/">RedisJSON module</a>.
+     *
+     * @param <K> the type of keys
+     * @return the object to manipulate JSON values.
+     */
+    <K> ReactiveTransactionalJsonCommands<K> json(Class<K> redisKeyType);
+
     /**
      * Executes a command.
      * This method is used to execute commands not offered by the API.
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/transactions/TransactionalRedisDataSource.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/transactions/TransactionalRedisDataSource.java
index 817fb9015522b..f0e37802c9509 100644
--- a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/transactions/TransactionalRedisDataSource.java
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/datasource/transactions/TransactionalRedisDataSource.java
@@ -4,6 +4,7 @@
 import io.quarkus.redis.datasource.geo.TransactionalGeoCommands;
 import io.quarkus.redis.datasource.hash.TransactionalHashCommands;
 import io.quarkus.redis.datasource.hyperloglog.TransactionalHyperLogLogCommands;
+import io.quarkus.redis.datasource.json.TransactionalJsonCommands;
 import io.quarkus.redis.datasource.keys.TransactionalKeyCommands;
 import io.quarkus.redis.datasource.list.TransactionalListCommands;
 import io.quarkus.redis.datasource.set.TransactionalSetCommands;
@@ -267,6 +268,25 @@ default TransactionalBitMapCommands<String> bitmap() {
         return bitmap(String.class);
     }
 
+    /**
+     * Gets the object to manipulate JSON values.
+     * This group requires the <a href="https://redis.io/docs/stack/json/">RedisJSON module</a>.
+     *
+     * @return the object to manipulate JSON values.
+     */
+    default TransactionalJsonCommands<String> json() {
+        return json(String.class);
+    }
+
+    /**
+     * Gets the object to manipulate JSON values.
+     * This group requires the <a href="https://redis.io/docs/stack/json/">RedisJSON module</a>.
+     *
+     * @param <K> the type of keys
+     * @return the object to manipulate JSON values.
+     */
+    <K> TransactionalJsonCommands<K> json(Class<K> redisKeyType);
+
     /**
      * Executes a command.
      * This method is used to execute commands not offered by the API.
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/AbstractJsonCommands.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/AbstractJsonCommands.java
new file mode 100644
index 0000000000000..a2a31ead49674
--- /dev/null
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/AbstractJsonCommands.java
@@ -0,0 +1,286 @@
+package io.quarkus.redis.runtime.datasource;
+
+import static io.quarkus.redis.runtime.datasource.Validation.notNullOrBlank;
+import static io.smallrye.mutiny.helpers.ParameterValidation.doesNotContainNull;
+import static io.smallrye.mutiny.helpers.ParameterValidation.nonNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import io.quarkus.redis.datasource.json.JsonSetArgs;
+import io.smallrye.mutiny.Uni;
+import io.vertx.core.json.Json;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+import io.vertx.mutiny.redis.client.Command;
+import io.vertx.mutiny.redis.client.Response;
+
+public class AbstractJsonCommands<K> extends AbstractRedisCommands {
+    private static final JsonSetArgs JSON_SET_DEFAULT = new JsonSetArgs();
+
+    public AbstractJsonCommands(RedisCommandExecutor api, Class<K> k) {
+        super(api, new Marshaller(k));
+    }
+
+    <T> Uni<Response> _jsonSet(K key, String path, T value) {
+        return _jsonSet(key, path, Json.encode(value).getBytes(), JSON_SET_DEFAULT);
+    }
+
+    Uni<Response> _jsonSet(K key, String path, JsonObject json) {
+        nonNull(json, "json");
+        return _jsonSet(key, path, json.toBuffer().getBytes(), JSON_SET_DEFAULT);
+    }
+
+    Uni<Response> _jsonSet(K key, String path, JsonArray json) {
+        nonNull(json, "json");
+        return _jsonSet(key, path, json.toBuffer().getBytes(), JSON_SET_DEFAULT);
+    }
+
+    Uni<Response> _jsonSet(K key, String path, JsonObject json, JsonSetArgs args) {
+        nonNull(json, "json");
+        return _jsonSet(key, path, json.toBuffer().getBytes(), args);
+    }
+
+    Uni<Response> _jsonSet(K key, String path, JsonArray json, JsonSetArgs args) {
+        nonNull(json, "json");
+        return _jsonSet(key, path, json.toBuffer().getBytes(), args);
+    }
+
+    <T> Uni<Response> _jsonSet(K key, String path, T value, JsonSetArgs args) {
+        return _jsonSet(key, path, Json.encode(value).getBytes(), args);
+    }
+
+    Uni<Response> _jsonSet(K key, String path, byte[] encoded, JsonSetArgs args) {
+        nonNull(key, "key");
+        notNullOrBlank(path, "path");
+        nonNull(args, "args");
+        RedisCommand cmd = RedisCommand.of(Command.JSON_SET)
+                .put(marshaller.encode(key))
+                .put(path)
+                .put(encoded)
+                .putAll(args.toArgs());
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonGet(K key) {
+        nonNull(key, "key");
+        RedisCommand cmd = RedisCommand.of((Command.JSON_GET))
+                .put(marshaller.encode(key));
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonGet(K key, String path) {
+        nonNull(key, "key");
+        nonNull(path, "path");
+        RedisCommand cmd = RedisCommand.of((Command.JSON_GET))
+                .put(marshaller.encode(key))
+                .put(path);
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonGet(K key, String... paths) {
+        nonNull(key, "key");
+        doesNotContainNull(paths, "path");
+        RedisCommand cmd = RedisCommand.of((Command.JSON_GET))
+                .put(marshaller.encode(key))
+                .putAll(paths);
+        return execute(cmd);
+    }
+
+    <T> Uni<Response> _jsonArrAppend(K key, String path, T... values) {
+        nonNull(key, "key");
+        doesNotContainNull(values, "values");
+        List<String> encoded = new ArrayList<>();
+        for (T value : values) {
+            encoded.add(Json.encode(value));
+        }
+        RedisCommand cmd = RedisCommand.of((Command.JSON_ARRAPPEND))
+                .put(marshaller.encode(key));
+
+        if (path != null) {
+            cmd.put(path);
+        }
+        cmd.putAll(encoded);
+        return execute(cmd);
+    }
+
+    <T> Uni<Response> _jsonArrIndex(K key, String path, T value, long start, long end) {
+        nonNull(key, "key");
+        nonNull(path, "path");
+        nonNull(value, "value");
+        RedisCommand cmd = RedisCommand.of(Command.JSON_ARRINDEX)
+                .put(marshaller.encode(key))
+                .put(path)
+                .put(Json.encode(value))
+                .put(start)
+                .put(end);
+        return execute(cmd);
+    }
+
+    <T> Uni<Response> _jsonArrInsert(K key, String path, int index, T[] values) {
+        nonNull(key, "key");
+        nonNull(path, "path");
+        doesNotContainNull(values, "values");
+        RedisCommand cmd = RedisCommand.of(Command.JSON_ARRINSERT)
+                .put(marshaller.encode(key))
+                .put(path)
+                .put(index);
+
+        for (T value : values) {
+            cmd.put(Json.encode(value));
+        }
+
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonArrLen(K key, String path) {
+        nonNull(key, "key");
+        RedisCommand cmd = RedisCommand.of((Command.JSON_ARRLEN))
+                .put(marshaller.encode(key));
+        if (path != null) {
+            cmd.put(path);
+        }
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonArrPop(K key, String path, int index) {
+        nonNull(key, "key");
+
+        RedisCommand cmd = RedisCommand.of(Command.JSON_ARRPOP)
+                .put(marshaller.encode(key));
+
+        if (path != null) {
+            cmd.put(path);
+        }
+        if (index != -1) {
+            cmd.put(-1);
+        }
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonArrTrim(K key, String path, int start, int stop) {
+        nonNull(key, "key");
+        nonNull(path, "path");
+        RedisCommand cmd = RedisCommand.of(Command.JSON_ARRTRIM)
+                .put(marshaller.encode(key))
+                .put(path)
+                .put(start)
+                .put(stop);
+
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonClear(K key, String path) {
+        nonNull(key, "key");
+        RedisCommand cmd = RedisCommand.of(Command.JSON_CLEAR)
+                .put(marshaller.encode(key));
+
+        if (path != null) {
+            cmd.put(path);
+        }
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonDel(K key, String path) {
+        nonNull(key, "key");
+        RedisCommand cmd = RedisCommand.of(Command.JSON_DEL)
+                .put(marshaller.encode(key));
+
+        if (path != null) {
+            cmd.put(path);
+        }
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonMget(String path, K... keys) {
+        notNullOrBlank(path, "path");
+        doesNotContainNull(keys, "keys");
+
+        RedisCommand cmd = RedisCommand.of(Command.JSON_MGET)
+                .put(path);
+
+        for (K key : keys) {
+            cmd.put(marshaller.encode(key));
+        }
+
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonNumincrby(K key, String path, double value) {
+        nonNull(key, "key");
+        notNullOrBlank(path, "path");
+
+        RedisCommand cmd = RedisCommand.of(Command.JSON_NUMINCRBY)
+                .put(marshaller.encode(key))
+                .put(path)
+                .put(value);
+
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonObjKeys(K key, String path) {
+        nonNull(key, "key");
+        RedisCommand cmd = RedisCommand.of(Command.JSON_OBJKEYS)
+                .put(marshaller.encode(key));
+        if (path != null) {
+            cmd.put(path);
+        }
+
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonObjLen(K key, String path) {
+        nonNull(key, "key");
+        RedisCommand cmd = RedisCommand.of(Command.JSON_OBJLEN)
+                .put(marshaller.encode(key));
+        if (path != null) {
+            cmd.put(path);
+        }
+
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonStrAppend(K key, String path, String value) {
+        nonNull(key, "key");
+        nonNull(value, "value");
+        RedisCommand cmd = RedisCommand.of(Command.JSON_STRAPPEND)
+                .put(marshaller.encode(key));
+        if (path != null) {
+            cmd.put(path);
+        }
+        cmd.put(Json.encode(value));
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonToggle(K key, String path) {
+        nonNull(key, "key");
+        nonNull(path, "path");
+        RedisCommand cmd = RedisCommand.of(Command.JSON_TOGGLE)
+                .put(marshaller.encode(key))
+                .put(path);
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonStrLen(K key, String path) {
+        nonNull(key, "key");
+        RedisCommand cmd = RedisCommand.of(Command.JSON_STRLEN)
+                .put(marshaller.encode(key));
+        if (path != null) {
+            cmd.put(path);
+        }
+
+        return execute(cmd);
+    }
+
+    Uni<Response> _jsonType(K key, String path) {
+        nonNull(key, "key");
+        RedisCommand cmd = RedisCommand.of(Command.JSON_TYPE)
+                .put(marshaller.encode(key));
+        if (path != null) {
+            cmd.put(path);
+        }
+
+        return execute(cmd);
+    }
+
+}
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingJsonCommandsImpl.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingJsonCommandsImpl.java
new file mode 100644
index 0000000000000..b9f9676b7745f
--- /dev/null
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingJsonCommandsImpl.java
@@ -0,0 +1,189 @@
+package io.quarkus.redis.runtime.datasource;
+
+import java.time.Duration;
+import java.util.List;
+
+import io.quarkus.redis.datasource.RedisDataSource;
+import io.quarkus.redis.datasource.json.JsonCommands;
+import io.quarkus.redis.datasource.json.JsonSetArgs;
+import io.quarkus.redis.datasource.json.ReactiveJsonCommands;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+
+public class BlockingJsonCommandsImpl<K> extends AbstractRedisCommandGroup implements JsonCommands<K> {
+
+    private final ReactiveJsonCommands<K> reactive;
+
+    public BlockingJsonCommandsImpl(RedisDataSource ds, ReactiveJsonCommands<K> reactive, Duration timeout) {
+        super(ds, timeout);
+        this.reactive = reactive;
+    }
+
+    @Override
+    public <T> void jsonSet(K key, String path, T value) {
+        reactive.jsonSet(key, path, value)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public void jsonSet(K key, String path, JsonObject json) {
+        reactive.jsonSet(key, path, json)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public void jsonSet(K key, String path, JsonObject json, JsonSetArgs args) {
+        reactive.jsonSet(key, path, json, args)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public void jsonSet(K key, String path, JsonArray json) {
+        reactive.jsonSet(key, path, json)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public void jsonSet(K key, String path, JsonArray json, JsonSetArgs args) {
+        reactive.jsonSet(key, path, json, args)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public <T> void jsonSet(K key, String path, T value, JsonSetArgs args) {
+        reactive.jsonSet(key, path, value, args)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public <T> T jsonGet(K key, Class<T> clazz) {
+        return reactive.jsonGet(key, clazz)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public JsonObject jsonGetObject(K key) {
+        return reactive.jsonGetObject(key)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public JsonArray jsonGetArray(K key) {
+        return reactive.jsonGetArray(key)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public JsonArray jsonGet(K key, String path) {
+        return reactive.jsonGet(key, path)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public JsonObject jsonGet(K key, String... paths) {
+        return reactive.jsonGet(key, paths)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public <T> List<Integer> jsonArrAppend(K key, String path, T... values) {
+        return reactive.jsonArrAppend(key, path, values)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public <T> List<Integer> jsonArrIndex(K key, String path, T value, int start, int end) {
+        return reactive.jsonArrIndex(key, path, value, start, end)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public <T> List<Integer> jsonArrIndex(K key, String path, T value) {
+        return reactive.jsonArrIndex(key, path, value)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public <T> List<Integer> jsonArrInsert(K key, String path, int index, T... values) {
+        return reactive.jsonArrInsert(key, path, index, values)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public List<Integer> jsonArrLen(K key, String path) {
+        return reactive.jsonArrLen(key, path)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public <T> List<T> jsonArrPop(K key, Class<T> clazz, String path, int index) {
+        return reactive.jsonArrPop(key, clazz, path, index)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public List<Integer> jsonArrTrim(K key, String path, int start, int stop) {
+        return reactive.jsonArrTrim(key, path, start, stop)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public int jsonClear(K key, String path) {
+        return reactive.jsonClear(key, path)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public int jsonDel(K key, String path) {
+        return reactive.jsonDel(key, path)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public List<JsonArray> jsonMget(String path, K... keys) {
+        return reactive.jsonMget(path, keys)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public void jsonNumincrby(K key, String path, double value) {
+        reactive.jsonNumincrby(key, path, value)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public List<List<String>> jsonObjKeys(K key, String path) {
+        return reactive.jsonObjKeys(key, path)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public List<Integer> jsonObjLen(K key, String path) {
+        return reactive.jsonObjLen(key, path)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public List<Integer> jsonStrAppend(K key, String path, String value) {
+        return reactive.jsonStrAppend(key, path, value)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public List<Integer> jsonStrLen(K key, String path) {
+        return reactive.jsonStrLen(key, path)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public List<Boolean> jsonToggle(K key, String path) {
+        return reactive.jsonToggle(key, path)
+                .await().atMost(timeout);
+    }
+
+    @Override
+    public List<String> jsonType(K key, String path) {
+        return reactive.jsonType(key, path)
+                .await().atMost(timeout);
+    }
+}
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingRedisDataSourceImpl.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingRedisDataSourceImpl.java
index 4a18d9e8e7cff..ad1cc652ff6ad 100644
--- a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingRedisDataSourceImpl.java
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingRedisDataSourceImpl.java
@@ -13,6 +13,7 @@
 import io.quarkus.redis.datasource.geo.GeoCommands;
 import io.quarkus.redis.datasource.hash.HashCommands;
 import io.quarkus.redis.datasource.hyperloglog.HyperLogLogCommands;
+import io.quarkus.redis.datasource.json.JsonCommands;
 import io.quarkus.redis.datasource.keys.KeyCommands;
 import io.quarkus.redis.datasource.list.ListCommands;
 import io.quarkus.redis.datasource.pubsub.PubSubCommands;
@@ -221,6 +222,11 @@ public <K> BitMapCommands<K> bitmap(Class<K> redisKeyType) {
         return new BlockingBitmapCommandsImpl<>(this, reactive.bitmap(redisKeyType), timeout);
     }
 
+    @Override
+    public <K> JsonCommands<K> json(Class<K> redisKeyType) {
+        return new BlockingJsonCommandsImpl<>(this, reactive.json(redisKeyType), timeout);
+    }
+
     @Override
     public <V> PubSubCommands<V> pubsub(Class<V> messageType) {
         return new BlockingPubSubCommandsImpl<>(this, reactive.pubsub(messageType), timeout);
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingTransactionalJsonCommandsImpl.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingTransactionalJsonCommandsImpl.java
new file mode 100644
index 0000000000000..29145fc4faa6c
--- /dev/null
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingTransactionalJsonCommandsImpl.java
@@ -0,0 +1,185 @@
+package io.quarkus.redis.runtime.datasource;
+
+import java.time.Duration;
+
+import io.quarkus.redis.datasource.json.JsonSetArgs;
+import io.quarkus.redis.datasource.json.ReactiveTransactionalJsonCommands;
+import io.quarkus.redis.datasource.json.TransactionalJsonCommands;
+import io.quarkus.redis.datasource.transactions.TransactionalRedisDataSource;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+
+public class BlockingTransactionalJsonCommandsImpl<K> extends AbstractTransactionalRedisCommandGroup
+        implements TransactionalJsonCommands<K> {
+
+    private final ReactiveTransactionalJsonCommands<K> reactive;
+
+    public BlockingTransactionalJsonCommandsImpl(TransactionalRedisDataSource ds,
+            ReactiveTransactionalJsonCommands<K> reactive,
+            Duration timeout) {
+        super(ds, timeout);
+        this.reactive = reactive;
+    }
+
+    @Override
+    public <T> void jsonSet(K key, String path, T value) {
+        this.reactive.jsonSet(key, path, value)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonSet(K key, String path, JsonObject json) {
+        this.reactive.jsonSet(key, path, json)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonSet(K key, String path, JsonObject json, JsonSetArgs args) {
+        this.reactive.jsonSet(key, path, json, args)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonSet(K key, String path, JsonArray json) {
+        this.reactive.jsonSet(key, path, json)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonSet(K key, String path, JsonArray json, JsonSetArgs args) {
+        this.reactive.jsonSet(key, path, json, args)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public <T> void jsonSet(K key, String path, T value, JsonSetArgs args) {
+        this.reactive.jsonSet(key, path, value, args)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public <T> void jsonGet(K key, Class<T> clazz) {
+        this.reactive.jsonGet(key, clazz)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonGetObject(K key) {
+        this.reactive.jsonGetObject(key)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonGetArray(K key) {
+        this.reactive.jsonGetArray(key)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonGet(K key, String path) {
+        this.reactive.jsonGet(key, path)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonGet(K key, String... paths) {
+        this.reactive.jsonGet(key, paths)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public <T> void jsonArrAppend(K key, String path, T... values) {
+        this.reactive.jsonArrAppend(key, path, values)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public <T> void jsonArrIndex(K key, String path, T value, int start, int end) {
+        this.reactive.jsonArrIndex(key, path, value, start, end)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public <T> void jsonArrInsert(K key, String path, int index, T... values) {
+        this.reactive.jsonArrInsert(key, path, index, values)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonArrLen(K key, String path) {
+        this.reactive.jsonArrLen(key, path)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public <T> void jsonArrPop(K key, Class<T> clazz, String path, int index) {
+        this.reactive.jsonArrPop(key, clazz, path, index)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonArrTrim(K key, String path, int start, int stop) {
+        this.reactive.jsonArrTrim(key, path, stop, stop)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonClear(K key, String path) {
+        this.reactive.jsonClear(key, path)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonDel(K key, String path) {
+        this.reactive.jsonDel(key, path)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonMget(String path, K... keys) {
+        this.reactive.jsonMget(path, keys)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonNumincrby(K key, String path, double value) {
+        this.reactive.jsonNumincrby(key, path, value)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonObjKeys(K key, String path) {
+        this.reactive.jsonObjKeys(key, path)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonObjLen(K key, String path) {
+        this.reactive.jsonObjLen(key, path)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonStrAppend(K key, String path, String value) {
+        this.reactive.jsonStrAppend(key, path, value)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonStrLen(K key, String path) {
+        this.reactive.jsonStrLen(key, path)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonToggle(K key, String path) {
+        this.reactive.jsonToggle(key, path)
+                .await().atMost(this.timeout);
+    }
+
+    @Override
+    public void jsonType(K key, String path) {
+        this.reactive.jsonType(key, path)
+                .await().atMost(this.timeout);
+    }
+}
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingTransactionalRedisDataSourceImpl.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingTransactionalRedisDataSourceImpl.java
index 69f5579c91eba..1e421d497de77 100644
--- a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingTransactionalRedisDataSourceImpl.java
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/BlockingTransactionalRedisDataSourceImpl.java
@@ -6,6 +6,7 @@
 import io.quarkus.redis.datasource.geo.TransactionalGeoCommands;
 import io.quarkus.redis.datasource.hash.TransactionalHashCommands;
 import io.quarkus.redis.datasource.hyperloglog.TransactionalHyperLogLogCommands;
+import io.quarkus.redis.datasource.json.TransactionalJsonCommands;
 import io.quarkus.redis.datasource.keys.TransactionalKeyCommands;
 import io.quarkus.redis.datasource.list.TransactionalListCommands;
 import io.quarkus.redis.datasource.set.TransactionalSetCommands;
@@ -89,6 +90,11 @@ public <K> TransactionalBitMapCommands<K> bitmap(Class<K> redisKeyType) {
         return new BlockingTransactionalBitMapCommandsImpl<>(this, reactive.bitmap(redisKeyType), timeout);
     }
 
+    @Override
+    public <K> TransactionalJsonCommands<K> json(Class<K> redisKeyType) {
+        return new BlockingTransactionalJsonCommandsImpl<>(this, reactive.json(redisKeyType), timeout);
+    }
+
     @Override
     public void execute(String command, String... args) {
         reactive.execute(command, args).await().atMost(timeout);
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveJsonCommandsImpl.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveJsonCommandsImpl.java
new file mode 100644
index 0000000000000..3284ddfbfb05f
--- /dev/null
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveJsonCommandsImpl.java
@@ -0,0 +1,293 @@
+package io.quarkus.redis.runtime.datasource;
+
+import static io.smallrye.mutiny.helpers.ParameterValidation.nonNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import io.quarkus.redis.datasource.ReactiveRedisDataSource;
+import io.quarkus.redis.datasource.json.JsonSetArgs;
+import io.quarkus.redis.datasource.json.ReactiveJsonCommands;
+import io.smallrye.mutiny.Uni;
+import io.vertx.core.json.Json;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+import io.vertx.mutiny.redis.client.Response;
+import io.vertx.redis.client.ResponseType;
+
+public class ReactiveJsonCommandsImpl<K> extends AbstractJsonCommands<K> implements ReactiveJsonCommands<K> {
+
+    private final ReactiveRedisDataSource reactive;
+
+    public ReactiveJsonCommandsImpl(ReactiveRedisDataSourceImpl redis, Class<K> k) {
+        super(redis, k);
+        this.reactive = redis;
+    }
+
+    @Override
+    public ReactiveRedisDataSource getDataSource() {
+        return reactive;
+    }
+
+    @Override
+    public <T> Uni<Void> jsonSet(K key, String path, T value) {
+        return _jsonSet(key, path, value)
+                .replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonSet(K key, String path, JsonObject json) {
+        return _jsonSet(key, path, json)
+                .replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonSet(K key, String path, JsonObject json, JsonSetArgs args) {
+        return _jsonSet(key, path, json, args)
+                .replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonSet(K key, String path, JsonArray json) {
+        return _jsonSet(key, path, json)
+                .replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonSet(K key, String path, JsonArray json, JsonSetArgs args) {
+        return _jsonSet(key, path, json, args)
+                .replaceWithVoid();
+    }
+
+    @Override
+    public <T> Uni<Void> jsonSet(K key, String path, T value, JsonSetArgs args) {
+        return _jsonSet(key, path, value, args)
+                .replaceWithVoid();
+    }
+
+    @Override
+    public <T> Uni<T> jsonGet(K key, Class<T> clazz) {
+        nonNull(clazz, "clazz");
+        return _jsonGet(key)
+                .map(r -> {
+                    if (r == null) {
+                        return null;
+                    }
+                    return Json.decodeValue(r.getDelegate().toBuffer(), clazz);
+                });
+    }
+
+    @Override
+    public Uni<JsonObject> jsonGetObject(K key) {
+        return _jsonGet(key)
+                .map(r -> r.toBuffer().toJsonObject());
+    }
+
+    @Override
+    public Uni<JsonArray> jsonGetArray(K key) {
+        return _jsonGet(key)
+                .map(r -> r.toBuffer().toJsonArray());
+    }
+
+    @Override
+    public Uni<JsonArray> jsonGet(K key, String path) {
+        return _jsonGet(key, path)
+                .map(r -> r.toBuffer().toJsonArray());
+    }
+
+    @Override
+    public Uni<JsonObject> jsonGet(K key, String... paths) {
+        return _jsonGet(key, paths)
+                .map(r -> {
+                    if (r == null || r.toString().equalsIgnoreCase("null")) { // JSON null
+                        return null;
+                    }
+                    return r.toBuffer().toJsonObject();
+                });
+    }
+
+    @Override
+    public <T> Uni<List<Integer>> jsonArrAppend(K key, String path, T... values) {
+        return _jsonArrAppend(key, path, values)
+                .map(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+    }
+
+    @Override
+    public <T> Uni<List<Integer>> jsonArrIndex(K key, String path, T value, int start, int end) {
+        return _jsonArrIndex(key, path, value, start, end)
+                .map(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+    }
+
+    static List<Integer> decodeAsListOfInteger(Response r) {
+        List<Integer> list = new ArrayList<>();
+        if (r.type() == ResponseType.MULTI) {
+            for (Response response : r) {
+                list.add(response == null ? null : response.toInteger());
+            }
+        } else {
+            list.add(r.toInteger());
+        }
+        return list;
+    }
+
+    @Override
+    public <T> Uni<List<Integer>> jsonArrInsert(K key, String path, int index, T... values) {
+        return _jsonArrInsert(key, path, index, values)
+                .map(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+    }
+
+    @Override
+    public Uni<List<Integer>> jsonArrLen(K key, String path) {
+        return _jsonArrLen(key, path)
+                .map(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+    }
+
+    @Override
+    public <T> Uni<List<T>> jsonArrPop(K key, Class<T> clazz, String path, int index) {
+        nonNull(clazz, "clazz");
+        return _jsonArrPop(key, path, index)
+                .map(r -> decodeArrPopResponse(clazz, r));
+    }
+
+    static <T> List<T> decodeArrPopResponse(Class<T> clazz, Response r) {
+        List<T> list = new ArrayList<>();
+        if (r == null) {
+            list.add(null);
+            return list;
+        }
+        if (r.type() == ResponseType.MULTI) {
+            for (Response response : r) {
+                list.add(response == null ? null : Json.decodeValue(response.toString(), clazz));
+            }
+        } else {
+            list.add(Json.decodeValue(r.toString(), clazz));
+        }
+        return list;
+    }
+
+    @Override
+    public Uni<List<Integer>> jsonArrTrim(K key, String path, int start, int stop) {
+        return _jsonArrTrim(key, path, start, stop)
+                .map(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+    }
+
+    @Override
+    public Uni<Integer> jsonClear(K key, String path) {
+        return _jsonClear(key, path)
+                .map(Response::toInteger);
+    }
+
+    @Override
+    public Uni<Integer> jsonDel(K key, String path) {
+        return _jsonDel(key, path)
+                .map(Response::toInteger);
+    }
+
+    @Override
+    public Uni<List<JsonArray>> jsonMget(String path, K... keys) {
+        return _jsonMget(path, keys)
+                .map(ReactiveJsonCommandsImpl::decodeMGetResponse);
+    }
+
+    static List<JsonArray> decodeMGetResponse(Response r) {
+        List<JsonArray> list = new ArrayList<>();
+        if (r.type() == ResponseType.MULTI) {
+            for (Response response : r) {
+                list.add(response == null ? null : response.toBuffer().toJsonArray());
+            }
+        } else {
+            list.add(r.toBuffer().toJsonArray());
+        }
+        return list;
+    }
+
+    @Override
+    public Uni<Void> jsonNumincrby(K key, String path, double value) {
+        return _jsonNumincrby(key, path, value)
+                .replaceWithVoid();
+    }
+
+    @Override
+    public Uni<List<List<String>>> jsonObjKeys(K key, String path) {
+        return _jsonObjKeys(key, path)
+                .map(ReactiveJsonCommandsImpl::decodeObjKeysResponse);
+    }
+
+    static List<List<String>> decodeObjKeysResponse(Response r) {
+        List<List<String>> list = new ArrayList<>();
+        if (r.type() == ResponseType.MULTI) {
+            List<String> sub = new ArrayList<>();
+            for (Response item : r) {
+                if (item == null) {
+                    list.add(null);
+                } else {
+                    if (item.type() == ResponseType.MULTI) {
+                        for (Response nested : item) {
+                            sub.add(nested == null ? null : nested.toString());
+                        }
+                    } else { // BULK
+                        sub.add(item.toString());
+                    }
+                }
+            }
+            list.add(sub);
+        } else {
+            list.add(null);
+        }
+        return list;
+    }
+
+    @Override
+    public Uni<List<Integer>> jsonObjLen(K key, String path) {
+        return _jsonObjLen(key, path)
+                .map(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+    }
+
+    @Override
+    public Uni<List<Integer>> jsonStrAppend(K key, String path, String value) {
+        return _jsonStrAppend(key, path, value)
+                .map(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+    }
+
+    @Override
+    public Uni<List<Integer>> jsonStrLen(K key, String path) {
+        return _jsonStrLen(key, path)
+                .map(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+    }
+
+    @Override
+    public Uni<List<Boolean>> jsonToggle(K key, String path) {
+        return _jsonToggle(key, path)
+                .map(ReactiveJsonCommandsImpl::decodeToggleResponse);
+    }
+
+    static List<Boolean> decodeToggleResponse(Response r) {
+        List<Boolean> list = new ArrayList<>();
+        if (r.type() == ResponseType.MULTI) {
+            for (Response response : r) {
+                list.add(response == null ? null : response.toBoolean());
+            }
+        } else {
+            list.add(r.toBoolean());
+        }
+        return list;
+    }
+
+    @Override
+    public Uni<List<String>> jsonType(K key, String path) {
+        return _jsonType(key, path)
+                .map(ReactiveJsonCommandsImpl::decodeTypeResponse);
+    }
+
+    static List<String> decodeTypeResponse(Response r) {
+        List<String> list = new ArrayList<>();
+        if (r.type() == ResponseType.MULTI) {
+            for (Response response : r) {
+                list.add(response == null ? null : response.toString());
+            }
+        } else {
+            list.add(r.toString());
+        }
+        return list;
+    }
+}
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveRedisDataSourceImpl.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveRedisDataSourceImpl.java
index ed4e1aafe7fb9..056b6729b099c 100644
--- a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveRedisDataSourceImpl.java
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveRedisDataSourceImpl.java
@@ -14,6 +14,7 @@
 import io.quarkus.redis.datasource.geo.ReactiveGeoCommands;
 import io.quarkus.redis.datasource.hash.ReactiveHashCommands;
 import io.quarkus.redis.datasource.hyperloglog.ReactiveHyperLogLogCommands;
+import io.quarkus.redis.datasource.json.ReactiveJsonCommands;
 import io.quarkus.redis.datasource.keys.ReactiveKeyCommands;
 import io.quarkus.redis.datasource.list.ReactiveListCommands;
 import io.quarkus.redis.datasource.pubsub.ReactivePubSubCommands;
@@ -277,6 +278,11 @@ public <K> ReactiveBitMapCommands<K> bitmap(Class<K> redisKeyType) {
         return new ReactiveBitMapCommandsImpl<>(this, redisKeyType);
     }
 
+    @Override
+    public <K> ReactiveJsonCommands<K> json(Class<K> redisKeyType) {
+        return new ReactiveJsonCommandsImpl<>(this, redisKeyType);
+    }
+
     @Override
     public <V> ReactivePubSubCommands<V> pubsub(Class<V> messageType) {
         return new ReactivePubSubCommandsImpl<>(this, messageType);
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveTransactionalJsonCommandsImpl.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveTransactionalJsonCommandsImpl.java
new file mode 100644
index 0000000000000..ea5ae52c3dd11
--- /dev/null
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveTransactionalJsonCommandsImpl.java
@@ -0,0 +1,213 @@
+package io.quarkus.redis.runtime.datasource;
+
+import static io.quarkus.redis.runtime.datasource.ReactiveJsonCommandsImpl.decodeArrPopResponse;
+
+import io.quarkus.redis.datasource.json.JsonSetArgs;
+import io.quarkus.redis.datasource.json.ReactiveTransactionalJsonCommands;
+import io.quarkus.redis.datasource.transactions.ReactiveTransactionalRedisDataSource;
+import io.smallrye.mutiny.Uni;
+import io.vertx.core.json.Json;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+import io.vertx.mutiny.redis.client.Response;
+
+public class ReactiveTransactionalJsonCommandsImpl<K> extends AbstractTransactionalCommands
+        implements ReactiveTransactionalJsonCommands<K> {
+
+    private final ReactiveJsonCommandsImpl<K> reactive;
+
+    public ReactiveTransactionalJsonCommandsImpl(ReactiveTransactionalRedisDataSource ds,
+            ReactiveJsonCommandsImpl<K> reactive, TransactionHolder tx) {
+        super(ds, tx);
+        this.reactive = reactive;
+    }
+
+    @Override
+    public <T> Uni<Void> jsonSet(K key, String path, T value) {
+        this.tx.enqueue(resp -> null);
+        return this.reactive._jsonSet(key, path, value).invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonSet(K key, String path, JsonObject json) {
+        this.tx.enqueue(resp -> null);
+        return this.reactive._jsonSet(key, path, json).invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonSet(K key, String path, JsonObject json, JsonSetArgs args) {
+        this.tx.enqueue(resp -> null);
+        return this.reactive._jsonSet(key, path, json, args).invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonSet(K key, String path, JsonArray json) {
+        this.tx.enqueue(resp -> null);
+        return this.reactive._jsonSet(key, path, json).invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonSet(K key, String path, JsonArray json, JsonSetArgs args) {
+        this.tx.enqueue(resp -> null);
+        return this.reactive._jsonSet(key, path, json, args).invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public <T> Uni<Void> jsonSet(K key, String path, T value, JsonSetArgs args) {
+        this.tx.enqueue(resp -> null);
+        return this.reactive._jsonSet(key, path, value, args).invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public <T> Uni<Void> jsonGet(K key, Class<T> clazz) {
+        this.tx.enqueue(r -> {
+            if (r == null) {
+                return null;
+            }
+            return Json.decodeValue(r.getDelegate().toBuffer(), clazz);
+        });
+        return this.reactive._jsonGet(key).invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonGetObject(K key) {
+        this.tx.enqueue(r -> r.toBuffer().toJsonObject());
+        return this.reactive._jsonGet(key).invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonGetArray(K key) {
+        this.tx.enqueue(r -> r.toBuffer().toJsonArray());
+        return this.reactive._jsonGet(key).invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonGet(K key, String path) {
+        this.tx.enqueue(r -> r.toBuffer().toJsonArray());
+        return this.reactive._jsonGet(key, path).invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonGet(K key, String... paths) {
+        this.tx.enqueue(r -> {
+            if (r == null || r.toString().equalsIgnoreCase("null")) { // JSON null
+                return null;
+            }
+            return r.toBuffer().toJsonObject();
+        });
+        return this.reactive._jsonGet(key, paths).invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public <T> Uni<Void> jsonArrAppend(K key, String path, T... values) {
+        this.tx.enqueue(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+        return this.reactive._jsonArrAppend(key, path, values)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public <T> Uni<Void> jsonArrIndex(K key, String path, T value, int start, int end) {
+        this.tx.enqueue(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+        return this.reactive._jsonArrIndex(key, path, value, start, end)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public <T> Uni<Void> jsonArrInsert(K key, String path, int index, T... values) {
+        this.tx.enqueue(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+        return this.reactive._jsonArrInsert(key, path, index, values)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonArrLen(K key, String path) {
+        this.tx.enqueue(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+        return this.reactive._jsonArrLen(key, path)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public <T> Uni<Void> jsonArrPop(K key, Class<T> clazz, String path, int index) {
+        this.tx.enqueue(r -> decodeArrPopResponse(clazz, r));
+        return this.reactive._jsonArrPop(key, path, index)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonArrTrim(K key, String path, int start, int stop) {
+        this.tx.enqueue(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+        return this.reactive._jsonArrTrim(key, path, start, stop)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonClear(K key, String path) {
+        this.tx.enqueue(Response::toInteger);
+        return this.reactive._jsonClear(key, path)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonDel(K key, String path) {
+        this.tx.enqueue(Response::toInteger);
+        return this.reactive._jsonDel(key, path)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonMget(String path, K... keys) {
+        this.tx.enqueue(ReactiveJsonCommandsImpl::decodeMGetResponse);
+        return this.reactive._jsonMget(path, keys)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonNumincrby(K key, String path, double value) {
+        this.tx.enqueue(r -> null);
+        return this.reactive._jsonNumincrby(key, path, value)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonObjKeys(K key, String path) {
+        this.tx.enqueue(ReactiveJsonCommandsImpl::decodeObjKeysResponse);
+        return this.reactive._jsonObjKeys(key, path)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonObjLen(K key, String path) {
+        this.tx.enqueue(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+        return this.reactive._jsonObjLen(key, path)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonStrAppend(K key, String path, String value) {
+        this.tx.enqueue(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+        return this.reactive._jsonStrAppend(key, path, value)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonStrLen(K key, String path) {
+        this.tx.enqueue(ReactiveJsonCommandsImpl::decodeAsListOfInteger);
+        return this.reactive._jsonStrLen(key, path)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonToggle(K key, String path) {
+        this.tx.enqueue(ReactiveJsonCommandsImpl::decodeToggleResponse);
+        return this.reactive._jsonToggle(key, path)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+    @Override
+    public Uni<Void> jsonType(K key, String path) {
+        this.tx.enqueue(ReactiveJsonCommandsImpl::decodeTypeResponse);
+        return this.reactive._jsonType(key, path)
+                .invoke(this::queuedOrDiscard).replaceWithVoid();
+    }
+
+}
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveTransactionalRedisDataSourceImpl.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveTransactionalRedisDataSourceImpl.java
index 4b50d6ff726b2..94ee58832e688 100644
--- a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveTransactionalRedisDataSourceImpl.java
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/ReactiveTransactionalRedisDataSourceImpl.java
@@ -9,6 +9,7 @@
 import io.quarkus.redis.datasource.geo.ReactiveTransactionalGeoCommands;
 import io.quarkus.redis.datasource.hash.ReactiveTransactionalHashCommands;
 import io.quarkus.redis.datasource.hyperloglog.ReactiveTransactionalHyperLogLogCommands;
+import io.quarkus.redis.datasource.json.ReactiveTransactionalJsonCommands;
 import io.quarkus.redis.datasource.keys.ReactiveTransactionalKeyCommands;
 import io.quarkus.redis.datasource.list.ReactiveTransactionalListCommands;
 import io.quarkus.redis.datasource.set.ReactiveTransactionalSetCommands;
@@ -97,6 +98,12 @@ public <K> ReactiveTransactionalBitMapCommands<K> bitmap(Class<K> redisKeyType)
                 (ReactiveBitMapCommandsImpl<K>) this.reactive.bitmap(redisKeyType), tx);
     }
 
+    @Override
+    public <K> ReactiveTransactionalJsonCommands<K> json(Class<K> redisKeyType) {
+        return new ReactiveTransactionalJsonCommandsImpl<>(this,
+                (ReactiveJsonCommandsImpl<K>) this.reactive.json(redisKeyType), tx);
+    }
+
     @Override
     public <K> ReactiveTransactionalKeyCommands<K> key(Class<K> redisKeyType) {
         return new ReactiveTransactionalKeyCommandsImpl<>(this,
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/RedisCommand.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/RedisCommand.java
index 51ecf01e711fa..d21b48131cceb 100644
--- a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/RedisCommand.java
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/RedisCommand.java
@@ -54,6 +54,13 @@ public RedisCommand putAll(List<?> args) {
         return this;
     }
 
+    public RedisCommand putAll(String[] args) {
+        for (Object arg : args) {
+            put(arg);
+        }
+        return this;
+    }
+
     public RedisCommand putArgs(RedisCommandExtraArguments arguments) {
         putAll(arguments.toArgs());
         return this;
@@ -81,6 +88,6 @@ public void putNullable(byte[] encoded) {
         } else {
             this.request.arg(encoded);
         }
-
     }
+
 }
diff --git a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/Validation.java b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/Validation.java
index 7c6cddd7b4290..dce0d298cafcf 100644
--- a/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/Validation.java
+++ b/extensions/redis-client/runtime/src/main/java/io/quarkus/redis/runtime/datasource/Validation.java
@@ -18,6 +18,15 @@ static <X> void notNullOrEmpty(X[] array, String name) {
         }
     }
 
+    static <X> void notNullOrBlank(String v, String name) {
+        if (v == null) {
+            throw new IllegalArgumentException("`" + name + "` must not be `null`");
+        }
+        if (v.isBlank()) {
+            throw new IllegalArgumentException("`" + name + "` must not be blank");
+        }
+    }
+
     static <X> void notNullOrEmpty(Collection<X> col, String name) {
         if (col == null) {
             throw new IllegalArgumentException("`" + name + "` must not be `null`");
diff --git a/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/DatasourceTestBase.java b/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/DatasourceTestBase.java
index 60380b44dd6d5..4d7765cc83626 100644
--- a/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/DatasourceTestBase.java
+++ b/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/DatasourceTestBase.java
@@ -1,5 +1,7 @@
 package io.quarkus.redis.datasource;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.UUID;
 
 import org.junit.jupiter.api.AfterAll;
@@ -12,6 +14,7 @@
 import io.vertx.mutiny.redis.client.Redis;
 import io.vertx.mutiny.redis.client.RedisAPI;
 import io.vertx.mutiny.redis.client.Request;
+import io.vertx.mutiny.redis.client.Response;
 
 public class DatasourceTestBase {
 
@@ -22,7 +25,7 @@ public class DatasourceTestBase {
     public static RedisAPI api;
 
     static GenericContainer<?> server = new GenericContainer<>(
-            DockerImageName.parse(System.getProperty("redis.base.image", "redis:7-alpine")))
+            DockerImageName.parse(System.getProperty("redis.base.image", "redis/redis-stack:7.0.2-RC2")))
             .withExposedPorts(6379);
 
     @BeforeAll
@@ -41,6 +44,16 @@ static void cleanup() {
         vertx.closeAndAwait();
     }
 
+    public static List<String> getAvailableCommands() {
+        List<String> commands = new ArrayList<>();
+        Response list = redis.send(Request.cmd(Command.COMMAND)).await().indefinitely();
+        for (Response response : list) {
+            commands.add(response.get(0).toString());
+        }
+        return commands;
+
+    }
+
     public static String getRedisVersion() {
         String info = redis.send(Request.cmd(Command.INFO)).await().indefinitely().toString();
         // Look for the redis_version line
diff --git a/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/JsonCommandsTest.java b/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/JsonCommandsTest.java
new file mode 100644
index 0000000000000..e1332920cd2ee
--- /dev/null
+++ b/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/JsonCommandsTest.java
@@ -0,0 +1,499 @@
+package io.quarkus.redis.datasource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.assertj.core.api.Assertions.entry;
+
+import java.time.Duration;
+import java.util.Collections;
+import java.util.List;
+import java.util.Objects;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import io.quarkus.redis.datasource.json.JsonCommands;
+import io.quarkus.redis.datasource.json.JsonSetArgs;
+import io.quarkus.redis.runtime.datasource.BlockingRedisDataSourceImpl;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+
+public class JsonCommandsTest extends DatasourceTestBase {
+
+    private RedisDataSource ds;
+
+    private JsonCommands<String> json;
+
+    @BeforeEach
+    void initialize() {
+        ds = new BlockingRedisDataSourceImpl(vertx, redis, api, Duration.ofSeconds(1));
+        json = ds.json();
+    }
+
+    @AfterEach
+    public void clear() {
+        ds.flushall();
+    }
+
+    @Test
+    void getDataSource() {
+        assertThat(ds).isEqualTo(json.getDataSource());
+    }
+
+    @Test
+    public void testJson() {
+        json.jsonSet("doc", "$",
+                new JsonObject().put("a", 2).put("b", 3).put("nested", new JsonObject().put("a", 4).put("b", null)));
+        assertThat(json.jsonGet("doc", "$..b")).containsExactly(3, null);
+        JsonObject object = json.jsonGet("doc", "..a", "$..b");
+        assertThat(object).hasSize(2);
+        assertThat(object.getJsonArray("..a")).containsExactly(2, 4);
+        assertThat(object.getJsonArray("$..b")).containsExactly(3, null);
+    }
+
+    @Test
+    public void jsonSetRoot() {
+        json.jsonSet("animal", "$", "dog");
+        assertThat(json.jsonGet("animal", "$")).containsExactly("dog");
+    }
+
+    public static class Person {
+        public String name;
+        public int age;
+
+        @Override
+        public boolean equals(Object o) {
+            if (this == o)
+                return true;
+            if (o == null || getClass() != o.getClass())
+                return false;
+            Person person = (Person) o;
+            return age == person.age && Objects.equals(name, person.name);
+        }
+
+        @Override
+        public int hashCode() {
+            return Objects.hash(name, age);
+        }
+    }
+
+    @Test
+    public void jsonSet() {
+        Person p = new Person();
+        p.name = "luke";
+        p.age = 20;
+
+        json.jsonSet("luke", "$", p);
+        assertThat(json.jsonGet("luke", Person.class)).isEqualTo(p);
+
+        Person p2 = new Person();
+        p2.name = "leia";
+        p2.age = 20;
+        json.jsonSet("luke", "$.sister", p2);
+        json.jsonSet("luke", "$.friends", new JsonArray().add("Obiwan").add("Han"), new JsonSetArgs().nx());
+        json.jsonSet("luke", "$.enemies", new JsonArray().add("Darth Sidious"), new JsonSetArgs().nx());
+        json.jsonSet("luke", "$.weapons", new JsonArray().add("Light Saber"));
+        json.jsonSet("luke", "$.father", new JsonObject().put("name", "Darth Vader").put("otherName", "Anakin"));
+        json.jsonSet("luke", "$.sister.father", new JsonObject().put("name", "Darth Vader").put("otherName", "Anakin"));
+
+        JsonObject luke = json.jsonGetObject("luke");
+        assertThat(luke.getString("name")).isEqualTo("luke");
+        assertThat(luke.getInteger("age")).isEqualTo(20);
+        assertThat(luke.getJsonArray("enemies")).containsExactly("Darth Sidious");
+        assertThat(luke.getJsonArray("weapons")).containsExactly("Light Saber");
+        assertThat(luke.getJsonObject("sister").getInteger("age")).isEqualTo(20);
+        assertThat(luke.getJsonObject("sister").getString("name")).isEqualTo("leia");
+        assertThat(luke.getJsonObject("sister").getJsonObject("father").getString("name")).isEqualTo("Darth Vader");
+        assertThat(luke.getJsonArray("friends")).containsExactly("Obiwan", "Han");
+        assertThat(luke.getJsonObject("father").getString("name")).isEqualTo("Darth Vader");
+
+        json.jsonSet("luke", "$", p, new JsonSetArgs().nx());
+
+        luke = json.jsonGetObject("luke");
+        assertThat(luke.getString("name")).isEqualTo("luke");
+        assertThat(luke.getInteger("age")).isEqualTo(20);
+        assertThat(luke.getJsonObject("sister").getInteger("age")).isEqualTo(20);
+        assertThat(luke.getJsonObject("sister").getString("name")).isEqualTo("leia");
+        assertThat(luke.getJsonObject("sister").getJsonObject("father").getString("name")).isEqualTo("Darth Vader");
+        assertThat(luke.getJsonArray("friends")).containsExactly("Obiwan", "Han");
+        assertThat(luke.getJsonObject("father").getString("name")).isEqualTo("Darth Vader");
+
+        json.jsonSet("luke", "$", p, new JsonSetArgs().xx());
+
+        luke = json.jsonGetObject("luke");
+        assertThat(luke.getString("name")).isEqualTo("luke");
+        assertThat(luke.getInteger("age")).isEqualTo(20);
+        assertThat(luke.getJsonObject("sister")).isNull();
+    }
+
+    @Test
+    public void jsonGetArray() {
+        json.jsonSet("array", "$", List.of("a", "b", "c"));
+        assertThat(json.jsonGetArray("array")).containsExactly("a", "b", "c");
+    }
+
+    @Test
+    public void jsonSetNull() {
+        json.jsonSet("null", "$", (Object) null);
+        assertThatThrownBy(() -> json.jsonSet("null-json", "$", (JsonArray) null))
+                .isInstanceOf(IllegalArgumentException.class);
+        assertThatThrownBy(() -> json.jsonSet("null-json", "$", (JsonObject) null))
+                .isInstanceOf(IllegalArgumentException.class);
+
+        assertThat(json.jsonGet("null")).isNull();
+        assertThat(json.jsonGet("null", String.class)).isNull();
+
+        assertThat(json.jsonGet("missing", String.class)).isNull();
+        assertThat(json.jsonGet("missing")).isNull();
+    }
+
+    @Test
+    public void testJsonGet() {
+        Person p = new Person();
+        p.name = "luke";
+        p.age = 20;
+
+        json.jsonSet("luke", "$", p);
+        assertThat(json.jsonGet("luke", Person.class)).isEqualTo(p);
+
+        Person p2 = new Person();
+        p2.name = "leia";
+        p2.age = 20;
+        json.jsonSet("luke", "$.sister", p2);
+        json.jsonSet("luke", "$.friends", new JsonArray().add("Obiwan").add("Han"), new JsonSetArgs().nx());
+        json.jsonSet("luke", "$.enemies", new JsonArray().add("Darth Sidious"), new JsonSetArgs().nx());
+        json.jsonSet("luke", "$.weapons", new JsonArray().add("Light Saber"));
+        json.jsonSet("luke", "$.father", new JsonObject().put("name", "Darth Vader").put("otherName", "Anakin"));
+        json.jsonSet("luke", "$.sister.father", new JsonObject().put("name", "Darth Vader").put("otherName", "Anakin"));
+
+        assertThat(json.jsonGet("luke", "$")).hasSize(1);
+        assertThat(json.jsonGet("luke", "$.missing")).hasSize(0);
+        assertThat(json.jsonGet("luke").getString("name")).isEqualTo("luke");
+        assertThat(json.jsonGet("luke", "$.friends[0]").getString(0)).isEqualTo("Obiwan");
+        assertThat(json.jsonGet("luke", "$.friends[2]")).hasSize(0);
+        JsonObject query = json.jsonGet("luke", "$.friends", "..father");
+        assertThat(query).hasSize(2);
+        assertThat(query.getJsonArray("$.friends").getJsonArray(0)).containsExactly("Obiwan", "Han");
+        assertThat(query.getJsonArray("..father").getJsonObject(0).getString("name")).isEqualTo("Darth Vader");
+        assertThat(query.getJsonArray("..father").getJsonObject(1).getString("name")).isEqualTo("Darth Vader");
+
+        query = json.jsonGet("luke", "$.friends", ".missing", "..father");
+        assertThat(query).hasSize(3);
+        assertThat(query.getJsonArray(".missing")).isEmpty();
+    }
+
+    @Test
+    void jsonArrAppend() {
+        JsonObject test = JsonObject.of("a", 10, "arr", JsonArray.of(1, 2));
+        JsonArray arr = JsonArray.of("a", "b", "c");
+        json.jsonSet(key, "$", test);
+        json.jsonSet("arr", "$", arr);
+        json.jsonSet("obj", "$", JsonObject.of("name", "clement"));
+
+        List<Integer> list = json.jsonArrAppend(key, "arr", new io.quarkus.redis.datasource.Person("luke", "skywalker"));
+        assertThat(list).containsExactly(3); // 1, 2, luke...
+        list = json.jsonArrAppend("arr", "$", new io.quarkus.redis.datasource.Person("luke", "skywalker"));
+        assertThat(list).containsExactly(4); // a, b, c, luke...
+        assertThatThrownBy(() -> json.jsonArrAppend("obj", ".name", "a", "b"))
+                .hasMessageContaining(".name");
+
+        assertThatThrownBy(() -> json.jsonArrAppend("missing", ".name", "a", "b"))
+                .hasMessageContaining("key");
+    }
+
+    @Test
+    void jsonArrIndex() {
+        JsonObject test = JsonObject.of("a", JsonArray.of(1, 2, 3, 2),
+                "nested", JsonObject.of("a", JsonArray.of(3, 4)));
+        json.jsonSet(key, "$", test);
+        assertThat(json.jsonArrIndex(key, "$..a", 2)).containsExactly(1, -1);
+        assertThat(json.jsonArrIndex(key, "$..a", 2, 0, 10)).containsExactly(1, -1);
+
+        assertThatThrownBy(() -> json.jsonArrIndex(key, ".name", 2))
+                .hasMessageContaining(".name");
+
+        assertThatThrownBy(() -> json.jsonArrIndex("missing", ".name", "a"))
+                .hasMessageContaining(".name");
+
+        test = JsonObject.of("a", JsonArray.of(1, 2, 3, 2),
+                "nested", JsonObject.of("a", false));
+        json.jsonSet(key, "$", test);
+        assertThat(json.jsonArrIndex(key, "$..a", 2)).containsExactly(1, null);
+    }
+
+    @Test
+    void jsonArrInsert() {
+        JsonObject test = JsonObject.of("a", JsonArray.of(3),
+                "nested", JsonObject.of("a", JsonArray.of(3, 4)));
+        json.jsonSet(key, "$", test);
+        assertThat(json.jsonArrInsert(key, "$..a", 0, 1, 2)).containsExactly(3, 4);
+        JsonObject object = json.jsonGetObject(key);
+        assertThat(object.getJsonArray("a")).containsExactly(1, 2, 3);
+        assertThat(object.getJsonObject("nested").getJsonArray("a")).containsExactly(1, 2, 3, 4);
+    }
+
+    @Test
+    void jsonArrInsertWithNull() {
+        JsonObject test = JsonObject.of("a", JsonArray.of(1, 2, 3, 2),
+                "nested", JsonObject.of("a", 1));
+        json.jsonSet(key, "$", test);
+        assertThat(json.jsonArrInsert(key, "$..a", 0, 1, 2)).containsExactly(6, null);
+    }
+
+    @Test
+    void jsonArrayLen() {
+        JsonObject test = JsonObject.of("a", JsonArray.of(3),
+                "nested", JsonObject.of("a", JsonArray.of(3, 4)));
+        json.jsonSet(key, "$", test);
+        json.jsonSet("doc", "$", JsonArray.of("a", "b", "c"));
+        json.jsonSet("doc2", "$", JsonObject.of("a", "b"));
+
+        assertThat(json.jsonArrLen(key, "$..a")).containsExactly(1, 2);
+        assertThat(json.jsonArrLen("doc")).hasValue(3);
+        assertThatThrownBy(() -> json.jsonArrLen("doc2"))
+                .hasMessageContaining("Path");
+    }
+
+    @Test
+    void jsonArrayLenWithNull() {
+        JsonObject test = JsonObject.of("a", JsonArray.of(1, 2, 3, 2),
+                "nested", JsonObject.of("a", 2));
+        json.jsonSet(key, "$", test);
+        assertThat(json.jsonArrLen(key, "$..a")).containsExactly(4, null);
+    }
+
+    @Test
+    void jsonArrayPop() {
+        JsonObject test = JsonObject.of("a", JsonArray.of(3),
+                "nested", JsonObject.of("a", JsonArray.of(3, 4)));
+        json.jsonSet(key, "$", test);
+
+        assertThat(json.jsonArrPop(key, Integer.class, "$..a", -1)).containsExactly(3, 4);
+        assertThat(json.jsonGetObject(key).getJsonArray("a")).isEmpty();
+        assertThat(json.jsonGetObject(key).getJsonObject("nested").getJsonArray("a")).containsExactly(3);
+    }
+
+    @Test
+    void jsonArrayPopWithNull() {
+        JsonObject test = JsonObject.of("a", JsonArray.of("foo", "bar"),
+                "nested", JsonObject.of("a", 2), "nested2", JsonObject.of("a", new JsonArray()));
+        json.jsonSet(key, "$", test);
+        assertThat(json.jsonArrPop(key, String.class, "$..a")).containsExactly("bar", null, null);
+    }
+
+    @Test
+    void jsonArrayPopWithDefault() {
+        JsonObject test = JsonObject.of("a", JsonArray.of(3),
+                "nested", JsonObject.of("a", JsonArray.of(3, 4)));
+        json.jsonSet(key, "$", test);
+
+        assertThat(json.jsonArrPop(key, Integer.class, "$..a")).containsExactly(3, 4);
+        assertThat(json.jsonGetObject(key).getJsonArray("a")).isEmpty();
+        assertThat(json.jsonGetObject(key).getJsonObject("nested").getJsonArray("a")).containsExactly(3);
+
+        json.jsonSet("arr", "$", JsonArray.of(1, 2, 3, 4));
+        assertThat(json.jsonArrPop("arr", Integer.class)).isEqualTo(4);
+
+        json.jsonSet("empty", "$", JsonArray.of());
+        assertThat(json.jsonArrPop("empty", Integer.class)).isNull();
+    }
+
+    @Test
+    void jsonArrayTrim() {
+        JsonObject test = JsonObject.of("a", JsonArray.of(),
+                "nested", JsonObject.of("a", JsonArray.of(1, 4)));
+        json.jsonSet(key, "$", test);
+
+        assertThat(json.jsonArrTrim(key, "$..a", 1, 1)).containsExactly(0, 1);
+        assertThat(json.jsonGetObject(key).getJsonArray("a")).isEmpty();
+        assertThat(json.jsonGetObject(key).getJsonObject("nested").getJsonArray("a")).containsExactly(4);
+    }
+
+    @Test
+    void jsonArrayTrimWithNull() {
+        JsonObject test = JsonObject.of("a", JsonArray.of(1, 2, 3, 2),
+                "nested", JsonObject.of("a", 1));
+        json.jsonSet(key, "$", test);
+
+        assertThat(json.jsonArrTrim(key, "$..a", 1, 1)).containsExactly(1, null);
+        assertThat(json.jsonGetObject(key).getJsonArray("a")).containsExactly(2);
+        assertThat(json.jsonGetObject(key).getJsonObject("nested").getInteger("a")).isEqualTo(1);
+    }
+
+    @Test
+    void jsonClearAll() {
+        JsonObject test = JsonObject.of("obj", JsonObject.of("a", 1, "b", 2),
+                "arr", JsonArray.of(1, 2, 3), "str", "foo", "bool", true,
+                "int", 42, "float", 3.14);
+        json.jsonSet(key, "$", test);
+
+        json.jsonClear(key);
+        JsonObject object = json.jsonGet(key);
+        assertThat(object).isEmpty();
+    }
+
+    @Test
+    void jsonClear() {
+        JsonObject test = JsonObject.of("obj", JsonObject.of("a", 1, "b", 2),
+                "arr", JsonArray.of(1, 2, 3), "str", "foo", "bool", true,
+                "int", 42, "float", 3.14);
+        json.jsonSet(key, "$", test);
+
+        json.jsonClear(key, "$.*");
+        JsonObject object = json.jsonGet(key);
+        assertThat(object.getJsonObject("obj")).isEmpty();
+        assertThat(object.getJsonArray("arr")).isEmpty();
+        assertThat(object.getString("str")).isEqualTo("foo");
+        assertThat(object.getBoolean("bool")).isTrue();
+        assertThat(object.getInteger("int")).isEqualTo(0);
+        assertThat(object.getDouble("float")).isEqualTo(0.0);
+    }
+
+    @Test
+    void jsonDel() {
+        JsonObject test = JsonObject.of("a", 1, "nested", JsonObject.of("a", 2, "b", 3));
+        json.jsonSet(key, "$", test);
+
+        json.jsonDel(key, "$..a");
+        JsonObject object = json.jsonGet(key);
+        assertThat(object.getString("a")).isNull();
+        assertThat(object.getJsonObject("nested")).containsExactly(entry("b", 3));
+    }
+
+    @Test
+    void jsonDelAll() {
+        JsonObject test = JsonObject.of("a", 1, "nested", JsonObject.of("a", 2, "b", 3));
+        json.jsonSet(key, "$", test);
+
+        json.jsonDel(key);
+        JsonObject object = json.jsonGet(key);
+        assertThat(object).isNull();
+    }
+
+    @Test
+    void mget() {
+        // redis> JSON.SET doc1 $ '{"a":1, "b": 2, "nested": {"a": 3}, "c": null}'
+        //OK
+        //redis> JSON.SET doc2 $ '{"a":4, "b": 5, "nested": {"a": 6}, "c": null}'
+        //OK
+        //redis> JSON.MGET doc1 doc2 $..a
+        //1) "[1,3]"
+        //2) "[4,6]"
+
+        JsonObject j1 = JsonObject.of("a", 1, "b", 2, "nested", JsonObject.of("a", 3), "c", null);
+        JsonObject j2 = JsonObject.of("a", 4, "b", 5, "nested", JsonObject.of("a", 6), "c", null);
+
+        json.jsonSet("doc1", j1);
+        json.jsonSet("doc2", j2);
+
+        List<JsonArray> arrays = json.jsonMget("doc1", "doc2", "$..a");
+        assertThat(arrays.get(0)).containsExactly(1, 3);
+        assertThat(arrays.get(1)).containsExactly(4, 6);
+
+        arrays = json.jsonMget("doc1", "doc2", "$..d");
+        assertThat(arrays).hasSize(2).allSatisfy(a -> assertThat(a).isEmpty());
+
+        arrays = json.jsonMget("doc1", "$..a");
+        assertThat(arrays.get(0)).containsExactly(1, 3);
+    }
+
+    @Test
+    void numIncrBy() {
+        JsonObject test = JsonObject.of("a", "b", "b",
+                JsonArray.of(JsonObject.of("a", 2), JsonObject.of("a", 5), JsonObject.of("a", "c")));
+        JsonObject res = JsonObject.of("a", "b", "b",
+                JsonArray.of(JsonObject.of("a", 4), JsonObject.of("a", 7), JsonObject.of("a", "c")));
+        json.jsonSet(key, test);
+        json.jsonNumincrby(key, "$.a", 2);
+        assertThat(json.jsonGet(key)).isEqualTo(test);
+        json.jsonNumincrby(key, "$..a", 2);
+        assertThat(json.jsonGet(key)).isEqualTo(res);
+    }
+
+    @Test
+    void objKeys() {
+        JsonObject test = JsonObject.of("a", JsonArray.of(3), "nested", JsonObject.of("a", JsonObject.of("b", 2, "c", 1)));
+        json.jsonSet(key, test);
+        assertThat(json.jsonObjKeys(key, "$..a")).containsExactly(null, List.of("b", "c"));
+
+        assertThat(json.jsonObjKeys(key)).containsExactly("a", "nested");
+        assertThat(json.jsonObjKeys(key, "$..missing")).containsExactly(Collections.emptyList());
+    }
+
+    @Test
+    void objLen() {
+        JsonObject test = JsonObject.of("a", JsonArray.of(3), "nested", JsonObject.of("a", JsonObject.of("b", 2, "c", 1)));
+        json.jsonSet(key, test);
+        json.jsonSet("empty", new JsonObject());
+        json.jsonSet("arr", new JsonArray());
+        assertThat(json.jsonObjLen(key, "$..a")).containsExactly(null, 2);
+        assertThat(json.jsonObjLen(key)).hasValue(2);
+        assertThat(json.jsonObjLen("empty")).hasValue(0);
+        assertThatThrownBy(() -> json.jsonObjLen("arr")).hasMessageContaining("array");
+        assertThat(json.jsonObjLen(key, "$..missing")).isEmpty();
+    }
+
+    @Test
+    void strAppend() {
+        JsonObject test = JsonObject.of("a", "foo", "nested", JsonObject.of("a", "hello"), "nested2", JsonObject.of("a", 31));
+        json.jsonSet(key, test);
+        json.jsonSet("empty", new JsonObject());
+        json.jsonSet("str", "hello");
+        assertThat(json.jsonStrAppend(key, "$..a", "baz buzz")).containsExactly(11, 13, null);
+        JsonObject object = json.jsonGet(key);
+        assertThat(object.getString("a")).isEqualTo("foobaz buzz");
+        assertThat(object.getJsonObject("nested").getString("a")).isEqualTo("hellobaz buzz");
+
+        assertThat(json.jsonStrAppend("str", null, "-hello")).containsExactly(11);
+        assertThatThrownBy(() -> json.jsonStrAppend("empty", null, "goo")).hasMessageContaining("string");
+        assertThat(json.jsonStrAppend(key, "$..missing", "gaa")).isEmpty();
+    }
+
+    @Test
+    void strLen() {
+        JsonObject test = JsonObject.of("a", "foo", "nested", JsonObject.of("a", "hello"), "nested2", JsonObject.of("a", 31));
+        json.jsonSet(key, test);
+        json.jsonSet("empty", new JsonObject());
+        json.jsonSet("str", "hello");
+        assertThat(json.jsonStrLen(key, "$..a")).containsExactly(3, 5, null);
+
+        assertThat(json.jsonStrLen("str", null)).containsExactly(5);
+        assertThatThrownBy(() -> json.jsonStrLen("empty", null)).hasMessageContaining("string");
+        assertThat(json.jsonStrLen(key, "$..missing")).isEmpty();
+    }
+
+    @Test
+    void toggle() {
+        JsonObject test = JsonObject.of("a", true, "nested", JsonObject.of("a", false), "nested2", JsonObject.of("a", "true"));
+        json.jsonSet(key, test);
+        json.jsonSet("empty", new JsonObject());
+        json.jsonSet("bool", false);
+        assertThat(json.jsonToggle(key, "$..a")).containsExactly(false, true, null);
+        JsonObject object = json.jsonGet(key);
+        assertThat(object.getBoolean("a")).isFalse();
+        assertThat(object.getJsonObject("nested").getBoolean("a")).isTrue();
+        assertThat(object.getJsonObject("nested2").getString("a")).isEqualTo("true");
+
+        assertThat(json.jsonToggle("bool", "$")).containsExactly(true);
+        assertThat(json.jsonToggle("empty", "$")).hasSize(1).allSatisfy(b -> assertThat(b).isNull());
+        assertThat(json.jsonToggle(key, "$..missing")).isEmpty();
+    }
+
+    @Test
+    void type() {
+        JsonObject test = JsonObject.of("a", 2, "nested", JsonObject.of("a", true), "foo", "bar", "arr", JsonArray.of(1, 2, 3),
+                "next", JsonObject.of("a", 23.5));
+        json.jsonSet(key, test);
+        json.jsonSet("empty", new JsonObject());
+        assertThat(json.jsonType(key, "$..foo")).containsExactly("string");
+        assertThat(json.jsonType(key, "$..a")).containsExactly("integer", "boolean", "number");
+        assertThat(json.jsonType(key, "$..missing")).isEmpty();
+        assertThat(json.jsonType(key, "$.arr")).containsExactly("array");
+        assertThat(json.jsonType(key, "$.arr[0]")).containsExactly("integer");
+        assertThat(json.jsonType("empty", "$")).containsExactly("object");
+        assertThat(json.jsonType("empty", "$.a")).isEmpty();
+
+    }
+
+}
diff --git a/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/Person.java b/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/Person.java
index c944730c8ebb8..4db35e13e7125 100644
--- a/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/Person.java
+++ b/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/Person.java
@@ -21,7 +21,7 @@ public Person(String firstname, String lastname) {
     }
 
     public Person() {
-        // USed by the mapper.
+        // Used by the mapper.
     }
 
     @Override
diff --git a/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/RedisCommandCondition.java b/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/RedisCommandCondition.java
new file mode 100644
index 0000000000000..4bbb799ccf909
--- /dev/null
+++ b/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/RedisCommandCondition.java
@@ -0,0 +1,37 @@
+package io.quarkus.redis.datasource;
+
+import static org.junit.jupiter.api.extension.ConditionEvaluationResult.disabled;
+import static org.junit.jupiter.api.extension.ConditionEvaluationResult.enabled;
+
+import java.util.List;
+import java.util.Optional;
+
+import org.junit.jupiter.api.extension.ConditionEvaluationResult;
+import org.junit.jupiter.api.extension.ExecutionCondition;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.platform.commons.util.AnnotationUtils;
+
+class RedisCommandCondition implements ExecutionCondition {
+
+    private static final ConditionEvaluationResult ENABLED_BY_DEFAULT = enabled("@RequiresCommand is not present");
+
+    @Override
+    public ConditionEvaluationResult evaluateExecutionCondition(ExtensionContext context) {
+        Optional<RequiresCommand> optional = AnnotationUtils.findAnnotation(context.getElement(),
+                RequiresCommand.class);
+
+        if (optional.isPresent()) {
+            String[] cmd = optional.get().value();
+            List<String> commands = DatasourceTestBase.getAvailableCommands();
+
+            for (String c : cmd) {
+                if (!commands.contains(c.toLowerCase())) {
+                    return disabled("Disabled, Redis command " + c + " not available.");
+                }
+            }
+            return enabled("Redis commands " + String.join(", ", cmd) + " are available");
+        }
+
+        return ENABLED_BY_DEFAULT;
+    }
+}
diff --git a/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/RequiresCommand.java b/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/RequiresCommand.java
new file mode 100644
index 0000000000000..1ba03eb39eb26
--- /dev/null
+++ b/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/RequiresCommand.java
@@ -0,0 +1,14 @@
+package io.quarkus.redis.datasource;
+
+import java.lang.annotation.*;
+
+import org.junit.jupiter.api.extension.ExtendWith;
+
+@Target(ElementType.METHOD)
+@Retention(RetentionPolicy.RUNTIME)
+@Inherited
+@ExtendWith(RedisCommandCondition.class)
+@interface RequiresCommand {
+
+    String[] value();
+}
diff --git a/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/TransactionalJsonCommandsTest.java b/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/TransactionalJsonCommandsTest.java
new file mode 100644
index 0000000000000..9944b1764c83e
--- /dev/null
+++ b/extensions/redis-client/runtime/src/test/java/io/quarkus/redis/datasource/TransactionalJsonCommandsTest.java
@@ -0,0 +1,125 @@
+
+package io.quarkus.redis.datasource;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.time.Duration;
+import java.util.List;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import io.quarkus.redis.datasource.json.ReactiveTransactionalJsonCommands;
+import io.quarkus.redis.datasource.json.TransactionalJsonCommands;
+import io.quarkus.redis.datasource.transactions.TransactionResult;
+import io.quarkus.redis.runtime.datasource.BlockingRedisDataSourceImpl;
+import io.quarkus.redis.runtime.datasource.ReactiveRedisDataSourceImpl;
+import io.vertx.core.json.Json;
+import io.vertx.core.json.JsonArray;
+import io.vertx.core.json.JsonObject;
+
+public class TransactionalJsonCommandsTest extends DatasourceTestBase {
+
+    private RedisDataSource blocking;
+    private ReactiveRedisDataSource reactive;
+
+    Person person = new Person("luke", "skywalker");
+    Person person2 = new Person("leia", "skywalker");
+
+    @BeforeEach
+    void initialize() {
+        blocking = new BlockingRedisDataSourceImpl(vertx, redis, api, Duration.ofSeconds(60));
+        reactive = new ReactiveRedisDataSourceImpl(vertx, redis, api);
+    }
+
+    @AfterEach
+    public void clear() {
+        blocking.flushall();
+    }
+
+    @SuppressWarnings("unchecked")
+    @Test
+    public void setBlocking() {
+
+        TransactionResult result = blocking.withTransaction(tx -> {
+            TransactionalJsonCommands<String> json = tx.json();
+            assertThat(json.getDataSource()).isEqualTo(tx);
+            json.jsonSet(key, "$", person); // 0
+            json.jsonSet(key, "$.sister", person2); // 1
+            json.jsonSet(key, "$.a", JsonArray.of(1, 2, 3)); // 2
+
+            json.jsonArrPop(key, Integer.class, "$.a", -1); // 3 -> [3]
+            json.jsonArrLen(key, "$.a"); // 4 -> [2]
+            json.jsonClear(key, "$.a"); // 5 -> 1
+
+            json.jsonStrLen(key, "$.sister.lastname"); // 6 -> [9]
+            json.jsonStrAppend(key, "$.sister.lastname", "!"); // 7 -> 10
+            json.jsonStrLen(key, "$.sister.lastname"); // 8 -> 10
+
+            json.jsonGet(key); // 9 {...}
+
+            json.jsonSet("sister", "$", new JsonObject(Json.encode(person2)));
+            json.jsonGet("sister", Person.class);
+        });
+        assertThat(result.size()).isEqualTo(12);
+        assertThat(result.discarded()).isFalse();
+
+        assertThat((Void) result.get(0)).isNull();
+        assertThat((Void) result.get(1)).isNull();
+        assertThat((Void) result.get(2)).isNull();
+        assertThat((List<Integer>) result.get(3)).containsExactly(3);
+        assertThat((List<Integer>) result.get(4)).containsExactly(2);
+        assertThat((int) result.get(5)).isEqualTo(1);
+        assertThat((List<Integer>) result.get(6)).containsExactly(person2.lastname.length());
+        assertThat((List<Integer>) result.get(7)).containsExactly(person2.lastname.length() + 1);
+        assertThat((List<Integer>) result.get(8)).containsExactly(person2.lastname.length() + 1);
+        JsonObject actual = result.get(9);
+        assertThat(actual.getString("firstname")).isEqualTo(person.firstname);
+        assertThat(actual.getString("lastname")).isEqualTo(person.lastname);
+        assertThat(actual.getJsonObject("sister").getString("lastname")).isEqualTo(person2.lastname + "!");
+        assertThat(actual.getJsonArray("a")).isEmpty();// cleared
+        assertThat((Void) result.get(10)).isNull();
+        assertThat((Person) result.get(11)).isEqualTo(person2);
+    }
+
+    @Test
+    public void setReactive() {
+        TransactionResult result = reactive.withTransaction(tx -> {
+            ReactiveTransactionalJsonCommands<String> json = tx.json();
+            assertThat(json.getDataSource()).isEqualTo(tx);
+            return json.jsonSet(key, "$", person) // 0
+                    .chain(() -> json.jsonSet(key, "$.sister", person2)) // 1
+                    .chain(() -> json.jsonSet(key, "$.a", JsonArray.of(1, 2, 3))) // 2
+                    .chain(() -> json.jsonArrPop(key, Integer.class, "$.a", -1)) // 3 -> [3]
+                    .chain(() -> json.jsonArrLen(key, "$.a")) // 4 -> [2]
+                    .chain(() -> json.jsonClear(key, "$.a")) // 5 -> 1
+                    .chain(() -> json.jsonStrLen(key, "$.sister.lastname")) // 6 -> [9]
+                    .chain(() -> json.jsonStrAppend(key, "$.sister.lastname", "!")) // 7 -> 10
+                    .chain(() -> json.jsonStrLen(key, "$.sister.lastname")) // 8 -> 10
+                    .chain(() -> json.jsonGet(key)) // 9 {...}
+                    .chain(() -> json.jsonSet("sister", "$", new JsonObject(Json.encode(person2))))
+                    .chain(() -> json.jsonGet("sister", Person.class));
+        }).await().atMost(Duration.ofSeconds(5));
+        assertThat(result.size()).isEqualTo(12);
+        assertThat(result.discarded()).isFalse();
+
+        assertThat((Void) result.get(0)).isNull();
+        assertThat((Void) result.get(1)).isNull();
+        assertThat((Void) result.get(2)).isNull();
+        assertThat((List<Integer>) result.get(3)).containsExactly(3);
+        assertThat((List<Integer>) result.get(4)).containsExactly(2);
+        assertThat((int) result.get(5)).isEqualTo(1);
+        assertThat((List<Integer>) result.get(6)).containsExactly(person2.lastname.length());
+        assertThat((List<Integer>) result.get(7)).containsExactly(person2.lastname.length() + 1);
+        assertThat((List<Integer>) result.get(8)).containsExactly(person2.lastname.length() + 1);
+        JsonObject actual = result.get(9);
+        assertThat(actual.getString("firstname")).isEqualTo(person.firstname);
+        assertThat(actual.getString("lastname")).isEqualTo(person.lastname);
+        assertThat(actual.getJsonObject("sister").getString("lastname")).isEqualTo(person2.lastname + "!");
+        assertThat(actual.getJsonArray("a")).isEmpty();// cleared
+        assertThat((Void) result.get(10)).isNull();
+        assertThat((Person) result.get(11)).isEqualTo(person2);
+    }
+
+}