diff --git a/src/rpc/blockchain.cpp b/src/rpc/blockchain.cpp
--- a/src/rpc/blockchain.cpp
+++ b/src/rpc/blockchain.cpp
@@ -19,6 +19,7 @@
 #include <policy/policy.h>
 #include <primitives/transaction.h>
 #include <rpc/server.h>
+#include <rpc/util.h>
 #include <script/descriptor.h>
 #include <streams.h>
 #include <sync.h>
diff --git a/src/rpc/mining.cpp b/src/rpc/mining.cpp
--- a/src/rpc/mining.cpp
+++ b/src/rpc/mining.cpp
@@ -20,6 +20,7 @@
 #include <rpc/blockchain.h>
 #include <rpc/mining.h>
 #include <rpc/server.h>
+#include <rpc/util.h>
 #include <shutdown.h>
 #include <txmempool.h>
 #include <util/strencodings.h>
diff --git a/src/rpc/net.cpp b/src/rpc/net.cpp
--- a/src/rpc/net.cpp
+++ b/src/rpc/net.cpp
@@ -14,6 +14,7 @@
 #include <netbase.h>
 #include <policy/policy.h>
 #include <rpc/protocol.h>
+#include <rpc/util.h>
 #include <sync.h>
 #include <timedata.h>
 #include <ui_interface.h>
