diff --git a/Kucoin.Net.UnitTests/JsonTests.cs b/Kucoin.Net.UnitTests/JsonTests.cs
index 915b1d78..ba8bf3d1 100644
--- a/Kucoin.Net.UnitTests/JsonTests.cs
+++ b/Kucoin.Net.UnitTests/JsonTests.cs
@@ -14,9 +14,8 @@ public class JsonTests
         private JsonToObjectComparer<IKucoinRestClient> _comparerSpot = new JsonToObjectComparer<IKucoinRestClient>((json) => TestHelpers.CreateResponseClient(json, x =>
         {
             x.ApiCredentials = new KucoinApiCredentials("1234", "1234", "12");
-            x.SpotOptions.RateLimiters = new List<IRateLimiter>();
             x.SpotOptions.OutputOriginalData = false;
-            x.FuturesOptions.RateLimiters = new List<IRateLimiter>();
+            x.RateLimiterEnabled = false;
             x.FuturesOptions.OutputOriginalData = false;
         }));
 
diff --git a/Kucoin.Net.UnitTests/TestImplementations/TestSocket.cs b/Kucoin.Net.UnitTests/TestImplementations/TestSocket.cs
index c8f8e01e..205e441c 100644
--- a/Kucoin.Net.UnitTests/TestImplementations/TestSocket.cs
+++ b/Kucoin.Net.UnitTests/TestImplementations/TestSocket.cs
@@ -18,6 +18,7 @@ public class TestSocket: IWebsocket
 #pragma warning disable 0067
         public event Func<Task> OnReconnected;
         public event Func<Task> OnReconnecting;
+        public event Func<int, Task> OnRequestRateLimited;
 #pragma warning restore 0067
         public event Func<int, Task> OnRequestSent;
         public event Action<WebSocketMessageType, ReadOnlyMemory<byte>> OnStreamMessage;
@@ -50,10 +51,10 @@ public class TestSocket: IWebsocket
         public TimeSpan KeepAliveInterval { get; set; }
         public Func<Task<Uri>> GetReconnectionUrl { get => throw new NotImplementedException(); set => throw new NotImplementedException(); }
 
-        public Task<bool> ConnectAsync()
+        public Task<CallResult> ConnectAsync()
         {
             Connected = CanConnect;
-            return Task.FromResult(CanConnect);
+            return Task.FromResult(CanConnect ? new CallResult(null) : new CallResult(new CantConnectError()));
         }
 
         public void Send(int requestId, string data, int weight)