diff --git a/src/rpc/rawtransaction.cpp b/src/rpc/rawtransaction.cpp
--- a/src/rpc/rawtransaction.cpp
+++ b/src/rpc/rawtransaction.cpp
@@ -245,7 +245,17 @@
     if (request.fHelp ||
         (request.params.size() != 1 && request.params.size() != 2)) {
         throw std::runtime_error(
-            "gettxoutproof [\"txid\",...] ( blockhash )\n"
+            RPCHelpMan{"gettxoutproof",
+                       {
+                           {"txids",
+                            RPCArg::Type::ARR,
+                            {
+                                {"txid", RPCArg::Type::STR_HEX, false},
+                            },
+                            false},
+                           {"blockhash", RPCArg::Type::STR_HEX, true},
+                       }}
+                .ToString() +
             "\nReturns a hex-encoded proof that \"txid\" was included in a "
             "block.\n"
             "\nNOTE: By default this function only works sometimes. This is "
@@ -742,7 +752,16 @@
                                       const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
-            "combinerawtransaction [\"hexstring\",...]\n"
+            RPCHelpMan{"combinerawtransaction",
+                       {
+                           {"txs",
+                            RPCArg::Type::ARR,
+                            {
+                                {"hexstring", RPCArg::Type::STR_HEX, false},
+                            },
+                            false},
+                       }}
+                .ToString() +
             "\nCombine multiple partially signed transactions into one "
             "transaction.\n"
             "The combined transaction may be another partially signed "
@@ -1014,9 +1033,34 @@
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 4) {
         throw std::runtime_error(
-            "signrawtransactionwithkey \"hexstring\" [\"privatekey1\",...] ( "
-            "[{\"txid\":\"id\",\"vout\":n,\"scriptPubKey\":\"hex\","
-            "\"redeemScript\":\"hex\"},...] sighashtype )\n"
+            RPCHelpMan{
+                "signrawtransactionwithkey",
+                {
+                    {"hexstring", RPCArg::Type::STR, false},
+                    {"privkyes",
+                     RPCArg::Type::ARR,
+                     {
+                         {"privatekey", RPCArg::Type::STR_HEX, false},
+                     },
+                     false},
+                    {"prevtxs",
+                     RPCArg::Type::ARR,
+                     {
+                         {"",
+                          RPCArg::Type::OBJ,
+                          {
+                              {"txid", RPCArg::Type::STR_HEX, false},
+                              {"vout", RPCArg::Type::NUM, false},
+                              {"scriptPubKey", RPCArg::Type::STR_HEX, false},
+                              {"redeemScript", RPCArg::Type::STR_HEX, false},
+                              {"amount", RPCArg::Type::AMOUNT, false},
+                          },
+                          true},
+                     },
+                     true},
+                    {"sighashtype", RPCArg::Type::STR, true},
+                }}
+                .ToString() +
             "\nSign inputs for raw transaction (serialized, hex-encoded).\n"
             "The second argument is an array of base58-encoded private\n"
             "keys that will be the only keys used to sign the transaction.\n"
@@ -1611,7 +1655,16 @@
                             const JSONRPCRequest &request) {
     if (request.fHelp || request.params.size() != 1) {
         throw std::runtime_error(
-            "combinepsbt [\"psbt\",...]\n"
+            RPCHelpMan{"combinepsbt",
+                       {
+                           {"txs",
+                            RPCArg::Type::ARR,
+                            {
+                                {"psbt", RPCArg::Type::STR_HEX, false},
+                            },
+                            false},
+                       }}
+                .ToString() +
             "\nCombine multiple partially signed Bitcoin transactions into one "
             "transaction.\n"
             "Implements the Combiner role.\n"
@@ -1748,8 +1801,41 @@
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 3) {
         throw std::runtime_error(
-            "createpsbt [{\"txid\":\"id\",\"vout\":n},...] "
-            "[{\"address\":amount},{\"data\":\"hex\"},...] ( locktime )\n"
+            RPCHelpMan{"createpsbt",
+                       {
+                           {"inputs",
+                            RPCArg::Type::ARR,
+                            {
+                                {"",
+                                 RPCArg::Type::OBJ,
+                                 {
+                                     {"txid", RPCArg::Type::STR_HEX, false},
+                                     {"vout", RPCArg::Type::NUM, false},
+                                     {"sequence", RPCArg::Type::NUM, true},
+                                 },
+                                 false},
+                            },
+                            false},
+                           {"outputs",
+                            RPCArg::Type::ARR,
+                            {
+                                {"",
+                                 RPCArg::Type::OBJ,
+                                 {
+                                     {"address", RPCArg::Type::AMOUNT, false},
+                                 },
+                                 true},
+                                {"",
+                                 RPCArg::Type::OBJ,
+                                 {
+                                     {"data", RPCArg::Type::STR_HEX, false},
+                                 },
+                                 true},
+                            },
+                            false},
+                           {"locktime", RPCArg::Type::NUM, true},
+                       }}
+                .ToString() +
             "\nCreates a transaction in the Partially Signed Transaction "
             "format.\n"
             "Implements the Creator role.\n"
diff --git a/src/rpc/server.cpp b/src/rpc/server.cpp
--- a/src/rpc/server.cpp
+++ b/src/rpc/server.cpp
@@ -10,6 +10,7 @@
 #include <fs.h>
 #include <key_io.h>
 #include <random.h>
+#include <rpc/util.h>
 #include <shutdown.h>
 #include <sync.h>
 #include <ui_interface.h>
diff --git a/src/rpc/util.h b/src/rpc/util.h
--- a/src/rpc/util.h
+++ b/src/rpc/util.h
@@ -30,4 +30,57 @@
 
 UniValue DescribeAddress(const CTxDestination &dest);
 
+struct RPCArg {
+    enum class Type {
+        OBJ,
+        ARR,
+        STR,
+        NUM,
+        BOOL,
+        //! Special type where the user must set the keys e.g. to define
+        //! multiple addresses; as opposed to e.g. an options object where the
+        //! keys are predefined
+        OBJ_USER_KEYS,
+        //! Special type representing a floating point amount (can be either NUM
+        //! or STR)
+        AMOUNT,
+        //! Special type that is a STR with only hex chars
+        STR_HEX,
+    };
+    //! The name of the arg (can be empty for inner args)
+    const std::string m_name;
+    const Type m_type;
+    //! Only used for arrays or dicts
+    const std::vector<RPCArg> m_inner;
+    const bool m_optional;
+
+    RPCArg(const std::string &name, const Type &type, const bool optional)
+        : m_name{name}, m_type{type}, m_optional{optional} {
+        assert(type != Type::ARR && type != Type::OBJ);
+    }
+
+    RPCArg(const std::string &name, const Type &type,
+           const std::vector<RPCArg> &inner, const bool optional)
+        : m_name{name}, m_type{type}, m_inner{inner}, m_optional{optional} {
+        assert(type == Type::ARR || type == Type::OBJ);
+    }
+
+    std::string ToString() const;
+
+private:
+    std::string ToStringObj() const;
+};
+
+class RPCHelpMan {
+public:
+    RPCHelpMan(const std::string &name, const std::vector<RPCArg> &args)
+        : m_name{name}, m_args{args} {}
+
+    std::string ToString() const;
+
+private:
+    const std::string m_name;
+    const std::vector<RPCArg> m_args;
+};
+
 #endif // BITCOIN_RPC_UTIL_H
diff --git a/src/rpc/util.cpp b/src/rpc/util.cpp
--- a/src/rpc/util.cpp
+++ b/src/rpc/util.cpp
@@ -114,3 +114,100 @@
 UniValue DescribeAddress(const CTxDestination &dest) {
     return boost::apply_visitor(DescribeAddressVisitor(), dest);
 }
+
+std::string RPCHelpMan::ToString() const {
+    std::string ret;
+
+    ret += m_name;
+    bool is_optional{false};
+    for (const auto &arg : m_args) {
+        ret += " ";
+        if (arg.m_optional) {
+            if (!is_optional) {
+                ret += "( ";
+            }
+            is_optional = true;
+        } else {
+            // Currently we still support unnamed arguments, so any argument
+            // following an optional argument must also be optional If support
+            // for positional arguments is deprecated in the future, remove this
+            // line
+            assert(!is_optional);
+        }
+        ret += arg.ToString();
+    }
+    if (is_optional) {
+        ret += " )";
+    }
+    ret += "\n";
+
+    return ret;
+}
+
+std::string RPCArg::ToStringObj() const {
+    std::string res = "\"" + m_name + "\":";
+    switch (m_type) {
+        case Type::STR:
+            return res + "\"str\"";
+        case Type::STR_HEX:
+            return res + "\"hex\"";
+        case Type::NUM:
+            return res + "n";
+        case Type::AMOUNT:
+            return res + "amount";
+        case Type::BOOL:
+            return res + "bool";
+        case Type::ARR:
+            res += "[";
+            for (const auto &i : m_inner) {
+                res += i.ToString() + ",";
+            }
+            return res + "...]";
+        case Type::OBJ:
+        case Type::OBJ_USER_KEYS:
+            // Currently unused, so avoid writing dead code
+            assert(false);
+
+            // no default case, so the compiler can warn about missing cases
+    }
+    assert(false);
+}
+
+std::string RPCArg::ToString() const {
+    switch (m_type) {
+        case Type::STR_HEX:
+        case Type::STR: {
+            return "\"" + m_name + "\"";
+        }
+        case Type::NUM:
+        case Type::AMOUNT:
+        case Type::BOOL: {
+            return m_name;
+        }
+        case Type::OBJ:
+        case Type::OBJ_USER_KEYS: {
+            std::string res;
+            for (size_t i = 0; i < m_inner.size();) {
+                res += m_inner[i].ToStringObj();
+                if (++i < m_inner.size()) {
+                    res += ",";
+                }
+            }
+            if (m_type == Type::OBJ) {
+                return "{" + res + "}";
+            } else {
+                return "{" + res + ",...}";
+            }
+        }
+        case Type::ARR: {
+            std::string res;
+            for (const auto &i : m_inner) {
+                res += i.ToString() + ",";
+            }
+            return "[" + res + "...]";
+        }
+
+            // no default case, so the compiler can warn about missing cases
+    }
+    assert(false);
+}
diff --git a/src/wallet/rpcdump.cpp b/src/wallet/rpcdump.cpp
--- a/src/wallet/rpcdump.cpp
+++ b/src/wallet/rpcdump.cpp
@@ -9,6 +9,7 @@
 #include <key_io.h>
 #include <merkleblock.h>
 #include <rpc/server.h>
+#include <rpc/util.h>
 #include <script/script.h>
 #include <script/standard.h>
 #include <sync.h>
diff --git a/src/wallet/rpcwallet.cpp b/src/wallet/rpcwallet.cpp
--- a/src/wallet/rpcwallet.cpp
+++ b/src/wallet/rpcwallet.cpp
@@ -3387,7 +3387,23 @@
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 2) {
         throw std::runtime_error(
-            "lockunspent unlock ([{\"txid\":\"txid\",\"vout\":n},...])\n"
+            RPCHelpMan{"lockunspent",
+                       {
+                           {"unlock", RPCArg::Type::BOOL, false},
+                           {"transactions",
+                            RPCArg::Type::ARR,
+                            {
+                                {"",
+                                 RPCArg::Type::OBJ,
+                                 {
+                                     {"txid", RPCArg::Type::STR_HEX, false},
+                                     {"vout", RPCArg::Type::NUM, false},
+                                 },
+                                 true},
+                            },
+                            true},
+                       }}
+                .ToString() +
             "\nUpdates list of temporarily unspendable outputs.\n"
             "Temporarily lock (unlock=false) or unlock (unlock=true) specified "
             "transaction outputs.\n"
@@ -4020,8 +4036,29 @@
 
     if (request.fHelp || request.params.size() > 5) {
         throw std::runtime_error(
-            "listunspent ( minconf maxconf  [\"addresses\",...] "
-            "[include_unsafe] [query_options])\n"
+            RPCHelpMan{
+                "listunspent",
+                {
+                    {"minconf", RPCArg::Type::NUM, true},
+                    {"maxconf", RPCArg::Type::NUM, true},
+                    {"addresses",
+                     RPCArg::Type::ARR,
+                     {
+                         {"address", RPCArg::Type::STR_HEX, true},
+                     },
+                     true},
+                    {"include_unsafe", RPCArg::Type::BOOL, true},
+                    {"query_options",
+                     RPCArg::Type::OBJ,
+                     {
+                         {"minimumAmount", RPCArg::Type::AMOUNT, true},
+                         {"maximumAmount", RPCArg::Type::AMOUNT, true},
+                         {"maximumCount", RPCArg::Type::NUM, true},
+                         {"minimumSumAmount", RPCArg::Type::AMOUNT, true},
+                     },
+                     true},
+                }}
+                .ToString() +
             "\nReturns array of unspent transaction outputs\n"
             "with between minconf and maxconf (inclusive) confirmations.\n"
             "Optionally filter to only include txouts paid to specified "
@@ -4472,9 +4509,28 @@
     if (request.fHelp || request.params.size() < 1 ||
         request.params.size() > 3) {
         throw std::runtime_error(
-            "signrawtransactionwithwallet \"hexstring\" ( "
-            "[{\"txid\":\"id\",\"vout\":n,\"scriptPubKey\":\"hex\","
-            "\"redeemScript\":\"hex\"},...] sighashtype )\n"
+            RPCHelpMan{
+                "signrawtransactionwithwallet",
+                {
+                    {"hexstring", RPCArg::Type::STR, false},
+                    {"prevtxs",
+                     RPCArg::Type::ARR,
+                     {
+                         {"",
+                          RPCArg::Type::OBJ,
+                          {
+                              {"txid", RPCArg::Type::STR_HEX, false},
+                              {"vout", RPCArg::Type::NUM, false},
+                              {"scriptPubKey", RPCArg::Type::STR_HEX, false},
+                              {"redeemScript", RPCArg::Type::STR_HEX, false},
+                              {"amount", RPCArg::Type::AMOUNT, false},
+                          },
+                          false},
+                     },
+                     true},
+                    {"sighashtype", RPCArg::Type::STR, true},
+                }}
+                .ToString() +
             "\nSign inputs for raw transaction (serialized, hex-encoded).\n"
             "The second optional argument (may be null) is an array of "
             "previous transaction outputs that\n"
@@ -5329,9 +5385,58 @@
     if (request.fHelp || request.params.size() < 2 ||
         request.params.size() > 5) {
         throw std::runtime_error(
-            "walletcreatefundedpsbt [{\"txid\":\"id\",\"vout\":n},...] "
-            "[{\"address\":amount},{\"data\":\"hex\"},...] ( locktime ) ( "
-            "options bip32derivs )\n"
+            RPCHelpMan{"walletcreatefundedpsbt",
+                       {
+                           {"inputs",
+                            RPCArg::Type::ARR,
+                            {
+                                {"",
+                                 RPCArg::Type::OBJ,
+                                 {
+                                     {"txid", RPCArg::Type::STR_HEX, false},
+                                     {"vout", RPCArg::Type::NUM, false},
+                                     {"sequence", RPCArg::Type::NUM, false},
+                                 },
+                                 false},
+                            },
+                            false},
+                           {"outputs",
+                            RPCArg::Type::ARR,
+                            {
+                                {"",
+                                 RPCArg::Type::OBJ,
+                                 {
+                                     {"address", RPCArg::Type::AMOUNT, true},
+                                 },
+                                 true},
+                                {"",
+                                 RPCArg::Type::OBJ,
+                                 {
+                                     {"data", RPCArg::Type::STR_HEX, true},
+                                 },
+                                 true},
+                            },
+                            false},
+                           {"locktime", RPCArg::Type::NUM, true},
+                           {"options",
+                            RPCArg::Type::OBJ,
+                            {
+                                {"changeAddress", RPCArg::Type::STR_HEX, true},
+                                {"changePosition", RPCArg::Type::NUM, true},
+                                {"includeWatching", RPCArg::Type::BOOL, true},
+                                {"lockUnspents", RPCArg::Type::BOOL, true},
+                                {"feeRate", RPCArg::Type::NUM, true},
+                                {"subtractFeeFromOutputs",
+                                 RPCArg::Type::ARR,
+                                 {
+                                     {"int", RPCArg::Type::NUM, true},
+                                 },
+                                 true},
+                            },
+                            true},
+                           {"bip32derivs", RPCArg::Type::BOOL, true},
+                       }}
+                .ToString() +
             "\nCreates and funds a transaction in the Partially Signed "
             "Transaction format. Inputs will be added if supplied inputs are "
             "not enough\n"
diff --git a/src/zmq/zmqrpc.cpp b/src/zmq/zmqrpc.cpp
--- a/src/zmq/zmqrpc.cpp
+++ b/src/zmq/zmqrpc.cpp
@@ -5,6 +5,7 @@
 #include <zmq/zmqrpc.h>
 
 #include <rpc/server.h>
+#include <rpc/util.h>
 #include <zmq/zmqabstractnotifier.h>
 #include <zmq/zmqnotificationinterface.h>