diff --git a/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApi.cs b/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApi.cs
index f9fcf8d4..fd78c421 100644
--- a/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApi.cs
+++ b/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApi.cs
@@ -68,7 +68,7 @@ protected override AuthenticationProvider CreateAuthenticationProvider(ApiCreden
 
         internal async Task<WebCallResult> Execute(Uri uri, HttpMethod method, CancellationToken ct, Dictionary<string, object>? parameters = null, bool signed = false, HttpMethodParameterPosition? parameterPosition = null)
         {
-            var result = await SendRequestAsync<KucoinResult<object>>(uri, method, ct, parameters, signed, parameterPosition: parameterPosition).ConfigureAwait(false);
+            var result = await SendRequestAsync<KucoinResult<object>>(uri, method, ct, parameters, signed, parameterPosition: parameterPosition, requestWeight: 0).ConfigureAwait(false);
             if (!result)
                 return result.AsDatalessError(result.Error!);
 
@@ -78,9 +78,9 @@ internal async Task<WebCallResult> Execute(Uri uri, HttpMethod method, Cancellat
             return result.AsDataless();
         }
 
-        internal async Task<WebCallResult<T>> Execute<T>(Uri uri, HttpMethod method, CancellationToken ct, Dictionary<string, object>? parameters = null, bool signed = false, int weight = 1, bool ignoreRatelimit = false, HttpMethodParameterPosition? parameterPosition = null)
+        internal async Task<WebCallResult<T>> Execute<T>(Uri uri, HttpMethod method, CancellationToken ct, Dictionary<string, object>? parameters = null, bool signed = false, HttpMethodParameterPosition? parameterPosition = null)
         {
-            var result = await SendRequestAsync<KucoinResult<T>>(uri, method, ct, parameters, signed, parameterPosition: parameterPosition, requestWeight: weight, ignoreRatelimit: ignoreRatelimit).ConfigureAwait(false);
+            var result = await SendRequestAsync<KucoinResult<T>>(uri, method, ct, parameters, signed, parameterPosition: parameterPosition, requestWeight: 0).ConfigureAwait(false);
             if (!result)
                 return result.AsError<T>(result.Error!);
 
diff --git a/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApiAccount.cs b/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApiAccount.cs
index 70938384..0c79488d 100644
--- a/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApiAccount.cs
+++ b/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApiAccount.cs
@@ -31,7 +31,7 @@ internal KucoinRestClientFuturesApiAccount(KucoinRestClientFuturesApi baseClient
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinAccountOverview>> GetAccountOverviewAsync(string? asset = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             return await _baseClient.Execute<KucoinAccountOverview>(_baseClient.GetUri("account-overview"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
         }
@@ -39,7 +39,7 @@ public async Task<WebCallResult<KucoinAccountOverview>> GetAccountOverviewAsync(
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginatedSlider<KucoinAccountTransaction>>> GetTransactionHistoryAsync(string? asset = null, TransactionType? type = null, DateTime? startTime = null, DateTime? endTime = null, int? offset = null, int? pageSize = null, bool? forward = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("startAt", DateTimeConverter.ConvertToMilliseconds(startTime));
             parameters.AddOptionalParameter("endAt", DateTimeConverter.ConvertToMilliseconds(endTime));
@@ -58,7 +58,7 @@ public async Task<WebCallResult<KucoinTransferResult>> TransferToMainAccountAsyn
             if (receiveAccountType != AccountType.Main && receiveAccountType != AccountType.Trade)
                 throw new ArgumentException("Receiving account type should be Main or Trade");
 
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("currency", asset);
             parameters.AddParameter("amount", quantity.ToString(CultureInfo.InvariantCulture));
             parameters.AddParameter("recAccountType", EnumConverter.GetString(receiveAccountType));
@@ -71,7 +71,7 @@ public async Task<WebCallResult> TransferToFuturesAccountAsync(string asset, dec
             if (payAccountType != AccountType.Main && payAccountType != AccountType.Trade)
                 throw new ArgumentException("Receiving account type should be Main or Trade");
 
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("currency", asset);
             parameters.AddParameter("amount", quantity.ToString(CultureInfo.InvariantCulture));
             parameters.AddParameter("payAccountType", EnumConverter.GetString(payAccountType));
@@ -81,7 +81,7 @@ public async Task<WebCallResult> TransferToFuturesAccountAsync(string asset, dec
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginated<KucoinTransfer>>> GetTransferToMainAccountHistoryAsync(string? asset = null, DateTime? startTime = null, DateTime? endTime = null, DepositStatus? status = null, int? currentPage = null, int? pageSize = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("startAt", DateTimeConverter.ConvertToMilliseconds(startTime));
             parameters.AddOptionalParameter("endAt", DateTimeConverter.ConvertToMilliseconds(endTime));
@@ -94,7 +94,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinTransfer>>> GetTransferToM
         /// <inheritdoc />
         public async Task<WebCallResult> CancelTransferToMainAccountAsync(string applyId, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("applyId", applyId);
             return await _baseClient.Execute(_baseClient.GetUri("cancel/transfer-out", 1), HttpMethod.Delete, ct, parameters, true).ConfigureAwait(false);
         }
@@ -105,7 +105,7 @@ public async Task<WebCallResult> CancelTransferToMainAccountAsync(string applyId
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPosition>> GetPositionAsync(string symbol, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("symbol", symbol);
             return await _baseClient.Execute<KucoinPosition>(_baseClient.GetUri("position"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
         }
@@ -113,7 +113,7 @@ public async Task<WebCallResult<KucoinPosition>> GetPositionAsync(string symbol,
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinPosition>>> GetPositionsAsync(string? asset = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             return await _baseClient.Execute<IEnumerable<KucoinPosition>>(_baseClient.GetUri("positions"), HttpMethod.Get, ct, parameters, signed: true).ConfigureAwait(false);
         }
@@ -121,7 +121,7 @@ public async Task<WebCallResult<IEnumerable<KucoinPosition>>> GetPositionsAsync(
         /// <inheritdoc />
         public async Task<WebCallResult> ToggleAutoDepositMarginAsync(string symbol, bool enabled, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("symbol", symbol);
             parameters.AddParameter("status", enabled.ToString());
             return await _baseClient.Execute(_baseClient.GetUri("position/margin/auto-deposit-status"), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false);
@@ -130,7 +130,7 @@ public async Task<WebCallResult> ToggleAutoDepositMarginAsync(string symbol, boo
         /// <inheritdoc />
         public async Task<WebCallResult> AddMarginAsync(string symbol, decimal quantity, string? clientId = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("symbol", symbol);
             parameters.AddParameter("bizNo", clientId ?? Convert.ToBase64String(Guid.NewGuid().ToByteArray()));
             parameters.AddParameter("margin", quantity.ToString(CultureInfo.InvariantCulture));
@@ -144,7 +144,7 @@ public async Task<WebCallResult> AddMarginAsync(string symbol, decimal quantity,
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginatedSlider<KucoinFundingItem>>> GetFundingHistoryAsync(string symbol, DateTime? startTime = null, DateTime? endTime = null, int? offset = null, int? pageSize = null, bool? forward = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("startAt", DateTimeConverter.ConvertToMilliseconds(startTime));
             parameters.AddOptionalParameter("endAt", DateTimeConverter.ConvertToMilliseconds(endTime));
@@ -160,7 +160,7 @@ public async Task<WebCallResult<KucoinPaginatedSlider<KucoinFundingItem>>> GetFu
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinOrderValuation>> GetOpenOrderValueAsync(string symbol, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("symbol", symbol);
             return await _baseClient.Execute<KucoinOrderValuation>(_baseClient.GetUri("openOrderStatistics"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
         }
@@ -171,7 +171,7 @@ public async Task<WebCallResult<KucoinOrderValuation>> GetOpenOrderValueAsync(st
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<Objects.Models.Futures.KucoinRiskLimit>>> GetRiskLimitLevelAsync(string symbol, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("symbol", symbol);
             return await _baseClient.Execute<IEnumerable<Objects.Models.Futures.KucoinRiskLimit>>(_baseClient.GetUri("contracts/risk-limit/" + symbol), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
         }
@@ -182,7 +182,7 @@ public async Task<WebCallResult<KucoinOrderValuation>> GetOpenOrderValueAsync(st
         /// <inheritdoc />
         public async Task<WebCallResult<bool>> SetRiskLimitLevelAsync(string symbol, int level, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("symbol", symbol);
             parameters.AddParameter("level", level);
             return await _baseClient.Execute<bool>(_baseClient.GetUri("position/risk-limit-level/change"), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false);
diff --git a/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApiExchangeData.cs b/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApiExchangeData.cs
index d1a4480e..310529b8 100644
--- a/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApiExchangeData.cs
+++ b/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApiExchangeData.cs
@@ -47,7 +47,7 @@ public async Task<WebCallResult<KucoinContract>> GetContractAsync(string symbol,
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinFuturesTick>> GetTickerAsync(string symbol, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("symbol", symbol);
             return await _baseClient.Execute<KucoinFuturesTick>(_baseClient.GetUri("ticker"), HttpMethod.Get, ct, parameters).ConfigureAwait(false);
         }
@@ -59,7 +59,7 @@ public async Task<WebCallResult<KucoinFuturesTick>> GetTickerAsync(string symbol
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinOrderBook>> GetAggregatedFullOrderBookAsync(string symbol, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("symbol", symbol);
             return await _baseClient.Execute<KucoinOrderBook>(_baseClient.GetUri("level2/snapshot"), HttpMethod.Get, ct, parameters).ConfigureAwait(false);
         }
@@ -69,7 +69,7 @@ public async Task<WebCallResult<KucoinOrderBook>> GetAggregatedPartialOrderBookA
         {
             depth.ValidateIntValues(nameof(depth), 20, 100);
 
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("symbol", symbol);
             return await _baseClient.Execute<KucoinOrderBook>(_baseClient.GetUri("level2/depth" + depth), HttpMethod.Get, ct, parameters).ConfigureAwait(false);
         }
@@ -81,7 +81,7 @@ public async Task<WebCallResult<KucoinOrderBook>> GetAggregatedPartialOrderBookA
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinFuturesTrade>>> GetTradeHistoryAsync(string symbol, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("symbol", symbol);
             return await _baseClient.Execute<IEnumerable<KucoinFuturesTrade>>(_baseClient.GetUri("trade/history"), HttpMethod.Get, ct, parameters).ConfigureAwait(false);
         }
@@ -93,7 +93,7 @@ public async Task<WebCallResult<IEnumerable<KucoinFuturesTrade>>> GetTradeHistor
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginatedSlider<KucoinFuturesInterest>>> GetInterestRatesAsync(string symbol, DateTime? startTime = null, DateTime? endTime = null, int? offset = null, int? pageSize = null, bool? forward = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("startAt", DateTimeConverter.ConvertToMilliseconds(startTime));
             parameters.AddOptionalParameter("endAt", DateTimeConverter.ConvertToMilliseconds(endTime));
@@ -106,7 +106,7 @@ public async Task<WebCallResult<KucoinPaginatedSlider<KucoinFuturesInterest>>> G
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginatedSlider<KucoinIndex>>> GetIndexListAsync(string symbol, DateTime? startTime = null, DateTime? endTime = null, int? offset = null, int? pageSize = null, bool? forward = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("startAt", DateTimeConverter.ConvertToMilliseconds(startTime));
             parameters.AddOptionalParameter("endAt", DateTimeConverter.ConvertToMilliseconds(endTime));
@@ -125,7 +125,7 @@ public async Task<WebCallResult<KucoinMarkPrice>> GetCurrentMarkPriceAsync(strin
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginatedSlider<KucoinPremiumIndex>>> GetPremiumIndexAsync(string symbol, DateTime? startTime = null, DateTime? endTime = null, int? offset = null, int? pageSize = null, bool? forward = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("startAt", DateTimeConverter.ConvertToMilliseconds(startTime));
             parameters.AddOptionalParameter("endAt", DateTimeConverter.ConvertToMilliseconds(endTime));
@@ -148,7 +148,7 @@ public async Task<WebCallResult<KucoinFundingRate>> GetCurrentFundingRateAsync(s
         /// <inheritdoc />
         public async Task<WebCallResult<DateTime>> GetServerTimeAsync(CancellationToken ct = default)
         {
-            var result = await _baseClient.Execute<long>(_baseClient.GetUri("timestamp"), HttpMethod.Get, ct, ignoreRatelimit: true).ConfigureAwait(false);
+            var result = await _baseClient.Execute<long>(_baseClient.GetUri("timestamp"), HttpMethod.Get, ct).ConfigureAwait(false);
             return result.As(result ? new DateTime(1970, 1, 1).AddMilliseconds(result.Data) : default);
         }
 
@@ -169,7 +169,7 @@ public async Task<WebCallResult<KucoinFuturesServiceStatus>> GetServiceStatusAsy
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinFuturesKline>>> GetKlinesAsync(string symbol, FuturesKlineInterval interval, DateTime? startTime = null, DateTime? endTime = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("symbol", symbol);
             parameters.AddParameter("granularity", JsonConvert.SerializeObject(interval, new FuturesKlineIntervalConverter(false)));
             parameters.AddOptionalParameter("from", DateTimeConverter.ConvertToMilliseconds(startTime));
diff --git a/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApiTrading.cs b/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApiTrading.cs
index 1644c108..e1733597 100644
--- a/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApiTrading.cs
+++ b/Kucoin.Net/Clients/FuturesApi/KucoinRestClientFuturesApiTrading.cs
@@ -54,7 +54,7 @@ public async Task<WebCallResult<KucoinNewOrder>> PlaceOrderAsync(
             string? clientOrderId = null,
             CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddParameter("symbol", symbol);
             parameters.AddParameter("side", JsonConvert.SerializeObject(side, new OrderSideConverter(false)));
             parameters.AddParameter("type", JsonConvert.SerializeObject(type, new NewOrderTypeConverter(false)));
@@ -87,7 +87,7 @@ public async Task<WebCallResult<KucoinCanceledOrders>> CancelOrderAsync(string o
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinCanceledOrders>> CancelAllOrdersAsync(string? symbol = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             return await _baseClient.Execute<KucoinCanceledOrders>(_baseClient.GetUri("orders", 1), HttpMethod.Delete, ct, parameters, true).ConfigureAwait(false);
         }
@@ -96,7 +96,7 @@ public async Task<WebCallResult<KucoinCanceledOrders>> CancelAllOrdersAsync(stri
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinCanceledOrders>> CancelAllStopOrdersAsync(string? symbol = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             return await _baseClient.Execute<KucoinCanceledOrders>(_baseClient.GetUri("stopOrders", 1), HttpMethod.Delete, ct, parameters, true).ConfigureAwait(false);
         }
@@ -104,7 +104,7 @@ public async Task<WebCallResult<KucoinCanceledOrders>> CancelAllStopOrdersAsync(
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginated<KucoinFuturesOrder>>> GetOrdersAsync(string? symbol = null, OrderStatus? status = null, OrderSide? side = null, OrderType? type = null, DateTime? startTime = null, DateTime? endTime = null, int? currentPage = null, int? pageSize = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("status", status == null ? null : JsonConvert.SerializeObject(status, new OrderStatusConverter(false)));
             parameters.AddOptionalParameter("side", side == null ? null : JsonConvert.SerializeObject(side, new OrderSideConverter(false)));
@@ -120,7 +120,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinFuturesOrder>>> GetOrdersA
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginated<KucoinFuturesOrder>>> GetUntriggeredStopOrdersAsync(string? symbol = null, OrderSide? side = null, OrderType? type = null, DateTime? startTime = null, DateTime? endTime = null, int? currentPage = null, int? pageSize = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("side", side == null ? null : JsonConvert.SerializeObject(side, new OrderSideConverter(false)));
             parameters.AddOptionalParameter("type", type == null ? null : JsonConvert.SerializeObject(type, new OrderTypeConverter(false)));
@@ -134,7 +134,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinFuturesOrder>>> GetUntrigg
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinFuturesOrder>>> GetClosedOrdersAsync(string? symbol = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             return await _baseClient.Execute<IEnumerable<KucoinFuturesOrder>>(_baseClient.GetUri("recentDoneOrders"), HttpMethod.Get, ct, parameters, signed: true).ConfigureAwait(false);
         }
@@ -148,7 +148,7 @@ public async Task<WebCallResult<KucoinFuturesOrder>> GetOrderAsync(string orderI
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinFuturesOrder>> GetOrderByClientOrderIdAsync(string clientOrderId, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("clientOid", clientOrderId);
             return await _baseClient.Execute<KucoinFuturesOrder>(_baseClient.GetUri("orders/byClientOid"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
         }
@@ -159,7 +159,7 @@ public async Task<WebCallResult<KucoinFuturesOrder>> GetOrderByClientOrderIdAsyn
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginated<KucoinFuturesUserTrade>>> GetUserTradesAsync(string? orderId = null, string? symbol = null, OrderSide? side = null, OrderType? type = null, DateTime? startTime = null, DateTime? endTime = null, int? currentPage = null, int? pageSize = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("orderId", orderId);
             parameters.AddOptionalParameter("side", side == null ? null : JsonConvert.SerializeObject(side, new OrderSideConverter(false)));
diff --git a/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApi.cs b/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApi.cs
index 4e3a78a4..7f9f35d1 100644
--- a/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApi.cs
+++ b/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApi.cs
@@ -344,9 +344,33 @@ internal void InvokeOrderCanceled(OrderId id)
             OnOrderCanceled?.Invoke(id);
         }
 
+        internal async Task<WebCallResult> SendAsync(RequestDefinition definition, ParameterCollection? parameters, CancellationToken cancellationToken, int? weight = null)
+        {
+            var result = await base.SendAsync<KucoinResult>(BaseAddress, definition, parameters, cancellationToken, null, weight).ConfigureAwait(false);
+            if (!result)
+                return result.AsDatalessError(result.Error!);
+
+            if (result.Data.Code != 200000)
+                return result.AsDatalessError(new ServerError(result.Data.Code, result.Data.Message ?? "-"));
+
+            return result.AsDataless();
+        }
+
+        internal async Task<WebCallResult<T>> SendAsync<T>(RequestDefinition definition, ParameterCollection? parameters, CancellationToken cancellationToken, int? weight = null)
+        {
+            var result = await base.SendAsync<KucoinResult<T>>(BaseAddress, definition, parameters, cancellationToken, null, weight).ConfigureAwait(false);
+            if (!result)
+                return result.AsError<T>(result.Error!);
+
+            if (result.Data.Code != 200000)
+                return result.AsError<T>(new ServerError(result.Data.Code, result.Data.Message ?? "-"));
+
+            return result.As(result.Data.Data);
+        }
+
         internal async Task<WebCallResult> Execute(Uri uri, HttpMethod method, CancellationToken ct, Dictionary<string, object>? parameters = null, bool signed = false, HttpMethodParameterPosition? parameterPosition = null)
         {
-            var result = await SendRequestAsync<KucoinResult<object>>(uri, method, ct, parameters, signed, parameterPosition: parameterPosition).ConfigureAwait(false);
+            var result = await SendRequestAsync<KucoinResult<object>>(uri, method, ct, parameters, signed, parameterPosition: parameterPosition, requestWeight: 0).ConfigureAwait(false);
             if (!result)
                 return result.AsDatalessError(result.Error!);
 
@@ -356,9 +380,9 @@ internal async Task<WebCallResult> Execute(Uri uri, HttpMethod method, Cancellat
             return result.AsDataless();
         }
 
-        internal async Task<WebCallResult<T>> Execute<T>(Uri uri, HttpMethod method, CancellationToken ct, Dictionary<string, object>? parameters = null, bool signed = false, int weight = 1, bool ignoreRatelimit = false, HttpMethodParameterPosition? parameterPosition = null)
+        internal async Task<WebCallResult<T>> Execute<T>(Uri uri, HttpMethod method, CancellationToken ct, Dictionary<string, object>? parameters = null, bool signed = false, HttpMethodParameterPosition? parameterPosition = null)
         {
-            var result = await SendRequestAsync<KucoinResult<T>>(uri, method, ct, parameters, signed, parameterPosition: parameterPosition, requestWeight: weight, ignoreRatelimit: ignoreRatelimit).ConfigureAwait(false);
+            var result = await SendRequestAsync<KucoinResult<T>>(uri, method, ct, parameters, signed, parameterPosition: parameterPosition, requestWeight: 0).ConfigureAwait(false);
             if (!result)
                 return result.AsError<T>(result.Error!);
 
@@ -373,6 +397,24 @@ internal Uri GetUri(string path, int apiVersion = 1)
             return new Uri(BaseAddress.AppendPath("api").AppendPath("v" + apiVersion, path));
         }
 
+        /// <inheritdoc />
+        protected override ServerRateLimitError ParseRateLimitResponse(int httpStatusCode, IEnumerable<KeyValuePair<string, IEnumerable<string>>> responseHeaders, IMessageAccessor accessor)
+        {
+            var retryAfterHeader = responseHeaders.SingleOrDefault(r => r.Key.Equals("gw-ratelimit-reset", StringComparison.InvariantCultureIgnoreCase));
+            if (retryAfterHeader.Value?.Any() != true)
+                return base.ParseRateLimitResponse(httpStatusCode, responseHeaders, accessor);
+
+            var value = retryAfterHeader.Value.First();
+            if (!int.TryParse(value, out var milliseconds))
+                return base.ParseRateLimitResponse(httpStatusCode, responseHeaders, accessor);
+
+            var msg = accessor.GetValue<string>(MessagePath.Get().Property("msg"));
+            return new ServerRateLimitError(msg!)
+            {
+                RetryAfter = DateTime.UtcNow.AddMilliseconds(milliseconds)
+            };
+        }
+
         /// <inheritdoc />
         protected override Error ParseErrorResponse(int httpStatusCode, IEnumerable<KeyValuePair<string, IEnumerable<string>>> responseHeaders, IMessageAccessor accessor)
         {
diff --git a/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiAccount.cs b/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiAccount.cs
index 6077ca99..48c3010f 100644
--- a/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiAccount.cs
+++ b/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiAccount.cs
@@ -11,6 +11,7 @@
 using System;
 using System.Collections.Generic;
 using System.Net.Http;
+using System.Security.Cryptography;
 using System.Threading;
 using System.Threading.Tasks;
 
@@ -19,6 +20,7 @@ namespace Kucoin.Net.Clients.SpotApi
     /// <inheritdoc />
     public class KucoinRestClientSpotApiAccount : IKucoinRestClientSpotApiAccount
     {
+        private static readonly RequestDefinitionCache _definitions = new();
         private readonly KucoinRestClientSpotApi _baseClient;
 
         internal KucoinRestClientSpotApiAccount(KucoinRestClientSpotApi baseClient)
@@ -29,38 +31,43 @@ internal KucoinRestClientSpotApiAccount(KucoinRestClientSpotApi baseClient)
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinUserInfo>> GetUserInfoAsync(CancellationToken ct = default)
         {
-            return await _baseClient.Execute<KucoinUserInfo>(_baseClient.GetUri("user-info", 2), HttpMethod.Get, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v2/user-info", KucoinExchange.RateLimiter.ManagementRest, 20, true);
+            return await _baseClient.SendAsync<KucoinUserInfo>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinSubUser>>> GetSubUserInfoAsync(CancellationToken ct = default)
         {
-            return await _baseClient.Execute<IEnumerable<KucoinSubUser>>(_baseClient.GetUri("sub/user"), HttpMethod.Get, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/sub/user", KucoinExchange.RateLimiter.ManagementRest, 20, true);
+            return await _baseClient.SendAsync<IEnumerable<KucoinSubUser>>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinAccount>>> GetAccountsAsync(string? asset = null, AccountType? accountType = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("type", accountType.HasValue ? JsonConvert.SerializeObject(accountType, new AccountTypeConverter(false)) : null);
-            return await _baseClient.Execute<IEnumerable<KucoinAccount>>(_baseClient.GetUri("accounts"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/accounts", KucoinExchange.RateLimiter.ManagementRest, 5, true);
+            return await _baseClient.SendAsync<IEnumerable<KucoinAccount>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinAccountSingle>> GetAccountAsync(string accountId, CancellationToken ct = default)
         {
             accountId.ValidateNotNull(nameof(accountId));
-            return await _baseClient.Execute<KucoinAccountSingle>(_baseClient.GetUri("accounts/" + accountId), HttpMethod.Get, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/accounts/" + accountId, KucoinExchange.RateLimiter.ManagementRest, 5, true);
+            return await _baseClient.SendAsync<KucoinAccountSingle>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinUserFee>> GetBasicUserFeeAsync(AssetType? assetType = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currencyType", EnumConverter.GetString(assetType));
 
-            return await _baseClient.Execute<KucoinUserFee>(_baseClient.GetUri("base-fee"), HttpMethod.Get, ct, parameters, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/base-fee", KucoinExchange.RateLimiter.SpotRest, 3, true);
+            return await _baseClient.SendAsync<KucoinUserFee>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -70,11 +77,12 @@ public async Task<WebCallResult<IEnumerable<KucoinTradeFee>>> GetSymbolTradingFe
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinTradeFee>>> GetSymbolTradingFeesAsync(IEnumerable<string> symbols, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbols",  string.Join(",", symbols) }
             };
-            return await _baseClient.Execute<IEnumerable<KucoinTradeFee>>(_baseClient.GetUri("trade-fees"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/trade-fees", KucoinExchange.RateLimiter.SpotRest, 3, true);
+            return await _baseClient.SendAsync<IEnumerable<KucoinTradeFee>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -96,7 +104,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinAccountActivity>>> GetAcco
                 directionString = JsonConvert.SerializeObject(direction, new AccountDirectionConverter(false)).ToLowerInvariant();
             }
 
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("direction", direction.HasValue ? directionString : null);
             parameters.AddOptionalParameter("bizType", bizType.HasValue ? bizTypeString : null);
@@ -105,18 +113,20 @@ public async Task<WebCallResult<KucoinPaginated<KucoinAccountActivity>>> GetAcco
             parameters.AddOptionalParameter("currentPage", currentPage);
             parameters.AddOptionalParameter("pageSize", pageSize);
 
-            return await _baseClient.Execute<KucoinPaginated<KucoinAccountActivity>>(_baseClient.GetUri("accounts/ledgers"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/accounts/ledgers", KucoinExchange.RateLimiter.ManagementRest, 2, true);
+            return await _baseClient.SendAsync<KucoinPaginated<KucoinAccountActivity>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinTransferableAccount>> GetTransferableAsync(string asset, AccountType accountType, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "currency", asset },
                 { "type", JsonConvert.SerializeObject(accountType, new AccountTypeConverter(false, true))}
             };
-            return await _baseClient.Execute<KucoinTransferableAccount>(_baseClient.GetUri("accounts/transferable"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/accounts/transferable", KucoinExchange.RateLimiter.ManagementRest, 20, true);
+            return await _baseClient.SendAsync<KucoinTransferableAccount>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -133,7 +143,7 @@ public async Task<WebCallResult<KucoinInnerTransfer>> UniversalTransferAsync(
             string? clientOrderId = null,
             CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "fromAccountType", EnumConverter.GetString(fromAccountType) },
                 { "toAccountType", EnumConverter.GetString(toAccountType)},
@@ -147,14 +157,15 @@ public async Task<WebCallResult<KucoinInnerTransfer>> UniversalTransferAsync(
             parameters.AddOptionalParameter("toUserId", toUserId);
             parameters.AddOptionalParameter("toAccountTag", toAccountTag);
 
-            return await _baseClient.Execute<KucoinInnerTransfer>(_baseClient.GetUri("accounts/universal-transfer", 3), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Post, $"api/v3/universal-transfer", KucoinExchange.RateLimiter.ManagementRest, 4, true);
+            return await _baseClient.SendAsync<KucoinInnerTransfer>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinInnerTransfer>> InnerTransferAsync(string asset, AccountType from, AccountType to, decimal quantity, string? fromTag = null, string? toTag = null, string? clientOrderId = null, CancellationToken ct = default)
         {
             asset.ValidateNotNull(nameof(asset));
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "currency", asset },
                 { "from", JsonConvert.SerializeObject(from, new AccountTypeConverter(false))},
@@ -165,7 +176,8 @@ public async Task<WebCallResult<KucoinInnerTransfer>> InnerTransferAsync(string
             parameters.AddOptionalParameter("fromTag", fromTag);
             parameters.AddOptionalParameter("toTag", toTag);
 
-            return await _baseClient.Execute<KucoinInnerTransfer>(_baseClient.GetUri("accounts/inner-transfer", 2), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Post, $"api/v2/accounts/inner-transfer", KucoinExchange.RateLimiter.ManagementRest, 10, true);
+            return await _baseClient.SendAsync<KucoinInnerTransfer>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -173,14 +185,15 @@ public async Task<WebCallResult<KucoinPaginated<KucoinDeposit>>> GetDepositsAsyn
         {
             pageSize?.ValidateIntBetween(nameof(pageSize), 10, 500);
 
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("startAt", DateTimeConverter.ConvertToMilliseconds(startTime));
             parameters.AddOptionalParameter("endAt", DateTimeConverter.ConvertToMilliseconds(endTime));
             parameters.AddOptionalParameter("status", status.HasValue ? JsonConvert.SerializeObject(status, new DepositStatusConverter(false)) : null);
             parameters.AddOptionalParameter("currentPage", currentPage);
             parameters.AddOptionalParameter("pageSize", pageSize);
-            return await _baseClient.Execute<KucoinPaginated<KucoinDeposit>>(_baseClient.GetUri("deposits"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/deposits", KucoinExchange.RateLimiter.ManagementRest, 5, true);
+            return await _baseClient.SendAsync<KucoinPaginated<KucoinDeposit>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -188,40 +201,44 @@ public async Task<WebCallResult<KucoinPaginated<KucoinHistoricalDeposit>>> GetHi
         {
             pageSize?.ValidateIntBetween(nameof(pageSize), 10, 500);
 
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("startAt", DateTimeConverter.ConvertToMilliseconds(startTime));
             parameters.AddOptionalParameter("endAt", DateTimeConverter.ConvertToMilliseconds(endTime));
             parameters.AddOptionalParameter("status", status.HasValue ? JsonConvert.SerializeObject(status, new DepositStatusConverter(false)) : null);
             parameters.AddOptionalParameter("currentPage", currentPage);
             parameters.AddOptionalParameter("pageSize", pageSize);
-            return await _baseClient.Execute<KucoinPaginated<KucoinHistoricalDeposit>>(_baseClient.GetUri("hist-deposits"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/hist-deposits", KucoinExchange.RateLimiter.ManagementRest, 5, true);
+            return await _baseClient.SendAsync<KucoinPaginated<KucoinHistoricalDeposit>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinDepositAddress>> GetDepositAddressAsync(string asset, string? network = null, CancellationToken ct = default)
         {
             asset.ValidateNotNull(nameof(asset));
-            var parameters = new Dictionary<string, object> { { "currency", asset } };
+            var parameters = new ParameterCollection { { "currency", asset } };
             parameters.AddOptionalParameter("chain", network);
-            return await _baseClient.Execute<KucoinDepositAddress>(_baseClient.GetUri("deposit-addresses"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/deposit-addresses", KucoinExchange.RateLimiter.ManagementRest, 5, true);
+            return await _baseClient.SendAsync<KucoinDepositAddress>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinDepositAddress>>> GetDepositAddressesAsync(string asset, CancellationToken ct = default)
         {
             asset.ValidateNotNull(nameof(asset));
-            var parameters = new Dictionary<string, object> { { "currency", asset } };
-            return await _baseClient.Execute<IEnumerable<KucoinDepositAddress>>(_baseClient.GetUri("deposit-addresses", 2), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
+            var parameters = new ParameterCollection { { "currency", asset } };
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v2/deposit-addresses", KucoinExchange.RateLimiter.ManagementRest, 5, true);
+            return await _baseClient.SendAsync<IEnumerable<KucoinDepositAddress>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinDepositAddress>> CreateDepositAddressAsync(string asset, string? network = null, CancellationToken ct = default)
         {
             asset.ValidateNotNull(nameof(asset));
-            var parameters = new Dictionary<string, object> { { "currency", asset } };
+            var parameters = new ParameterCollection { { "currency", asset } };
             parameters.AddOptionalParameter("chain", network);
-            return await _baseClient.Execute<KucoinDepositAddress>(_baseClient.GetUri("deposit-addresses"), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Post, $"api/v1/deposit-addresses", KucoinExchange.RateLimiter.ManagementRest, 20, true);
+            return await _baseClient.SendAsync<KucoinDepositAddress>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -229,14 +246,15 @@ public async Task<WebCallResult<KucoinPaginated<KucoinWithdrawal>>> GetWithdrawa
         {
             pageSize?.ValidateIntBetween(nameof(pageSize), 10, 500);
 
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("startAt", DateTimeConverter.ConvertToMilliseconds(startTime));
             parameters.AddOptionalParameter("endAt", DateTimeConverter.ConvertToMilliseconds(endTime));
             parameters.AddOptionalParameter("status", status.HasValue ? JsonConvert.SerializeObject(status, new WithdrawalStatusConverter(false)) : null);
             parameters.AddOptionalParameter("currentPage", currentPage);
             parameters.AddOptionalParameter("pageSize", pageSize);
-            return await _baseClient.Execute<KucoinPaginated<KucoinWithdrawal>>(_baseClient.GetUri("withdrawals"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/withdrawals", KucoinExchange.RateLimiter.ManagementRest, 20, true);
+            return await _baseClient.SendAsync<KucoinPaginated<KucoinWithdrawal>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -244,14 +262,15 @@ public async Task<WebCallResult<KucoinPaginated<KucoinHistoricalWithdrawal>>> Ge
         {
             pageSize?.ValidateIntBetween(nameof(pageSize), 10, 500);
 
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("startAt", DateTimeConverter.ConvertToMilliseconds(startTime));
             parameters.AddOptionalParameter("endAt", DateTimeConverter.ConvertToMilliseconds(endTime));
             parameters.AddOptionalParameter("status", status.HasValue ? JsonConvert.SerializeObject(status, new WithdrawalStatusConverter(false)) : null);
             parameters.AddOptionalParameter("currentPage", currentPage);
             parameters.AddOptionalParameter("pageSize", pageSize);
-            return await _baseClient.Execute<KucoinPaginated<KucoinHistoricalWithdrawal>>(_baseClient.GetUri("hist-withdrawals"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/hist-withdrawals", KucoinExchange.RateLimiter.ManagementRest, 20, true);
+            return await _baseClient.SendAsync<KucoinPaginated<KucoinHistoricalWithdrawal>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -259,9 +278,10 @@ public async Task<WebCallResult<KucoinWithdrawalQuota>> GetWithdrawalQuotasAsync
         {
             asset.ValidateNotNull(nameof(asset));
 
-            var parameters = new Dictionary<string, object> { { "currency", asset } };
+            var parameters = new ParameterCollection { { "currency", asset } };
             parameters.AddOptionalParameter("chain", network);
-            return await _baseClient.Execute<KucoinWithdrawalQuota>(_baseClient.GetUri("withdrawals/quotas"), HttpMethod.Get, ct, parameters: parameters, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/withdrawals/quotas", KucoinExchange.RateLimiter.ManagementRest, 20, true);
+            return await _baseClient.SendAsync<KucoinWithdrawalQuota>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -269,7 +289,7 @@ public async Task<WebCallResult<KucoinNewWithdrawal>> WithdrawAsync(string asset
         {
             asset.ValidateNotNull(nameof(asset));
             toAddress.ValidateNotNull(nameof(toAddress));
-            var parameters = new Dictionary<string, object> {
+            var parameters = new ParameterCollection {
                 { "currency", asset },
                 { "address", toAddress },
                 { "amount", quantity },
@@ -279,20 +299,23 @@ public async Task<WebCallResult<KucoinNewWithdrawal>> WithdrawAsync(string asset
             parameters.AddOptionalParameter("remark", remark);
             parameters.AddOptionalParameter("chain", network);
             parameters.AddOptionalParameter("feeDeductType", EnumConverter.GetString(deductType));
-            return await _baseClient.Execute<KucoinNewWithdrawal>(_baseClient.GetUri("withdrawals"), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Post, $"api/v1/withdrawals", KucoinExchange.RateLimiter.ManagementRest, 5, true);
+            return await _baseClient.SendAsync<KucoinNewWithdrawal>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
-        public async Task<WebCallResult<object>> CancelWithdrawalAsync(string withdrawalId, CancellationToken ct = default)
+        public async Task<WebCallResult> CancelWithdrawalAsync(string withdrawalId, CancellationToken ct = default)
         {
             withdrawalId.ValidateNotNull(nameof(withdrawalId));
-            return await _baseClient.Execute<object>(_baseClient.GetUri($"withdrawals/{withdrawalId}"), HttpMethod.Delete, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Delete, $"api/v1/withdrawals/{withdrawalId}", KucoinExchange.RateLimiter.ManagementRest, 20, true);
+            return await _baseClient.SendAsync(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinMarginAccount>> GetMarginAccountAsync(CancellationToken ct = default)
         {
-            return await _baseClient.Execute<KucoinMarginAccount>(_baseClient.GetUri($"margin/account"), HttpMethod.Get, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/margin/account", KucoinExchange.RateLimiter.SpotRest, 40, true);
+            return await _baseClient.SendAsync<KucoinMarginAccount>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -300,38 +323,34 @@ public async Task<WebCallResult<KucoinCrossMarginAccount>> GetCrossMarginAccount
         {
             var parameters = new ParameterCollection();
             parameters.AddOptional("quoteCurrency", quoteAsset);
-            return await _baseClient.Execute<KucoinCrossMarginAccount>(_baseClient.GetUri($"margin/accounts", 3), HttpMethod.Get, ct, parameters, signed: true).ConfigureAwait(false);
-        }
-
-        /// <inheritdoc />
-        public async Task<WebCallResult<IEnumerable<KucoinRiskLimitCrossMargin>>> GetRiskLimitCrossMarginAsync(CancellationToken ct = default)
-        {
-            return await _baseClient.Execute<IEnumerable<KucoinRiskLimitCrossMargin>>(_baseClient.GetUri($"risk/limit/strategy"), HttpMethod.Get, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v3/margin/accounts", KucoinExchange.RateLimiter.SpotRest, 15, true);
+            return await _baseClient.SendAsync<KucoinCrossMarginAccount>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
-        public async Task<WebCallResult<IEnumerable<KucoinRiskLimitIsolatedMargin>>> GetRiskLimitIsolatedMarginAsync(CancellationToken ct = default)
+        public async Task<WebCallResult<KucoinIsolatedMarginAccountsInfo>> GetIsolatedMarginAccountsAsync(CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
-            parameters.AddOptionalParameter("marginModel", "isolated");
-            return await _baseClient.Execute<IEnumerable<KucoinRiskLimitIsolatedMargin>>(_baseClient.GetUri($"risk/limit/strategy"), HttpMethod.Get, ct, parameters, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/isolated/accounts", KucoinExchange.RateLimiter.SpotRest, 50, true);
+            return await _baseClient.SendAsync<KucoinIsolatedMarginAccountsInfo>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
-        public async Task<WebCallResult<KucoinIsolatedMarginAccountsInfo>> GetIsolatedMarginAccountsAsync(CancellationToken ct = default)
+        public async Task<WebCallResult<KucoinIsolatedMarginAccount>> GetIsolatedMarginAccountAsync(string symbol, CancellationToken ct = default)
         {
-            return await _baseClient.Execute<KucoinIsolatedMarginAccountsInfo>(_baseClient.GetUri($"isolated/accounts"), HttpMethod.Get, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/isolated/account/{symbol}", KucoinExchange.RateLimiter.SpotRest, 50, true);
+            return await _baseClient.SendAsync<KucoinIsolatedMarginAccount>(request, null, ct).ConfigureAwait(false);
         }
 
-        /// <inheritdoc />
-        public async Task<WebCallResult<KucoinIsolatedMarginAccount>> GetIsolatedMarginAccountAsync(string symbol, CancellationToken ct = default)
+        internal async Task<WebCallResult<KucoinToken>> GetWebsocketTokenPublicAsync(CancellationToken ct = default)
         {
-            return await _baseClient.Execute<KucoinIsolatedMarginAccount>(_baseClient.GetUri($"isolated/account/{symbol}"), HttpMethod.Get, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Post, $"api/v1/bullet-public", KucoinExchange.RateLimiter.PublicRest, 10, false);
+            return await _baseClient.SendAsync<KucoinToken>(request, null, ct).ConfigureAwait(false);
         }
 
-        internal async Task<WebCallResult<KucoinToken>> GetWebsocketToken(bool authenticated, CancellationToken ct = default)
+        internal async Task<WebCallResult<KucoinToken>> GetWebsocketTokenPrivateAsync(CancellationToken ct = default)
         {
-            return await _baseClient.Execute<KucoinToken>(_baseClient.GetUri(authenticated ? "bullet-private" : "bullet-public"), method: HttpMethod.Post, ct, signed: authenticated).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Post, $"api/v1/bullet-private", KucoinExchange.RateLimiter.PublicRest, 10, true);
+            return await _baseClient.SendAsync<KucoinToken>(request, null, ct).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiExchangeData.cs b/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiExchangeData.cs
index 2b96c1d0..28d81a52 100644
--- a/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiExchangeData.cs
+++ b/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiExchangeData.cs
@@ -15,6 +15,7 @@
 using Kucoin.Net.Objects.Models.Futures;
 using Kucoin.Net.Objects;
 using Kucoin.Net.ExtensionMethods;
+using System.Security.Cryptography;
 
 namespace Kucoin.Net.Clients.SpotApi
 {
@@ -22,6 +23,7 @@ namespace Kucoin.Net.Clients.SpotApi
     public class KucoinRestClientSpotApiExchangeData : IKucoinRestClientSpotApiExchangeData
     {
         private readonly KucoinRestClientSpotApi _baseClient;
+        private static readonly RequestDefinitionCache _definitions = new();
 
         internal KucoinRestClientSpotApiExchangeData(KucoinRestClientSpotApi baseClient)
         {
@@ -31,82 +33,92 @@ internal KucoinRestClientSpotApiExchangeData(KucoinRestClientSpotApi baseClient)
         /// <inheritdoc />
         public async Task<WebCallResult<DateTime>> GetServerTimeAsync(CancellationToken ct = default)
         {
-            var result = await _baseClient.Execute<long>(_baseClient.GetUri("timestamp"), HttpMethod.Get, ct, ignoreRatelimit: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/timestamp", KucoinExchange.RateLimiter.PublicRest, 3);
+            var result = await _baseClient.SendAsync<long>(request, null, ct).ConfigureAwait(false);
             return result.As(result ? JsonConvert.DeserializeObject<DateTime>(result.Data.ToString(), new DateTimeConverter()) : default);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinSymbol>>> GetSymbolsAsync(string? market = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("market", market);
             // Testnet doesn't support V2
             var apiVersion = _baseClient.BaseAddress == KucoinApiAddresses.TestNet.SpotAddress ? 1 : 2;
-            return await _baseClient.Execute<IEnumerable<KucoinSymbol>>(_baseClient.GetUri("symbols", apiVersion), HttpMethod.Get, ct, parameters: parameters).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v{apiVersion}/symbols", KucoinExchange.RateLimiter.PublicRest, 4);
+            return await _baseClient.SendAsync<IEnumerable<KucoinSymbol>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinTick>> GetTickerAsync(string symbol, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object> { { "symbol", symbol } };
-            return await _baseClient.Execute<KucoinTick>(_baseClient.GetUri("market/orderbook/level1"), HttpMethod.Get, ct, parameters: parameters).ConfigureAwait(false);
+            var parameters = new ParameterCollection { { "symbol", symbol } };
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/market/orderbook/level1", KucoinExchange.RateLimiter.PublicRest, 2);
+            return await _baseClient.SendAsync<KucoinTick>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinTicks>> GetTickersAsync(CancellationToken ct = default)
         {
-            return await _baseClient.Execute<KucoinTicks>(_baseClient.GetUri("market/allTickers"), HttpMethod.Get, ct).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/market/allTickers", KucoinExchange.RateLimiter.PublicRest, 15);
+            return await _baseClient.SendAsync<KucoinTicks>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<Kucoin24HourStat>> Get24HourStatsAsync(string symbol, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object> { { "symbol", symbol } };
-            return await _baseClient.Execute<Kucoin24HourStat>(_baseClient.GetUri("market/stats"), HttpMethod.Get, ct, parameters: parameters).ConfigureAwait(false);
+            var parameters = new ParameterCollection { { "symbol", symbol } };
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/market/stats", KucoinExchange.RateLimiter.PublicRest, 15);
+            return await _baseClient.SendAsync<Kucoin24HourStat>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<string>>> GetMarketsAsync(CancellationToken ct = default)
         {
-            return await _baseClient.Execute<IEnumerable<string>>(_baseClient.GetUri("markets"), HttpMethod.Get, ct).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/markets", KucoinExchange.RateLimiter.PublicRest, 3);
+            return await _baseClient.SendAsync<IEnumerable<string>>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinOrderBook>> GetAggregatedPartialOrderBookAsync(string symbol, int limit, CancellationToken ct = default)
         {
             limit.ValidateIntValues(nameof(limit), 20, 100);
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbol", symbol }
             };
 
-            return await _baseClient.Execute<KucoinOrderBook>(_baseClient.GetUri($"market/orderbook/level2_{limit}"), HttpMethod.Get, ct, parameters).ConfigureAwait(false);
+            var weight = limit == 20 ? 2 : 4;
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/market/orderbook/level2_{limit}", KucoinExchange.RateLimiter.PublicRest, weight);
+            return await _baseClient.SendAsync<KucoinOrderBook>(request, parameters, ct, weight).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinOrderBook>> GetAggregatedFullOrderBookAsync(string symbol, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbol", symbol }
             };
-            return await _baseClient.Execute<KucoinOrderBook>(_baseClient.GetUri($"market/orderbook/level2", 3), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/market/orderbook/level2", KucoinExchange.RateLimiter.PublicRest, 3);
+            return await _baseClient.SendAsync<KucoinOrderBook>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinTrade>>> GetTradeHistoryAsync(string symbol, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbol", symbol }
             };
-            return await _baseClient.Execute<IEnumerable<KucoinTrade>>(_baseClient.GetUri($"market/histories"), HttpMethod.Get, ct, parameters).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/market/histories", KucoinExchange.RateLimiter.PublicRest, 3);
+            return await _baseClient.SendAsync<IEnumerable<KucoinTrade>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinKline>>> GetKlinesAsync(string symbol, KlineInterval interval, DateTime? startTime = null, DateTime? endTime = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbol", symbol },
                 { "type", JsonConvert.SerializeObject(interval, new KlineIntervalConverter(false)) }
@@ -114,69 +126,55 @@ public async Task<WebCallResult<IEnumerable<KucoinKline>>> GetKlinesAsync(string
             parameters.AddOptionalParameter("startAt", DateTimeConverter.ConvertToSeconds(startTime));
             parameters.AddOptionalParameter("endAt", DateTimeConverter.ConvertToSeconds(endTime));
 
-            return await _baseClient.Execute<IEnumerable<KucoinKline>>(_baseClient.GetUri("market/candles"), HttpMethod.Get, ct, parameters).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/market/candles", KucoinExchange.RateLimiter.PublicRest, 3);
+            return await _baseClient.SendAsync<IEnumerable<KucoinKline>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinAssetDetails>>> GetAssetsAsync(CancellationToken ct = default)
         {
-            return await _baseClient.Execute<IEnumerable<KucoinAssetDetails>>(_baseClient.GetUri("currencies", 3), HttpMethod.Get, ct).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v3/currencies", KucoinExchange.RateLimiter.PublicRest, 3);
+            return await _baseClient.SendAsync<IEnumerable<KucoinAssetDetails>>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinAssetDetails>> GetAssetAsync(string asset, CancellationToken ct = default)
         {
             asset.ValidateNotNull(nameof(asset));
-            return await _baseClient.Execute<KucoinAssetDetails>(_baseClient.GetUri($"currencies/{asset}", 3), HttpMethod.Get, ct).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v3/currencies/{asset}", KucoinExchange.RateLimiter.PublicRest, 3);
+            return await _baseClient.SendAsync<KucoinAssetDetails>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<Dictionary<string, decimal>>> GetFiatPricesAsync(string? fiatBase = null, IEnumerable<string>? assets = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("base", fiatBase);
             parameters.AddOptionalParameter("currencies", assets?.Any() == true ? string.Join(",", assets) : null);
 
-            return await _baseClient.Execute<Dictionary<string, decimal>>(_baseClient.GetUri("prices"), HttpMethod.Get, ct, parameters: parameters).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/prices", KucoinExchange.RateLimiter.PublicRest, 3);
+            return await _baseClient.SendAsync<Dictionary<string, decimal>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinIndexBase>> GetMarginMarkPriceAsync(string symbol, CancellationToken ct = default)
         {
-            return await _baseClient.Execute<KucoinIndexBase>(_baseClient.GetUri($"mark-price/{symbol}/current"), HttpMethod.Get, ct).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/mark-price/{symbol}/current", KucoinExchange.RateLimiter.PublicRest, 2);
+            return await _baseClient.SendAsync<KucoinIndexBase>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinMarginConfig>> GetMarginConfigurationAsync(CancellationToken ct = default)
         {
-            return await _baseClient.Execute<KucoinMarginConfig>(_baseClient.GetUri("margin/config"), HttpMethod.Get, ct).ConfigureAwait(false);
-        }
-
-        /// <inheritdoc />
-        public async Task<WebCallResult<IEnumerable<KucoinLendingMarketEntry>>> GetLendMarketDataAsync(string asset, int? term = null, CancellationToken ct = default)
-        {
-            var parameters = new Dictionary<string, object>
-            {
-                { "currency", asset }
-            };
-            parameters.AddOptionalParameter("term", term);
-            return await _baseClient.Execute<IEnumerable<KucoinLendingMarketEntry>>(_baseClient.GetUri("margin/market"), HttpMethod.Get, ct, parameters).ConfigureAwait(false);
-        }
-
-        /// <inheritdoc />
-        public async Task<WebCallResult<IEnumerable<KucoinBorrowOrderDetails>>> GetMarginTradeHistoryAsync(string asset, CancellationToken ct = default)
-        {
-            var parameters = new Dictionary<string, object>
-            {
-                { "currency", asset }
-            };
-            return await _baseClient.Execute<IEnumerable<KucoinBorrowOrderDetails>>(_baseClient.GetUri("margin/trade/last"), HttpMethod.Get, ct, parameters).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/margin/config", KucoinExchange.RateLimiter.SpotRest, 25);
+            return await _baseClient.SendAsync<KucoinMarginConfig>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinTradingPairConfiguration>>> GetMarginTradingPairConfigurationAsync(CancellationToken ct = default)
         {
-            return await _baseClient.Execute<IEnumerable<KucoinTradingPairConfiguration>>(_baseClient.GetUri($"isolated/symbols"), HttpMethod.Get, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/isolated/symbols", KucoinExchange.RateLimiter.SpotRest, 20, true);
+            return await _baseClient.SendAsync<IEnumerable<KucoinTradingPairConfiguration>>(request, null, ct).ConfigureAwait(false);
         }
     }
 }
diff --git a/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiProAccount.cs b/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiProAccount.cs
index e514619f..d43b9673 100644
--- a/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiProAccount.cs
+++ b/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiProAccount.cs
@@ -18,6 +18,7 @@ namespace Kucoin.Net.Clients.SpotApi
     /// <inheritdoc />
     public class KucoinRestClientSpotApiProAccount : IKucoinRestClientSpotApiProAccount
     {
+        private static readonly RequestDefinitionCache _definitions = new();
         private readonly KucoinRestClientSpotApi _baseClient;
 
         internal KucoinRestClientSpotApiProAccount(KucoinRestClientSpotApi baseClient)
@@ -56,7 +57,7 @@ public async Task<WebCallResult<KucoinNewOrder>> PlaceOrderAsync(
                     throw new ArgumentException("Market order cant have both quantity and quoteQuantity specified");
             }
 
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbol", symbol },
                 { "side", JsonConvert.SerializeObject(side, new OrderSideConverter(false)) },
@@ -74,7 +75,8 @@ public async Task<WebCallResult<KucoinNewOrder>> PlaceOrderAsync(
             parameters.AddOptionalParameter("visibleSize", visibleIceBergSize);
             parameters.AddOptionalParameter("remark", remark);
             parameters.AddOptionalParameter("stp", selfTradePrevention.HasValue ? JsonConvert.SerializeObject(selfTradePrevention.Value, new SelfTradePreventionConverter(false)) : null);
-            var result = await _baseClient.Execute<KucoinNewOrder>(_baseClient.GetUri("hf/orders"), HttpMethod.Post, ct, parameters, true, weight: 4).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Post, $"api/v1/hf/orders", KucoinExchange.RateLimiter.SpotRest, 1, true);
+            var result = await _baseClient.SendAsync<KucoinNewOrder>(request, parameters, ct).ConfigureAwait(false);
             if (result)
                 _baseClient.InvokeOrderPlaced(new OrderId { SourceObject = result.Data, Id = result.Data.Id });
             return result;
@@ -86,25 +88,27 @@ public async Task<WebCallResult<KucoinCanceledOrders>> CancelOrderAsync(string o
             orderId.ValidateNotNull(nameof(orderId));
             symbol.ValidateNotNull(nameof(symbol));
 
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
 
-            var result = await _baseClient.Execute<KucoinCanceledOrders>(_baseClient.GetUri($"hf/orders/{orderId}"), HttpMethod.Delete, ct, signed: true, weight: 3, parameters: parameters).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Delete, $"api/v1/hf/orders/{orderId}", KucoinExchange.RateLimiter.SpotRest, 1, true);
+            var result = await _baseClient.SendAsync<KucoinCanceledOrders>(request, parameters, ct).ConfigureAwait(false);
             if (result)
                 _baseClient.InvokeOrderCanceled(new OrderId { SourceObject = result.Data, Id = orderId });
             return result;
         }
 
         /// <inheritdoc />
-        public Task<WebCallResult<KucoinOrderHighFrequency>> GetOrderAsync(string orderId, string symbol, CancellationToken ct = default)
+        public async Task<WebCallResult<KucoinOrderHighFrequency>> GetOrderAsync(string orderId, string symbol, CancellationToken ct = default)
         {
             orderId.ValidateNotNull(nameof(orderId));
             symbol.ValidateNotNull(nameof(symbol));
 
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
 
-            return _baseClient.Execute<KucoinOrderHighFrequency>(_baseClient.GetUri($"hf/orders/{orderId}"), HttpMethod.Get, ct, signed: true, parameters: parameters);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/hf/orders/{orderId}", KucoinExchange.RateLimiter.SpotRest, 2, true);
+            return await _baseClient.SendAsync<KucoinOrderHighFrequency>(request, parameters, ct).ConfigureAwait(false);
         }
     }
 }
\ No newline at end of file
diff --git a/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiTrading.cs b/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiTrading.cs
index bac3b2a0..dd8cb331 100644
--- a/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiTrading.cs
+++ b/Kucoin.Net/Clients/SpotApi/KucoinRestClientSpotApiTrading.cs
@@ -23,6 +23,7 @@ namespace Kucoin.Net.Clients.SpotApi
     public class KucoinRestClientSpotApiTrading : IKucoinRestClientSpotApiTrading
     {
         private readonly KucoinRestClientSpotApi _baseClient;
+        private static readonly RequestDefinitionCache _definitions = new();
 
         internal KucoinRestClientSpotApiTrading(KucoinRestClientSpotApi baseClient)
         {
@@ -60,7 +61,7 @@ public async Task<WebCallResult<KucoinNewOrder>> PlaceOrderAsync(
                     throw new ArgumentException("Market order cant have both quantity and quoteQuantity specified");
             }
 
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbol", symbol },
                 { "side", JsonConvert.SerializeObject(side, new OrderSideConverter(false)) },
@@ -78,7 +79,9 @@ public async Task<WebCallResult<KucoinNewOrder>> PlaceOrderAsync(
             parameters.AddOptionalParameter("visibleSize", visibleIceBergSize);
             parameters.AddOptionalParameter("remark", remark);
             parameters.AddOptionalParameter("stp", selfTradePrevention.HasValue ? JsonConvert.SerializeObject(selfTradePrevention.Value, new SelfTradePreventionConverter(false)) : null);
-            var result = await _baseClient.Execute<KucoinNewOrder>(_baseClient.GetUri("orders"), HttpMethod.Post, ct, parameters, true, weight: 2).ConfigureAwait(false);
+
+            var request = _definitions.GetOrCreate(HttpMethod.Post, $"api/v1/orders", KucoinExchange.RateLimiter.SpotRest, 2, true);
+            var result = await _baseClient.SendAsync<KucoinNewOrder>(request, parameters, ct).ConfigureAwait(false);
             if (result)
                 _baseClient.InvokeOrderPlaced(new OrderId { SourceObject = result.Data, Id = result.Data.Id });
             return result;
@@ -115,7 +118,7 @@ public async Task<WebCallResult<KucoinNewOrder>> PlaceTestOrderAsync(
                     throw new ArgumentException("Market order cant have both quantity and quoteQuantity specified");
             }
 
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbol", symbol },
                 { "side", JsonConvert.SerializeObject(side, new OrderSideConverter(false)) },
@@ -133,7 +136,8 @@ public async Task<WebCallResult<KucoinNewOrder>> PlaceTestOrderAsync(
             parameters.AddOptionalParameter("visibleSize", visibleIceBergSize);
             parameters.AddOptionalParameter("remark", remark);
             parameters.AddOptionalParameter("stp", selfTradePrevention.HasValue ? JsonConvert.SerializeObject(selfTradePrevention.Value, new SelfTradePreventionConverter(false)) : null);
-            return await _baseClient.Execute<KucoinNewOrder>(_baseClient.GetUri("orders/test"), HttpMethod.Post, ct, parameters, true, weight: 2).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Post, $"api/v1/orders/test", KucoinExchange.RateLimiter.SpotRest, 2, true);
+            return await _baseClient.SendAsync<KucoinNewOrder>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -171,7 +175,7 @@ public async Task<WebCallResult<KucoinNewMarginOrder>> PlaceMarginOrderAsync(
             if (marginMode.HasValue && marginMode.Value != MarginMode.CrossMode)
                 throw new ArgumentException("Currently, the platform only supports the cross mode");
 
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbol", symbol },
                 { "side", JsonConvert.SerializeObject(side, new OrderSideConverter(false)) },
@@ -192,7 +196,8 @@ public async Task<WebCallResult<KucoinNewMarginOrder>> PlaceMarginOrderAsync(
             parameters.AddOptionalParameter("autoBorrow", autoBorrow);
             parameters.AddOptionalParameter("autoRepay", autoRepay);
             parameters.AddOptionalParameter("stp", selfTradePrevention.HasValue ? JsonConvert.SerializeObject(selfTradePrevention.Value, new SelfTradePreventionConverter(false)) : null);
-            return await _baseClient.Execute<KucoinNewMarginOrder>(_baseClient.GetUri("margin/order"), HttpMethod.Post, ct, parameters, true, weight: 5).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Post, $"api/v1/margin/order", KucoinExchange.RateLimiter.SpotRest, 5, true);
+            return await _baseClient.SendAsync<KucoinNewMarginOrder>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -230,7 +235,7 @@ public async Task<WebCallResult<KucoinNewMarginOrder>> PlaceTestMarginOrderAsync
             if (marginMode.HasValue && marginMode.Value != MarginMode.CrossMode)
                 throw new ArgumentException("Currently, the platform only supports the cross mode");
 
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbol", symbol },
                 { "side", JsonConvert.SerializeObject(side, new OrderSideConverter(false)) },
@@ -251,7 +256,8 @@ public async Task<WebCallResult<KucoinNewMarginOrder>> PlaceTestMarginOrderAsync
             parameters.AddOptionalParameter("autoBorrow", autoBorrow);
             parameters.AddOptionalParameter("autoRepay", autoRepay);
             parameters.AddOptionalParameter("stp", selfTradePrevention.HasValue ? JsonConvert.SerializeObject(selfTradePrevention.Value, new SelfTradePreventionConverter(false)) : null);
-            return await _baseClient.Execute<KucoinNewMarginOrder>(_baseClient.GetUri("margin/order/test"), HttpMethod.Post, ct, parameters, true, weight: 5).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Post, $"api/v1/margin/order/test", KucoinExchange.RateLimiter.SpotRest, 5, true);
+            return await _baseClient.SendAsync<KucoinNewMarginOrder>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -267,13 +273,14 @@ public async Task<WebCallResult<KucoinBulkOrderResponse>> PlaceBulkOrderAsync(st
             if (orderList.Any(o => o.TradeType != null && o.TradeType != TradeType.SpotTrade))
                 throw new ArgumentException("Only spot orders can be part of a bulk order");
 
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbol", symbol },
                 { "orderList", orderList }
             };
 
-            var result = await _baseClient.Execute<KucoinBulkOrderResponse>(_baseClient.GetUri("orders/multi"), HttpMethod.Post, ct, parameters, true, weight: 60, parameterPosition: HttpMethodParameterPosition.InBody).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Post, $"api/v1/orders/multi", KucoinExchange.RateLimiter.SpotRest, 3, true);
+            var result = await _baseClient.SendAsync<KucoinBulkOrderResponse>(request, parameters, ct).ConfigureAwait(false);
             if (result)
             {
                 foreach (var order in result.Data.Orders.Where(o => o.Status == BulkOrderCreationStatus.Success))
@@ -288,7 +295,8 @@ public async Task<WebCallResult<KucoinBulkOrderResponse>> PlaceBulkOrderAsync(st
         public async Task<WebCallResult<KucoinCanceledOrders>> CancelOrderAsync(string orderId, CancellationToken ct = default)
         {
             orderId.ValidateNotNull(nameof(orderId));
-            var result = await _baseClient.Execute<KucoinCanceledOrders>(_baseClient.GetUri($"orders/{orderId}"), HttpMethod.Delete, ct, signed: true, weight: 3).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Delete, $"api/v1/orders/{orderId}", KucoinExchange.RateLimiter.SpotRest, 3, true);
+            var result = await _baseClient.SendAsync<KucoinCanceledOrders>(request, null, ct).ConfigureAwait(false);
             if (result)
                 _baseClient.InvokeOrderCanceled(new OrderId { SourceObject = result.Data, Id = orderId });
             return result;
@@ -298,7 +306,8 @@ public async Task<WebCallResult<KucoinCanceledOrders>> CancelOrderAsync(string o
         public async Task<WebCallResult<KucoinCanceledOrder>> CancelOrderByClientOrderIdAsync(string clientOrderId, CancellationToken ct = default)
         {
             clientOrderId.ValidateNotNull(nameof(clientOrderId));
-            var result = await _baseClient.Execute<KucoinCanceledOrder>(_baseClient.GetUri($"order/client-order/{clientOrderId}"), HttpMethod.Delete, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Delete, $"api/v1/order/client-order/{clientOrderId}", KucoinExchange.RateLimiter.SpotRest, 5, true);
+            var result = await _baseClient.SendAsync<KucoinCanceledOrder>(request, null, ct).ConfigureAwait(false);
             if (result)
                 _baseClient.InvokeOrderCanceled(new OrderId { SourceObject = result.Data, Id = clientOrderId });
             return result;
@@ -307,10 +316,11 @@ public async Task<WebCallResult<KucoinCanceledOrder>> CancelOrderByClientOrderId
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinCanceledOrders>> CancelAllOrdersAsync(string? symbol = null, TradeType? type = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("tradeType", EnumConverter.GetString(type));
-            return await _baseClient.Execute<KucoinCanceledOrders>(_baseClient.GetUri("orders"), HttpMethod.Delete, ct, parameters, true, weight: 60).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Delete, $"api/v1/orders", KucoinExchange.RateLimiter.SpotRest, 5, true);
+            return await _baseClient.SendAsync<KucoinCanceledOrders>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -318,7 +328,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinOrder>>> GetOrdersAsync(st
         {
             pageSize?.ValidateIntBetween(nameof(pageSize), 10, 500);
 
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("side", side.HasValue ? JsonConvert.SerializeObject(side, new OrderSideConverter(false)) : null);
             parameters.AddOptionalParameter("type", type.HasValue ? JsonConvert.SerializeObject(type, new OrderTypeConverter(false)) : null);
@@ -329,43 +339,31 @@ public async Task<WebCallResult<KucoinPaginated<KucoinOrder>>> GetOrdersAsync(st
             parameters.AddOptionalParameter("currentPage", currentPage);
             parameters.AddOptionalParameter("pageSize", pageSize);
 
-            return await _baseClient.Execute<KucoinPaginated<KucoinOrder>>(_baseClient.GetUri("orders"), HttpMethod.Get, ct, parameters: parameters, signed: true, weight: 6).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/orders", KucoinExchange.RateLimiter.SpotRest, 2, true);
+            return await _baseClient.SendAsync<KucoinPaginated<KucoinOrder>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinOrder>>> GetRecentOrdersAsync(CancellationToken ct = default)
         {
-            return await _baseClient.Execute<IEnumerable<KucoinOrder>>(_baseClient.GetUri("limit/orders"), HttpMethod.Get, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/limit/orders", KucoinExchange.RateLimiter.SpotRest, 3, true);
+            return await _baseClient.SendAsync<IEnumerable<KucoinOrder>>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinOrder>> GetOrderByClientOrderIdAsync(string clientOrderId, CancellationToken ct = default)
         {
             clientOrderId.ValidateNotNull(nameof(clientOrderId));
-            return await _baseClient.Execute<KucoinOrder>(_baseClient.GetUri($"order/client-order/{clientOrderId}"), HttpMethod.Get, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/order/client-order/{clientOrderId}", KucoinExchange.RateLimiter.SpotRest, 3, true);
+            return await _baseClient.SendAsync<KucoinOrder>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinOrder>> GetOrderAsync(string orderId, CancellationToken ct = default)
         {
             orderId.ValidateNotNull(nameof(orderId));
-            return await _baseClient.Execute<KucoinOrder>(_baseClient.GetUri($"orders/{orderId}"), HttpMethod.Get, ct, signed: true).ConfigureAwait(false);
-        }
-
-        /// <inheritdoc />
-        public async Task<WebCallResult<KucoinPaginated<KucoinHistoricalOrder>>> GetHistoricalOrdersAsync(string? symbol = null, Enums.OrderSide? side = null, DateTime? startTime = null, DateTime? endTime = null, int? currentPage = null, int? pageSize = null, CancellationToken ct = default)
-        {
-            pageSize?.ValidateIntBetween(nameof(pageSize), 10, 500);
-
-            var parameters = new Dictionary<string, object>();
-            parameters.AddOptionalParameter("symbol", symbol);
-            parameters.AddOptionalParameter("side", side.HasValue ? JsonConvert.SerializeObject(side, new OrderSideConverter(false)) : null);
-            parameters.AddOptionalParameter("startAt", DateTimeConverter.ConvertToMilliseconds(startTime));
-            parameters.AddOptionalParameter("endAt", DateTimeConverter.ConvertToMilliseconds(endTime));
-            parameters.AddOptionalParameter("currentPage", currentPage);
-            parameters.AddOptionalParameter("pageSize", pageSize);
-
-            return await _baseClient.Execute<KucoinPaginated<KucoinHistoricalOrder>>(_baseClient.GetUri("hist-orders"), HttpMethod.Get, ct, signed: true, parameters: parameters).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/orders/{orderId}", KucoinExchange.RateLimiter.SpotRest, 2, true);
+            return await _baseClient.SendAsync<KucoinOrder>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -376,7 +374,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinUserTrade>>> GetUserTrades
             if (endTime.HasValue && startTime.HasValue && (endTime.Value - startTime.Value).TotalDays > 7)
                 throw new ArgumentException("Difference between start and end time can be a maximum of 1 week");
 
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("side", side.HasValue ? JsonConvert.SerializeObject(side, new OrderSideConverter(false)) : null);
             parameters.AddOptionalParameter("type", type.HasValue ? JsonConvert.SerializeObject(type, new OrderTypeConverter(false)) : null);
@@ -387,13 +385,15 @@ public async Task<WebCallResult<KucoinPaginated<KucoinUserTrade>>> GetUserTrades
             parameters.AddOptionalParameter("currentPage", currentPage);
             parameters.AddOptionalParameter("pageSize", pageSize);
 
-            return await _baseClient.Execute<KucoinPaginated<KucoinUserTrade>>(_baseClient.GetUri("fills"), HttpMethod.Get, ct, signed: true, parameters: parameters).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/fills", KucoinExchange.RateLimiter.SpotRest, 10, true);
+            return await _baseClient.SendAsync<KucoinPaginated<KucoinUserTrade>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinUserTrade>>> GetRecentUserTradesAsync(CancellationToken ct = default)
         {
-            return await _baseClient.Execute<IEnumerable<KucoinUserTrade>>(_baseClient.GetUri("limit/fills"), HttpMethod.Get, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/limit/fills", KucoinExchange.RateLimiter.SpotRest, 20, true);
+            return await _baseClient.SendAsync<IEnumerable<KucoinUserTrade>>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -432,7 +432,7 @@ public async Task<WebCallResult<KucoinNewOrder>> PlaceStopOrderAsync(
             if (stopCondition == StopCondition.None)
                 throw new ArgumentException("Invalid stop condition", nameof(stopCondition));
 
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbol", symbol },
                 { "clientOid", clientOrderId ?? Guid.NewGuid().ToString() },
@@ -457,41 +457,45 @@ public async Task<WebCallResult<KucoinNewOrder>> PlaceStopOrderAsync(
 
             parameters.AddOptionalParameter("funds", quoteQuantity);
 
-            return await _baseClient.Execute<KucoinNewOrder>(_baseClient.GetUri("stop-order"), HttpMethod.Post, ct, parameters, true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Post, $"api/v1/stop-order", KucoinExchange.RateLimiter.SpotRest, 2, true);
+            return await _baseClient.SendAsync<KucoinNewOrder>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinCanceledOrders>> CancelStopOrderAsync(string orderId, CancellationToken ct = default)
         {
-            return await _baseClient.Execute<KucoinCanceledOrders>(_baseClient.GetUri("stop-order/" + orderId), HttpMethod.Delete, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Delete, $"api/v1/stop-order/" + orderId, KucoinExchange.RateLimiter.SpotRest, 3, true);
+            return await _baseClient.SendAsync<KucoinCanceledOrders>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinCanceledOrder>> CancelStopOrderByClientOrderIdAsync(string clientOrderId, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>()
+            var parameters = new ParameterCollection()
             {
                 { "clientOid", clientOrderId }
             };
-            return await _baseClient.Execute<KucoinCanceledOrder>(_baseClient.GetUri("stop-order/cancelOrderByClientOid"), HttpMethod.Delete, ct, parameters, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Delete, $"api/v1/stop-order/cancelOrderByClientOid", KucoinExchange.RateLimiter.SpotRest, 5, true);
+            return await _baseClient.SendAsync<KucoinCanceledOrder>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinCanceledOrders>> CancelStopOrdersAsync(string? symbol = null, IEnumerable<string>? orderIds = null, TradeType? tradeType = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("orderIds", orderIds == null ? null : string.Join(",", orderIds));
             parameters.AddOptionalParameter("tradeType", tradeType.HasValue ? JsonConvert.SerializeObject(tradeType, new TradeTypeConverter(false)) : null);
 
-            return await _baseClient.Execute<KucoinCanceledOrders>(_baseClient.GetUri("stop-order/cancel"), HttpMethod.Delete, ct, parameters, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Delete, $"api/v1/stop-order/cancel", KucoinExchange.RateLimiter.SpotRest, 3, true);
+            return await _baseClient.SendAsync<KucoinCanceledOrders>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginated<KucoinStopOrder>>> GetStopOrdersAsync(bool? activeOrders = null, string? symbol = null, Enums.OrderSide? side = null,
             Enums.OrderType? type = null, TradeType? tradeType = null, DateTime? startTime = null, DateTime? endTime = null, IEnumerable<string>? orderIds = null, int? currentPage = null, int? pageSize = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("status", activeOrders.HasValue ? activeOrders == true ? "active" : "done" : null);
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("side", side.HasValue ? JsonConvert.SerializeObject(side, new OrderSideConverter(false)) : null);
@@ -503,23 +507,26 @@ public async Task<WebCallResult<KucoinPaginated<KucoinStopOrder>>> GetStopOrders
             parameters.AddOptionalParameter("pageSize", pageSize);
             parameters.AddOptionalParameter("tradeType", tradeType.HasValue ? JsonConvert.SerializeObject(tradeType, new TradeTypeConverter(false)) : null);
 
-            return await _baseClient.Execute<KucoinPaginated<KucoinStopOrder>>(_baseClient.GetUri("stop-order"), HttpMethod.Get, ct, parameters, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/stop-order", KucoinExchange.RateLimiter.SpotRest, 8, true);
+            return await _baseClient.SendAsync<KucoinPaginated<KucoinStopOrder>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinStopOrder>> GetStopOrderAsync(string orderId, CancellationToken ct = default)
         {
-            return await _baseClient.Execute<KucoinStopOrder>(_baseClient.GetUri("stop-order/" + orderId), HttpMethod.Get, ct, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/stop-order/" + orderId, KucoinExchange.RateLimiter.SpotRest, 3, true);
+            return await _baseClient.SendAsync<KucoinStopOrder>(request, null, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinStopOrder>>> GetStopOrderByClientOrderIdAsync(string clientOrderId, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>()
+            var parameters = new ParameterCollection()
             {
                 { "clientOid", clientOrderId }
             };
-            return await _baseClient.Execute<IEnumerable<KucoinStopOrder>>(_baseClient.GetUri("stop-order/queryOrderByClientOid"), HttpMethod.Get, ct, parameters, signed: true).ConfigureAwait(false);
+            var request = _definitions.GetOrCreate(HttpMethod.Get, $"api/v1/stop-order/queryOrderByClientOid", KucoinExchange.RateLimiter.SpotRest, 3, true);
+            return await _baseClient.SendAsync<IEnumerable<KucoinStopOrder>>(request, parameters, ct).ConfigureAwait(false);
         }
 
         /// <inheritdoc />
@@ -531,7 +538,7 @@ public async Task<WebCallResult<KucoinNewBorrowOrder>> PlaceBorrowOrderAsync(
             string? term = null,
             CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "currency", asset },
                 { "type", JsonConvert.SerializeObject(type, new BorrowOrderTypeConverter(false)) },
@@ -546,7 +553,7 @@ public async Task<WebCallResult<KucoinNewBorrowOrder>> PlaceBorrowOrderAsync(
         public async Task<WebCallResult<KucoinBorrowOrder>> GetBorrowOrderAsync(string orderId, CancellationToken ct = default)
         {
             orderId.ValidateNotNull(nameof(orderId));
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "orderId", orderId }
             };
@@ -556,7 +563,7 @@ public async Task<WebCallResult<KucoinBorrowOrder>> GetBorrowOrderAsync(string o
         /// <inheritdoc />
         public async Task<WebCallResult> RepaySingleBorrowOrderAsync(string asset, string tradeId, decimal quantity, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "currency", asset },
                 { "tradeId", tradeId },
@@ -569,7 +576,7 @@ public async Task<WebCallResult> RepaySingleBorrowOrderAsync(string asset, strin
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginated<KucoinRepayRecord>>> GetOpenBorrowRecordsAsync(string? asset = null, int? page = null, int? pageSize = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("page", page);
             parameters.AddOptionalParameter("pageSize", pageSize);
@@ -579,7 +586,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinRepayRecord>>> GetOpenBorr
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginated<KucoinBorrowRecord>>> GetClosedBorrowRecordsAsync(string? asset = null, int? page = null, int? pageSize = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("page", page);
             parameters.AddOptionalParameter("pageSize", pageSize);
@@ -589,7 +596,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinBorrowRecord>>> GetClosedB
         /// <inheritdoc />
         public async Task<WebCallResult> RepayAllAsync(string asset, RepaymentStrategy strategy, decimal quantity, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>()
+            var parameters = new ParameterCollection()
             {
                 { "currency", asset },
                 { "sequence", EnumConverter.GetString(strategy) },
@@ -601,7 +608,7 @@ public async Task<WebCallResult> RepayAllAsync(string asset, RepaymentStrategy s
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinNewOrder>> PlaceLendOrderAsync(string asset, decimal quantity, decimal dailyInterestRate, int term, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>()
+            var parameters = new ParameterCollection()
             {
                 { "currency", asset },
                 { "dailyIntRate", dailyInterestRate },
@@ -620,7 +627,7 @@ public async Task<WebCallResult> CancelLendOrderAsync(string orderId, Cancellati
         /// <inheritdoc />
         public async Task<WebCallResult> SetAutoLendAsync(string asset, bool isEnabled, decimal? retainQuantity = null, decimal? dailyInterestRate = null, int? term = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>()
+            var parameters = new ParameterCollection()
             {
                 { "currency", asset },
                 { "isEnable", isEnabled }
@@ -634,7 +641,7 @@ public async Task<WebCallResult> SetAutoLendAsync(string asset, bool isEnabled,
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginated<KucoinLendOrder>>> GetOpenLendOrdersAsync(string? asset = null, int? page = null, int? pageSize = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("page", page);
             parameters.AddOptionalParameter("pageSize", pageSize);
@@ -644,7 +651,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinLendOrder>>> GetOpenLendOr
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginated<KucoinLendOrder>>> GetClosedLendOrdersAsync(string? asset = null, int? page = null, int? pageSize = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("page", page);
             parameters.AddOptionalParameter("pageSize", pageSize);
@@ -654,7 +661,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinLendOrder>>> GetClosedLend
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginated<KucoinOpenLend>>> GetOpenLendsAsync(string? asset = null, int? page = null, int? pageSize = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("page", page);
             parameters.AddOptionalParameter("pageSize", pageSize);
@@ -664,7 +671,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinOpenLend>>> GetOpenLendsAs
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginated<KucoinClosedLend>>> GetClosedLendsAsync(string? asset = null, int? page = null, int? pageSize = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("page", page);
             parameters.AddOptionalParameter("pageSize", pageSize);
@@ -674,7 +681,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinClosedLend>>> GetClosedLen
         /// <inheritdoc />
         public async Task<WebCallResult<IEnumerable<KucoinLendHistory>>> GetLendingStatusAsync(string? asset = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("currency", asset);
             return await _baseClient.Execute<IEnumerable<KucoinLendHistory>>(_baseClient.GetUri($"margin/lend/assets"), HttpMethod.Get, ct, parameters, true).ConfigureAwait(false);
         }
@@ -690,7 +697,7 @@ public async Task<WebCallResult<KucoinNewIsolatedBorrowOrder>> PlaceIsolatedBorr
             string? term = null,
             CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbol", symbol },
                 { "currency", asset },
@@ -705,7 +712,7 @@ public async Task<WebCallResult<KucoinNewIsolatedBorrowOrder>> PlaceIsolatedBorr
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginated<KucoinIsolatedOpenBorrowRecord>>> GetIsolatedOpenBorrowRecordsAsync(string? symbol = null, string? asset = null, int? page = null, int? pageSize = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("page", page);
@@ -716,7 +723,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinIsolatedOpenBorrowRecord>>
         /// <inheritdoc />
         public async Task<WebCallResult<KucoinPaginated<KucoinIsolatedClosedBorrowRecord>>> GetIsolatedClosedBorrowRecordsAsync(string? symbol = null, string? asset = null, int? page = null, int? pageSize = null, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>();
+            var parameters = new ParameterCollection();
             parameters.AddOptionalParameter("symbol", symbol);
             parameters.AddOptionalParameter("currency", asset);
             parameters.AddOptionalParameter("page", page);
@@ -727,7 +734,7 @@ public async Task<WebCallResult<KucoinPaginated<KucoinIsolatedClosedBorrowRecord
         /// <inheritdoc />
         public async Task<WebCallResult> RepayAllIsolatedAsync(string symbol, string asset, RepaymentStrategy strategy, decimal quantity, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>()
+            var parameters = new ParameterCollection()
             {
                 { "symbol", symbol },
                 { "currency", asset },
@@ -740,7 +747,7 @@ public async Task<WebCallResult> RepayAllIsolatedAsync(string symbol, string ass
         /// <inheritdoc />
         public async Task<WebCallResult> RepaySingleIsolatedBorrowOrderAsync(string symbol, string asset, decimal quantity, string loanId, CancellationToken ct = default)
         {
-            var parameters = new Dictionary<string, object>
+            var parameters = new ParameterCollection
             {
                 { "symbol", symbol },
                 { "currency", asset },
diff --git a/Kucoin.Net/Clients/SpotApi/KucoinSocketClientSpotApi.cs b/Kucoin.Net/Clients/SpotApi/KucoinSocketClientSpotApi.cs
index 80614168..2a4ffe57 100644
--- a/Kucoin.Net/Clients/SpotApi/KucoinSocketClientSpotApi.cs
+++ b/Kucoin.Net/Clients/SpotApi/KucoinSocketClientSpotApi.cs
@@ -234,7 +234,11 @@ public async Task<CallResult<UpdateSubscription>> SubscribeToStopOrderUpdatesAsy
                 options.Environment = ClientOptions.Environment;
             }))
             {
-                WebCallResult<KucoinToken> tokenResult = await ((KucoinRestClientSpotApiAccount)restClient.SpotApi.Account).GetWebsocketToken(authenticated).ConfigureAwait(false);
+                WebCallResult<KucoinToken> tokenResult;
+                if (authenticated)
+                    tokenResult = await ((KucoinRestClientSpotApiAccount)restClient.SpotApi.Account).GetWebsocketTokenPrivateAsync().ConfigureAwait(false);
+                else
+                    tokenResult = await ((KucoinRestClientSpotApiAccount)restClient.SpotApi.Account).GetWebsocketTokenPublicAsync().ConfigureAwait(false);
                 if (!tokenResult)
                     return tokenResult.As<string?>(null);
 
diff --git a/Kucoin.Net/Enums/VipLevel.cs b/Kucoin.Net/Enums/VipLevel.cs
new file mode 100644
index 00000000..e8045933
--- /dev/null
+++ b/Kucoin.Net/Enums/VipLevel.cs
@@ -0,0 +1,65 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Kucoin.Net.Enums
+{
+    /// <summary>
+    /// Account VIP level
+    /// </summary>
+    public enum VipLevel
+    {
+        /// <summary>
+        /// Level 0
+        /// </summary>
+        Vip0,
+        /// <summary>
+        /// Level 1
+        /// </summary>
+        Vip1,
+        /// <summary>
+        /// Level 2
+        /// </summary>
+        Vip2,
+        /// <summary>
+        /// Level 3
+        /// </summary>
+        Vip3,
+        /// <summary>
+        /// Level 4
+        /// </summary>
+        Vip4,
+        /// <summary>
+        /// Level 5
+        /// </summary>
+        Vip5,
+        /// <summary>
+        /// Level 6
+        /// </summary>
+        Vip6,
+        /// <summary>
+        /// Level 7
+        /// </summary>
+        Vip7,
+        /// <summary>
+        /// Level 8
+        /// </summary>
+        Vip8,
+        /// <summary>
+        /// Level 9
+        /// </summary>
+        Vip9,
+        /// <summary>
+        /// Level 10
+        /// </summary>
+        Vip10,
+        /// <summary>
+        /// Level 11
+        /// </summary>
+        Vip11,
+        /// <summary>
+        /// Level 12
+        /// </summary>
+        Vip12
+    }
+}
diff --git a/Kucoin.Net/Interfaces/Clients/SpotApi/IKucoinRestClientSpotApiAccount.cs b/Kucoin.Net/Interfaces/Clients/SpotApi/IKucoinRestClientSpotApiAccount.cs
index 88a5e1cc..bc11ed52 100644
--- a/Kucoin.Net/Interfaces/Clients/SpotApi/IKucoinRestClientSpotApiAccount.cs
+++ b/Kucoin.Net/Interfaces/Clients/SpotApi/IKucoinRestClientSpotApiAccount.cs
@@ -263,23 +263,7 @@ Task<WebCallResult<KucoinInnerTransfer>> UniversalTransferAsync(
         /// <param name="withdrawalId">The id of the withdrawal to cancel</param>
         /// <param name="ct">Cancellation token</param>
         /// <returns>Null</returns>
-        Task<WebCallResult<object>> CancelWithdrawalAsync(string withdrawalId, CancellationToken ct = default);
-
-        /// <summary>
-        /// Get cross margin risk limit
-        /// <para><a href="https://www.kucoin.com/docs/rest/funding/withdrawals/cancel-withdrawal" /></para>
-        /// </summary>
-        /// <param name="ct">Cancellation token</param>
-        /// <returns></returns>
-        Task<WebCallResult<IEnumerable<KucoinRiskLimitCrossMargin>>> GetRiskLimitCrossMarginAsync(CancellationToken ct = default);
-
-        /// <summary>
-        /// Get isolated margin risk limit
-        /// <para><a href="https://docs.kucoin.com/#query-the-cross-isolated-margin-risk-limit" /></para>
-        /// </summary>
-        /// <param name="ct">Cancellation token</param>
-        /// <returns></returns>
-        Task<WebCallResult<IEnumerable<KucoinRiskLimitIsolatedMargin>>> GetRiskLimitIsolatedMarginAsync(CancellationToken ct = default);
+        Task<WebCallResult> CancelWithdrawalAsync(string withdrawalId, CancellationToken ct = default);
 
         /// <summary>
         /// Get margin account info
diff --git a/Kucoin.Net/Interfaces/Clients/SpotApi/IKucoinRestClientSpotApiExchangeData.cs b/Kucoin.Net/Interfaces/Clients/SpotApi/IKucoinRestClientSpotApiExchangeData.cs
index 228076b9..7da93ac4 100644
--- a/Kucoin.Net/Interfaces/Clients/SpotApi/IKucoinRestClientSpotApiExchangeData.cs
+++ b/Kucoin.Net/Interfaces/Clients/SpotApi/IKucoinRestClientSpotApiExchangeData.cs
@@ -149,25 +149,6 @@ public interface IKucoinRestClientSpotApiExchangeData
         /// <returns></returns>
         Task<WebCallResult<KucoinIndexBase>> GetMarginMarkPriceAsync(string symbol, CancellationToken ct = default);
 
-        /// <summary>
-        /// Get lending market data
-        /// <para><a href="https://docs.kucoin.com/#lending-market-data" /></para>
-        /// </summary>
-        /// <param name="asset">Asset</param>
-        /// <param name="term">Filter by term</param>
-        /// <param name="ct">Cancellation token</param>
-        /// <returns></returns>
-        Task<WebCallResult<IEnumerable<KucoinLendingMarketEntry>>> GetLendMarketDataAsync(string asset, int? term = null, CancellationToken ct = default);
-
-        /// <summary>
-        /// Get the last 300 fills for borrow/lending orders
-        /// <para><a href="https://docs.kucoin.com/#margin-trade-data" /></para>
-        /// </summary>
-        /// <param name="asset">The asset</param>
-        /// <param name="ct">Cancellation token</param>
-        /// <returns></returns>
-        Task<WebCallResult<IEnumerable<KucoinBorrowOrderDetails>>> GetMarginTradeHistoryAsync(string asset, CancellationToken ct = default);
-
         /// <summary>
         /// Get Margin Trading Pair ConfigurationAsync
         /// <para><a href="https://www.kucoin.com/docs/rest/margin-trading/isolated-margin/get-isolated-margin-symbols-configuration" /></para>
diff --git a/Kucoin.Net/Interfaces/Clients/SpotApi/IKucoinRestClientSpotApiTrading.cs b/Kucoin.Net/Interfaces/Clients/SpotApi/IKucoinRestClientSpotApiTrading.cs
index f118ba41..ff5426b9 100644
--- a/Kucoin.Net/Interfaces/Clients/SpotApi/IKucoinRestClientSpotApiTrading.cs
+++ b/Kucoin.Net/Interfaces/Clients/SpotApi/IKucoinRestClientSpotApiTrading.cs
@@ -263,20 +263,6 @@ Task<WebCallResult<KucoinNewMarginOrder>> PlaceTestMarginOrderAsync(
         /// <returns>Order info</returns>
         Task<WebCallResult<KucoinOrder>> GetOrderAsync(string orderId, CancellationToken ct = default);
 
-        /// <summary>
-        /// Gets a list of historical orders
-        /// <para><a href="https://docs.kucoin.com/#get-v1-historical-orders-list" /></para>
-        /// </summary>
-        /// <param name="symbol">Filter list by symbol</param>
-        /// <param name="side">Filter list by order side</param>
-        /// <param name="startTime">Filter list by start time</param>
-        /// <param name="endTime">Filter list by end time</param>
-        /// <param name="currentPage">The page to retrieve</param>
-        /// <param name="pageSize">The amount of results per page</param>
-        /// <param name="ct">Cancellation token</param>
-        /// <returns>List of historical orders</returns>
-        Task<WebCallResult<KucoinPaginated<KucoinHistoricalOrder>>> GetHistoricalOrdersAsync(string? symbol = null, OrderSide? side = null, DateTime? startTime = null, DateTime? endTime = null, int? currentPage = null, int? pageSize = null, CancellationToken ct = default);
-
         /// <summary>
         /// Gets a list of fills
         /// <para><a href="https://www.kucoin.com/docs/rest/spot-trading/fills/get-filled-list" /></para>
diff --git a/Kucoin.Net/Kucoin.Net.csproj b/Kucoin.Net/Kucoin.Net.csproj
index 4a20033a..68d8f385 100644
--- a/Kucoin.Net/Kucoin.Net.csproj
+++ b/Kucoin.Net/Kucoin.Net.csproj
@@ -53,6 +53,6 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="CryptoExchange.Net" Version="7.2.0" />
+    <PackageReference Include="CryptoExchange.Net" Version="7.3.0" />
   </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/Kucoin.Net/Kucoin.Net.xml b/Kucoin.Net/Kucoin.Net.xml
index 6b41cba2..40be4a02 100644
--- a/Kucoin.Net/Kucoin.Net.xml
+++ b/Kucoin.Net/Kucoin.Net.xml
@@ -358,6 +358,9 @@
             <param name="quoteAsset"></param>
             <returns></returns>
         </member>
+        <member name="M:Kucoin.Net.Clients.SpotApi.KucoinRestClientSpotApi.ParseRateLimitResponse(System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.Collections.Generic.IEnumerable{System.String}}},CryptoExchange.Net.Interfaces.IMessageAccessor)">
+            <inheritdoc />
+        </member>
         <member name="M:Kucoin.Net.Clients.SpotApi.KucoinRestClientSpotApi.ParseErrorResponse(System.Int32,System.Collections.Generic.IEnumerable{System.Collections.Generic.KeyValuePair{System.String,System.Collections.Generic.IEnumerable{System.String}}},CryptoExchange.Net.Interfaces.IMessageAccessor)">
             <inheritdoc />
         </member>
@@ -445,12 +448,6 @@
         <member name="M:Kucoin.Net.Clients.SpotApi.KucoinRestClientSpotApiAccount.GetCrossMarginAccountsAsync(System.String,System.Threading.CancellationToken)">
             <inheritdoc />
         </member>
-        <member name="M:Kucoin.Net.Clients.SpotApi.KucoinRestClientSpotApiAccount.GetRiskLimitCrossMarginAsync(System.Threading.CancellationToken)">
-            <inheritdoc />
-        </member>
-        <member name="M:Kucoin.Net.Clients.SpotApi.KucoinRestClientSpotApiAccount.GetRiskLimitIsolatedMarginAsync(System.Threading.CancellationToken)">
-            <inheritdoc />
-        </member>
         <member name="M:Kucoin.Net.Clients.SpotApi.KucoinRestClientSpotApiAccount.GetIsolatedMarginAccountsAsync(System.Threading.CancellationToken)">
             <inheritdoc />
         </member>
@@ -505,12 +502,6 @@
         <member name="M:Kucoin.Net.Clients.SpotApi.KucoinRestClientSpotApiExchangeData.GetMarginConfigurationAsync(System.Threading.CancellationToken)">
             <inheritdoc />
         </member>
-        <member name="M:Kucoin.Net.Clients.SpotApi.KucoinRestClientSpotApiExchangeData.GetLendMarketDataAsync(System.String,System.Nullable{System.Int32},System.Threading.CancellationToken)">
-            <inheritdoc />
-        </member>
-        <member name="M:Kucoin.Net.Clients.SpotApi.KucoinRestClientSpotApiExchangeData.GetMarginTradeHistoryAsync(System.String,System.Threading.CancellationToken)">
-            <inheritdoc />
-        </member>
         <member name="M:Kucoin.Net.Clients.SpotApi.KucoinRestClientSpotApiExchangeData.GetMarginTradingPairConfigurationAsync(System.Threading.CancellationToken)">
             <inheritdoc />
         </member>
@@ -565,9 +556,6 @@
         <member name="M:Kucoin.Net.Clients.SpotApi.KucoinRestClientSpotApiTrading.GetOrderAsync(System.String,System.Threading.CancellationToken)">
             <inheritdoc />
         </member>
-        <member name="M:Kucoin.Net.Clients.SpotApi.KucoinRestClientSpotApiTrading.GetHistoricalOrdersAsync(System.String,System.Nullable{Kucoin.Net.Enums.OrderSide},System.Nullable{System.DateTime},System.Nullable{System.DateTime},System.Nullable{System.Int32},System.Nullable{System.Int32},System.Threading.CancellationToken)">
-            <inheritdoc />
-        </member>
         <member name="M:Kucoin.Net.Clients.SpotApi.KucoinRestClientSpotApiTrading.GetUserTradesAsync(System.String,System.Nullable{Kucoin.Net.Enums.OrderSide},System.Nullable{Kucoin.Net.Enums.OrderType},System.Nullable{System.DateTime},System.Nullable{System.DateTime},System.String,System.Nullable{Kucoin.Net.Enums.TradeType},System.Nullable{System.Int32},System.Nullable{System.Int32},System.Threading.CancellationToken)">
             <inheritdoc />
         </member>
@@ -1859,6 +1847,76 @@
             Sub to parent
             </summary>
         </member>
+        <member name="T:Kucoin.Net.Enums.VipLevel">
+            <summary>
+            Account VIP level
+            </summary>
+        </member>
+        <member name="F:Kucoin.Net.Enums.VipLevel.Vip0">
+            <summary>
+            Level 0
+            </summary>
+        </member>
+        <member name="F:Kucoin.Net.Enums.VipLevel.Vip1">
+            <summary>
+            Level 1
+            </summary>
+        </member>
+        <member name="F:Kucoin.Net.Enums.VipLevel.Vip2">
+            <summary>
+            Level 2
+            </summary>
+        </member>
+        <member name="F:Kucoin.Net.Enums.VipLevel.Vip3">
+            <summary>
+            Level 3
+            </summary>
+        </member>
+        <member name="F:Kucoin.Net.Enums.VipLevel.Vip4">
+            <summary>
+            Level 4
+            </summary>
+        </member>
+        <member name="F:Kucoin.Net.Enums.VipLevel.Vip5">
+            <summary>
+            Level 5
+            </summary>
+        </member>
+        <member name="F:Kucoin.Net.Enums.VipLevel.Vip6">
+            <summary>
+            Level 6
+            </summary>
+        </member>
+        <member name="F:Kucoin.Net.Enums.VipLevel.Vip7">
+            <summary>
+            Level 7
+            </summary>
+        </member>
+        <member name="F:Kucoin.Net.Enums.VipLevel.Vip8">
+            <summary>
+            Level 8
+            </summary>
+        </member>
+        <member name="F:Kucoin.Net.Enums.VipLevel.Vip9">
+            <summary>
+            Level 9
+            </summary>
+        </member>
+        <member name="F:Kucoin.Net.Enums.VipLevel.Vip10">
+            <summary>
+            Level 10
+            </summary>
+        </member>
+        <member name="F:Kucoin.Net.Enums.VipLevel.Vip11">
+            <summary>
+            Level 11
+            </summary>
+        </member>
+        <member name="F:Kucoin.Net.Enums.VipLevel.Vip12">
+            <summary>
+            Level 12
+            </summary>
+        </member>
         <member name="T:Kucoin.Net.Enums.WithdrawalStatus">
             <summary>
             Status of a withdrawal
@@ -2857,22 +2915,6 @@
             <param name="ct">Cancellation token</param>
             <returns>Null</returns>
         </member>
-        <member name="M:Kucoin.Net.Interfaces.Clients.SpotApi.IKucoinRestClientSpotApiAccount.GetRiskLimitCrossMarginAsync(System.Threading.CancellationToken)">
-            <summary>
-            Get cross margin risk limit
-            <para><a href="https://www.kucoin.com/docs/rest/funding/withdrawals/cancel-withdrawal" /></para>
-            </summary>
-            <param name="ct">Cancellation token</param>
-            <returns></returns>
-        </member>
-        <member name="M:Kucoin.Net.Interfaces.Clients.SpotApi.IKucoinRestClientSpotApiAccount.GetRiskLimitIsolatedMarginAsync(System.Threading.CancellationToken)">
-            <summary>
-            Get isolated margin risk limit
-            <para><a href="https://docs.kucoin.com/#query-the-cross-isolated-margin-risk-limit" /></para>
-            </summary>
-            <param name="ct">Cancellation token</param>
-            <returns></returns>
-        </member>
         <member name="M:Kucoin.Net.Interfaces.Clients.SpotApi.IKucoinRestClientSpotApiAccount.GetMarginAccountAsync(System.Threading.CancellationToken)">
             <summary>
             Get margin account info
@@ -3047,25 +3089,6 @@
             <param name="ct">Cancellation token</param>
             <returns></returns>
         </member>
-        <member name="M:Kucoin.Net.Interfaces.Clients.SpotApi.IKucoinRestClientSpotApiExchangeData.GetLendMarketDataAsync(System.String,System.Nullable{System.Int32},System.Threading.CancellationToken)">
-            <summary>
-            Get lending market data
-            <para><a href="https://docs.kucoin.com/#lending-market-data" /></para>
-            </summary>
-            <param name="asset">Asset</param>
-            <param name="term">Filter by term</param>
-            <param name="ct">Cancellation token</param>
-            <returns></returns>
-        </member>
-        <member name="M:Kucoin.Net.Interfaces.Clients.SpotApi.IKucoinRestClientSpotApiExchangeData.GetMarginTradeHistoryAsync(System.String,System.Threading.CancellationToken)">
-            <summary>
-            Get the last 300 fills for borrow/lending orders
-            <para><a href="https://docs.kucoin.com/#margin-trade-data" /></para>
-            </summary>
-            <param name="asset">The asset</param>
-            <param name="ct">Cancellation token</param>
-            <returns></returns>
-        </member>
         <member name="M:Kucoin.Net.Interfaces.Clients.SpotApi.IKucoinRestClientSpotApiExchangeData.GetMarginTradingPairConfigurationAsync(System.Threading.CancellationToken)">
             <summary>
             Get Margin Trading Pair ConfigurationAsync
@@ -3306,20 +3329,6 @@
             <param name="ct">Cancellation token</param>
             <returns>Order info</returns>
         </member>
-        <member name="M:Kucoin.Net.Interfaces.Clients.SpotApi.IKucoinRestClientSpotApiTrading.GetHistoricalOrdersAsync(System.String,System.Nullable{Kucoin.Net.Enums.OrderSide},System.Nullable{System.DateTime},System.Nullable{System.DateTime},System.Nullable{System.Int32},System.Nullable{System.Int32},System.Threading.CancellationToken)">
-            <summary>
-            Gets a list of historical orders
-            <para><a href="https://docs.kucoin.com/#get-v1-historical-orders-list" /></para>
-            </summary>
-            <param name="symbol">Filter list by symbol</param>
-            <param name="side">Filter list by order side</param>
-            <param name="startTime">Filter list by start time</param>
-            <param name="endTime">Filter list by end time</param>
-            <param name="currentPage">The page to retrieve</param>
-            <param name="pageSize">The amount of results per page</param>
-            <param name="ct">Cancellation token</param>
-            <returns>List of historical orders</returns>
-        </member>
         <member name="M:Kucoin.Net.Interfaces.Clients.SpotApi.IKucoinRestClientSpotApiTrading.GetUserTradesAsync(System.String,System.Nullable{Kucoin.Net.Enums.OrderSide},System.Nullable{Kucoin.Net.Enums.OrderType},System.Nullable{System.DateTime},System.Nullable{System.DateTime},System.String,System.Nullable{Kucoin.Net.Enums.TradeType},System.Nullable{System.Int32},System.Nullable{System.Int32},System.Threading.CancellationToken)">
             <summary>
             Gets a list of fills
@@ -3944,6 +3953,42 @@
             <param name="futuresAddress"></param>
             <returns></returns>
         </member>
+        <member name="T:Kucoin.Net.KucoinExchange">
+            <summary>
+            Kucoin exchange information and configuration
+            </summary>
+        </member>
+        <member name="P:Kucoin.Net.KucoinExchange.ExchangeName">
+            <summary>
+            Exchange name
+            </summary>
+        </member>
+        <member name="P:Kucoin.Net.KucoinExchange.RateLimiter">
+            <summary>
+            Rate limiter configuration for the Kucoin API
+            </summary>
+        </member>
+        <member name="T:Kucoin.Net.KucoinRateLimiters">
+            <summary>
+            Rate limiter configuration for the Kucoin API
+            </summary>
+        </member>
+        <member name="P:Kucoin.Net.KucoinRateLimiters.VipLevel">
+            <summary>
+            The VIP level to use when calculating rate limits
+            </summary>
+        </member>
+        <member name="E:Kucoin.Net.KucoinRateLimiters.RateLimitTriggered">
+            <summary>
+            Event for when a rate limit is triggered
+            </summary>
+        </member>
+        <member name="M:Kucoin.Net.KucoinRateLimiters.Configure(Kucoin.Net.Enums.VipLevel)">
+            <summary>
+            Configure the rate limit with a different VIP level
+            </summary>
+            <param name="level"></param>
+        </member>
         <member name="T:Kucoin.Net.Objects.KucoinApiAddresses">
             <summary>
             Kucoin API addresses
diff --git a/Kucoin.Net/KucoinExchange.cs b/Kucoin.Net/KucoinExchange.cs
new file mode 100644
index 00000000..16fdcf18
--- /dev/null
+++ b/Kucoin.Net/KucoinExchange.cs
@@ -0,0 +1,135 @@
+using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.RateLimiting;
+using CryptoExchange.Net.RateLimiting.Filters;
+using CryptoExchange.Net.RateLimiting.Guards;
+using CryptoExchange.Net.RateLimiting.Interfaces;
+using Kucoin.Net.Enums;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Kucoin.Net
+{
+    /// <summary>
+    /// Kucoin exchange information and configuration
+    /// </summary>
+    public static class KucoinExchange
+    {
+        /// <summary>
+        /// Exchange name
+        /// </summary>
+        public static string ExchangeName => "Kucoin";
+
+        /// <summary>
+        /// Rate limiter configuration for the Kucoin API
+        /// </summary>
+        public static KucoinRateLimiters RateLimiter { get; } = new KucoinRateLimiters();
+    }
+
+    /// <summary>
+    /// Rate limiter configuration for the Kucoin API
+    /// </summary>
+    public class KucoinRateLimiters
+    {
+        private static readonly Dictionary<VipLevel, int> _spotLimits = new()
+        {
+            { VipLevel.Vip0, 4000 },
+            { VipLevel.Vip1, 6000 },
+            { VipLevel.Vip2, 8000 },
+            { VipLevel.Vip3, 10000 },
+            { VipLevel.Vip4, 13000 },
+            { VipLevel.Vip5, 16000 },
+            { VipLevel.Vip6, 20000 },
+            { VipLevel.Vip7, 23000 },
+            { VipLevel.Vip8, 26000 },
+            { VipLevel.Vip9, 30000 },
+            { VipLevel.Vip10, 33000 },
+            { VipLevel.Vip11, 36000 },
+            { VipLevel.Vip12, 40000 },
+        };
+
+        private static readonly Dictionary<VipLevel, int> _futuresLimits = new()
+        {
+            { VipLevel.Vip0, 2000 },
+            { VipLevel.Vip1, 2000 },
+            { VipLevel.Vip2, 4000 },
+            { VipLevel.Vip3, 5000 },
+            { VipLevel.Vip4, 6000 },
+            { VipLevel.Vip5, 7000 },
+            { VipLevel.Vip6, 8000 },
+            { VipLevel.Vip7, 10000 },
+            { VipLevel.Vip8, 12000 },
+            { VipLevel.Vip9, 14000 },
+            { VipLevel.Vip10, 16000 },
+            { VipLevel.Vip11, 18000 },
+            { VipLevel.Vip12, 20000 },
+        };
+
+        private static readonly Dictionary<VipLevel, int> _managementLimits = new()
+        {
+            { VipLevel.Vip0, 2000 },
+            { VipLevel.Vip1, 2000 },
+            { VipLevel.Vip2, 4000 },
+            { VipLevel.Vip3, 5000 },
+            { VipLevel.Vip4, 6000 },
+            { VipLevel.Vip5, 7000 },
+            { VipLevel.Vip6, 8000 },
+            { VipLevel.Vip7, 10000 },
+            { VipLevel.Vip8, 12000 },
+            { VipLevel.Vip9, 14000 },
+            { VipLevel.Vip10, 16000 },
+            { VipLevel.Vip11, 18000 },
+            { VipLevel.Vip12, 20000 },
+        };
+
+        internal IRateLimitGate SpotRest { get; private set; }
+        internal IRateLimitGate FuturesRest { get; private set; }
+        internal IRateLimitGate ManagementRest { get; private set; }
+        internal IRateLimitGate PublicRest { get; private set; }
+        internal IRateLimitGate Socket { get; private set; }
+
+        /// <summary>
+        /// The VIP level to use when calculating rate limits
+        /// </summary>
+        public VipLevel VipLevel { get; private set; } = VipLevel.Vip0;
+
+        /// <summary>
+        /// Event for when a rate limit is triggered
+        /// </summary>
+        public event Action<RateLimitEvent> RateLimitTriggered;
+
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        internal KucoinRateLimiters()
+#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.
+        {
+            Initialize();
+        }
+
+        /// <summary>
+        /// Configure the rate limit with a different VIP level
+        /// </summary>
+        /// <param name="level"></param>
+        public void Configure(VipLevel level)
+        {
+            VipLevel = level;
+            Initialize();
+        }
+
+        private void Initialize()
+        {
+            SpotRest = new RateLimitGate("Spot Rest").AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, Array.Empty<IGuardFilter>(), _spotLimits[VipLevel], TimeSpan.FromSeconds(30), RateLimitWindowType.FixedAfterFirst)); // Might be fixed but from the first request timestamp instead of the the whole interval
+            FuturesRest = new RateLimitGate("Futures Rest").AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, Array.Empty<IGuardFilter>(), _futuresLimits[VipLevel], TimeSpan.FromSeconds(30), RateLimitWindowType.FixedAfterFirst)); // Might be fixed but from the first request timestamp instead of the the whole interval
+            ManagementRest = new RateLimitGate("Management Rest").AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, Array.Empty<IGuardFilter>(), _managementLimits[VipLevel], TimeSpan.FromSeconds(30), RateLimitWindowType.FixedAfterFirst)); // Might be fixed but from the first request timestamp instead of the the whole interval
+            PublicRest = new RateLimitGate("Public Rest").AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, Array.Empty<IGuardFilter>(), 2000, TimeSpan.FromSeconds(30), RateLimitWindowType.FixedAfterFirst)); // Might be fixed but from the first request timestamp instead of the the whole interval
+            Socket = new RateLimitGate("Socket")
+                    .AddGuard(new RateLimitGuard(RateLimitGuard.PerHost, new LimitItemTypeFilter(RateLimitItemType.Connection), 30, TimeSpan.FromMinutes(1), RateLimitWindowType.Fixed))
+                    .AddGuard(new RateLimitGuard(RateLimitGuard.PerEndpoint, new LimitItemTypeFilter(RateLimitItemType.Request), 100, TimeSpan.FromSeconds(10), RateLimitWindowType.Fixed));
+
+            SpotRest.RateLimitTriggered += (x) => RateLimitTriggered?.Invoke(x);
+            FuturesRest.RateLimitTriggered += (x) => RateLimitTriggered?.Invoke(x);
+            ManagementRest.RateLimitTriggered += (x) => RateLimitTriggered?.Invoke(x);
+            PublicRest.RateLimitTriggered += (x) => RateLimitTriggered?.Invoke(x);
+            Socket.RateLimitTriggered += (x) => RateLimitTriggered?.Invoke(x);
+        }
+    }
+}
diff --git a/Kucoin.Net/Objects/Internal/KucoinResult.cs b/Kucoin.Net/Objects/Internal/KucoinResult.cs
index c6545614..c56ae211 100644
--- a/Kucoin.Net/Objects/Internal/KucoinResult.cs
+++ b/Kucoin.Net/Objects/Internal/KucoinResult.cs
@@ -2,13 +2,16 @@
 
 namespace Kucoin.Net.Objects.Internal
 {
-    internal class KucoinResult<T>
+    internal class KucoinResult
     {
         [JsonProperty("code")]
         public int Code { get; set; }
         [JsonProperty("msg")]
         public string? Message { get; set; }
+    }
 
+    internal class KucoinResult<T> : KucoinResult
+    {
         public T Data { get; set; } = default!;
     }
 }
diff --git a/Kucoin.Net/Objects/Options/KucoinRestOptions.cs b/Kucoin.Net/Objects/Options/KucoinRestOptions.cs
index c5f14cb7..0caeef29 100644
--- a/Kucoin.Net/Objects/Options/KucoinRestOptions.cs
+++ b/Kucoin.Net/Objects/Options/KucoinRestOptions.cs
@@ -22,16 +22,7 @@ public class KucoinRestOptions : RestExchangeOptions<KucoinEnvironment, KucoinAp
         /// <summary>
         /// Spot API options
         /// </summary>
-        public KucoinRestApiOptions SpotOptions { get; private set; } = new KucoinRestApiOptions()
-        {
-            RateLimiters = new List<IRateLimiter>
-            {
-                     new RateLimiter()
-                        .AddPartialEndpointLimit("/api/v1/orders", 180, TimeSpan.FromSeconds(3), null, true, true)
-                        .AddApiKeyLimit(200, TimeSpan.FromSeconds(10), true, true)
-                        .AddTotalRateLimit(100, TimeSpan.FromSeconds(10))
-            }
-        };
+        public KucoinRestApiOptions SpotOptions { get; private set; } = new KucoinRestApiOptions();
 
         /// <summary>
         /// Futures API options
diff --git a/docs/index.html b/docs/index.html
index 44e352f3..dc8e90f8 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -83,6 +83,7 @@
           <ul class="nav flex-column">
             <li class="nav-item"><a class="nav-link" href="#idocs_installation">Installation</a></li>
             <li class="nav-item"><a class="nav-link" href="#idocs_apiaccess">API Access</a></li>
+            <li class="nav-item"><a class="nav-link" href="#idocs_ratelimit">Rate limiting</a></li>
           </ul>
         </li>
         <li class="nav-item"><a class="nav-link active" href="#idocs_examples">Examples</a>
@@ -181,6 +182,27 @@ <h2>API Access</h2>
 });
 var socketClient = new KucoinSocketClient();</code></pre>
 		  
+        </section>
+		<section id="idocs_ratelimit">
+          <h2>Rate limiting</h2>
+          
+		  <p>By default a rate limiter is enabled which makes sure the server rate limits aren't exceeded. For more info on what the rate limits for the Kucoin API are see the <a href="https://www.kucoin.com/docs/basic-info/request-rate-limit/rest-api" target="_blank">Spot API docs</a>. Currently client side rate limiting is only implemented for the Spot API. Note that rate limiting is only implemented to prevent going over the request rate limit, it does not apply for order limits.</p>
+		  <p>Whether client ratelimiting is enabled in the library and what the behaviour should be when the limit is reached can be controlled with the <code>RatelimiterEnabled</code> and <code>RateLimitingBehaviour</code> client options</p>
+		  <pre><code>services.AddKucoin(x =>
+    x.RatelimiterEnabled = true;
+    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
+}, x =>
+{
+    x.RatelimiterEnabled = true;
+    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
+});</code></pre>
+		  <p>To be notified of when a rate limit is hit the static <code>KucoinExchange.RateLimiter</code> exposes an event which triggers when a rate limit is reached</p>
+		  <pre><code>KucoinExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);
+
+// Output: Limit triggered: RateLimitEvent { ApiLimit = Public Rest, LimitDescription = Limit of 2000 per 00:00:30, RequestDefinition = GET api/v1/market/stats, Host = https://api.kucoin.com/, Current = 1995, RequestWeight = 15, Limit = 2000, TimePeriod = 00:00:30, DelayTime = 00:00:19.8111238, Behaviour = Wait }</code></pre>
+
+		  <p>Kucoin applies different rate limits based on the account VIP level. By default the rate limit is set to the most conservative <code>VIP0</code> tier. To change the rate limit tier call the <code>Configure</code> method</p>
+		  <pre><code>KucoinExchange.RateLimiter.Configure(Kucoin.Net.Enums.VipLevel.Vip5);</code></pre>
         </section>
         		
 		<hr class="divider">