CryptoManager.Net reference

Added LibraryHelpers.CreateHttpClientMessageHandle to standardize HttpMessageHandler creation
Added REST client option for selecting HTTP protocol version
Added REST client option for HTTP client keep alive interval
Added HttpVersion to WebCallResult responses
Updated request logic to default to using HTTP version 2.0 for dotnet core

CryptoExchange.Net.Protobuf/CryptoExchange.Net.Protobuf.csproj

@@ -6,9 +6,9 @@
     <PackageId>CryptoExchange.Net.Protobuf</PackageId>
     <Authors>JKorf</Authors>
     <Description>Protobuf support for CryptoExchange.Net</Description>
-    <PackageVersion>9.5.0</PackageVersion>
-    <AssemblyVersion>9.5.0</AssemblyVersion>
-    <FileVersion>9.5.0</FileVersion>
+    <PackageVersion>9.7.0</PackageVersion>
+    <AssemblyVersion>9.7.0</AssemblyVersion>
+    <FileVersion>9.7.0</FileVersion>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>CryptoExchange;CryptoExchange.Net</PackageTags>
     <RepositoryType>git</RepositoryType>
@@ -41,7 +41,7 @@
     <DocumentationFile>CryptoExchange.Net.Protobuf.xml</DocumentationFile>
   </PropertyGroup>
   <ItemGroup>
-    <PackageReference Include="CryptoExchange.Net" Version="9.5.0" />
+    <PackageReference Include="CryptoExchange.Net" Version="9.7.0" />
     <PackageReference Include="protobuf-net" Version="3.2.56" />
   </ItemGroup>
 </Project>

CryptoExchange.Net.Protobuf/README.md

@@ -5,6 +5,12 @@
 Protobuf support for CryptoExchange.Net.
 
 ## Release notes
+* Version 9.7.0 - 01 Sep 2025
+    * Updated CryptoExchange.Net version to 9.7.0, see https://github.com/JKorf/CryptoExchange.Net/releases/
+
+* Version 9.6.0 - 25 Aug 2025
+    * Updated CryptoExchange.Net version to 9.6.0
+
 * Version 9.5.0 - 19 Aug 2025
     * Updated CryptoExchange.Net version to 9.5.0
 

CryptoExchange.Net.UnitTests/CallResultTests.cs

@@ -5,6 +5,7 @@ using NUnit.Framework.Legacy;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Net;
 using System.Net.Http;
 using System.Text;
 using System.Threading.Tasks;
@@ -113,6 +114,7 @@ namespace CryptoExchange.Net.UnitTests
         {
             var result = new WebCallResult<TestObjectResult>(
                 System.Net.HttpStatusCode.OK,
+                HttpVersion.Version11,
                 new KeyValuePair<string, string[]>[0],
                 TimeSpan.FromSeconds(1),
                 null,
@@ -143,6 +145,7 @@ namespace CryptoExchange.Net.UnitTests
         {
             var result = new WebCallResult<TestObjectResult>(
                 System.Net.HttpStatusCode.OK,
+                HttpVersion.Version11,
                 new KeyValuePair<string, string[]>[0],
                 TimeSpan.FromSeconds(1),
                 null,

CryptoExchange.Net.UnitTests/TestImplementations/Sockets/TestSubscription.cs

@@ -28,7 +28,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
             return new CallResult(null);
         }
 
-        public override Query GetSubQuery(SocketConnection connection) => new TestQuery("sub", new object(), false, 1);
-        public override Query GetUnsubQuery() => new TestQuery("unsub", new object(), false, 1);
+        protected override Query GetSubQuery(SocketConnection connection) => new TestQuery("sub", new object(), false, 1);
+        protected override Query GetUnsubQuery(SocketConnection connection) => new TestQuery("unsub", new object(), false, 1);
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/Sockets/TestSubscriptionWithResponseCheck.cs

@@ -28,7 +28,7 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations.Sockets
             return new CallResult(null);
         }
 
-        public override Query GetSubQuery(SocketConnection connection) => new TestChannelQuery(_channel, "subscribe", false, 1);
-        public override Query GetUnsubQuery() => new TestChannelQuery(_channel, "unsubscribe", false, 1);
+        protected override Query GetSubQuery(SocketConnection connection) => new TestChannelQuery(_channel, "subscribe", false, 1);
+        protected override Query GetUnsubQuery(SocketConnection connection) => new TestChannelQuery(_channel, "unsubscribe", false, 1);
     }
 }

CryptoExchange.Net.UnitTests/TestImplementations/TestRestClient.cs

@@ -60,8 +60,8 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             request.Setup(c => c.GetHeaders()).Returns(() => headers.ToArray());
 
             var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, Uri, int>((method, uri, id) => 
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) => 
                 { 
                     request.Setup(a => a.Uri).Returns(uri);
                     request.Setup(a => a.Method).Returns(method); 
@@ -69,8 +69,8 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
                 .Returns(request.Object);
 
             factory = Mock.Get(Api2.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, Uri, int>((method, uri, id) =>
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) =>
                 {
                     request.Setup(a => a.Uri).Returns(uri);
                     request.Setup(a => a.Method).Returns(method);
@@ -90,12 +90,12 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             request.Setup(c => c.GetResponseAsync(It.IsAny<CancellationToken>())).Throws(we);
 
             var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
                 .Returns(request.Object);
 
 
             factory = Mock.Get(Api2.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
                 .Returns(request.Object);
         }
 
@@ -118,13 +118,13 @@ namespace CryptoExchange.Net.UnitTests.TestImplementations
             request.Setup(c => c.GetHeaders()).Returns(headers.ToArray());
 
             var factory = Mock.Get(Api1.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, Uri, int>((method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
                 .Returns(request.Object);
 
             factory = Mock.Get(Api2.RequestFactory);
-            factory.Setup(c => c.Create(It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
-                .Callback<HttpMethod, Uri, int>((method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
+            factory.Setup(c => c.Create(It.IsAny<Version>(), It.IsAny<HttpMethod>(), It.IsAny<Uri>(), It.IsAny<int>()))
+                .Callback<Version, HttpMethod, Uri, int>((version, method, uri, id) => request.Setup(a => a.Uri).Returns(uri))
                 .Returns(request.Object);
         }
     }

CryptoExchange.Net/Clients/RestApiClient.cs

@@ -106,7 +106,7 @@ namespace CryptoExchange.Net.Clients
                   options,
                   apiOptions)
         {
-            RequestFactory.Configure(options.Proxy, options.RequestTimeout, httpClient);
+            RequestFactory.Configure(options, httpClient);
         }
 
         /// <summary>
@@ -239,7 +239,7 @@ namespace CryptoExchange.Net.Clients
                     additionalHeaders);
                 _logger.RestApiSendRequest(request.RequestId, definition, request.Content, string.IsNullOrEmpty(request.Uri.Query) ? "-" : request.Uri.Query, string.Join(", ", request.GetHeaders().Select(h => h.Key + $"=[{string.Join(",", h.Value)}]")));
                 TotalRequestsMade++;
-                var result = await GetResponseAsync<T>(request, definition.RateLimitGate, cancellationToken).ConfigureAwait(false);
+                var result = await GetResponseAsync<T>(definition, request, definition.RateLimitGate, cancellationToken).ConfigureAwait(false);
                 if (result.Error is not CancellationRequestedError)
                 {
                     var originalData = OutputOriginalData ? result.OriginalData : "[Data only available when OutputOriginal = true]";
@@ -388,7 +388,7 @@ namespace CryptoExchange.Net.Clients
                 queryString = $"?{queryString}";
 
             var uri = new Uri(baseAddress.AppendPath(definition.Path) + queryString);
-            var request = RequestFactory.Create(definition.Method, uri, requestId);
+            var request = RequestFactory.Create(ClientOptions.HttpVersion, definition.Method, uri, requestId);
             request.Accept = Constants.JsonContentHeader;
 
             foreach (var header in requestConfiguration.Headers)
@@ -424,11 +424,13 @@ namespace CryptoExchange.Net.Clients
         /// <summary>
         /// Executes the request and returns the result deserialized into the type parameter class
         /// </summary>
+        /// <param name="requestDefinition">The request definition</param>
         /// <param name="request">The request object to execute</param>
         /// <param name="gate">The ratelimit gate used</param>
         /// <param name="cancellationToken">Cancellation token</param>
         /// <returns></returns>
         protected virtual async Task<WebCallResult<T>> GetResponseAsync<T>(
+            RequestDefinition requestDefinition,
             IRequest request,
             IRateLimitGate? gate,
             CancellationToken cancellationToken)
@@ -441,14 +443,11 @@ namespace CryptoExchange.Net.Clients
             {
                 response = await request.GetResponseAsync(cancellationToken).ConfigureAwait(false);
                 sw.Stop();
-                var statusCode = response.StatusCode;
-                var headers = response.ResponseHeaders;
-                var responseLength = response.ContentLength;
                 responseStream = await response.GetResponseStreamAsync().ConfigureAwait(false);
                 var outputOriginalData = ApiOptions.OutputOriginalData ?? ClientOptions.OutputOriginalData;
 
                 accessor = CreateAccessor();
-                if (!response.IsSuccessStatusCode)
+                if (!response.IsSuccessStatusCode && !requestDefinition.TryParseOnNonSuccess)
                 {
                     // Error response
                     var readResult = await accessor.Read(responseStream, true).ConfigureAwait(false);
@@ -470,27 +469,25 @@ namespace CryptoExchange.Net.Clients
                         error = ParseErrorResponse((int)response.StatusCode, response.ResponseHeaders, accessor, readResult.Error?.Exception);
                     }
 
-#pragma warning disable CS0618 // Type or member is obsolete
                     if (error.Code == null || error.Code == 0)
                         error.Code = (int)response.StatusCode;
-#pragma warning restore CS0618 // Type or member is obsolete
 
-                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error!);
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error!);
                 }
 
                 var valid = await accessor.Read(responseStream, outputOriginalData).ConfigureAwait(false);
                 if (typeof(T) == typeof(object))
                     // Success status code and expected empty response, assume it's correct
-                    return new WebCallResult<T>(statusCode, headers, sw.Elapsed, 0, accessor.OriginalDataAvailable ? accessor.GetOriginalString() : "[Data only available when OutputOriginal = true in client options]", request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, null);
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, 0, accessor.OriginalDataAvailable ? accessor.GetOriginalString() : "[Data only available when OutputOriginal = true in client options]", request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, null);
 
                 if (!valid)
                 {
                     // Invalid json
-                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, valid.Error);
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, valid.Error);
                 }
 
                 // Json response received
-                var parsedError = TryParseError(response.ResponseHeaders, accessor);
+                var parsedError = TryParseError(requestDefinition, response.ResponseHeaders, accessor);
                 if (parsedError != null)
                 {
                     if (parsedError is ServerRateLimitError rateError)
@@ -503,33 +500,55 @@ namespace CryptoExchange.Net.Clients
                     }
 
                     // Success status code, but TryParseError determined it was an error response
-                    return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, parsedError);
+                    return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, parsedError);
                 }
 
                 var deserializeResult = accessor.Deserialize<T>();
-                return new WebCallResult<T>(response.StatusCode, response.ResponseHeaders, sw.Elapsed, responseLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, deserializeResult.Data, deserializeResult.Error);
+                return new WebCallResult<T>(response.StatusCode, response.HttpVersion, response.ResponseHeaders, sw.Elapsed, response.ContentLength, OutputOriginalData ? accessor.GetOriginalString() : null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, deserializeResult.Data, deserializeResult.Error);
             }
             catch (HttpRequestException requestException)
             {
                 // Request exception, can't reach server for instance
                 var error = new WebError(requestException.Message, requestException);
-                return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
+                return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
             }
             catch (OperationCanceledException canceledException)
             {
                 if (cancellationToken != default && canceledException.CancellationToken == cancellationToken)
                 {
                     // Cancellation token canceled by caller
-                    return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, new CancellationRequestedError(canceledException));
+                    return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, new CancellationRequestedError(canceledException));
                 }
                 else
                 {
                     // Request timed out
                     var error = new WebError($"Request timed out", exception: canceledException);
                     error.ErrorType = ErrorType.Timeout;
-                    return new WebCallResult<T>(null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
+                    return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
                 }
             }
+            catch (ArgumentException argumentException)
+            {
+                if (argumentException.Message.StartsWith("Only HTTP/"))
+                {
+                    // Unsupported HTTP version error .net framework
+                    var error = ArgumentError.Invalid(nameof(RestExchangeOptions.HttpVersion), $"Invalid HTTP version {request.HttpVersion}: " + argumentException.Message);
+                    return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
+                }
+
+                throw;
+            }
+            catch (NotSupportedException notSupportedException)
+            {
+                if (notSupportedException.Message.StartsWith("Request version value must be one of"))
+                {
+                    // Unsupported HTTP version error dotnet code
+                    var error = ArgumentError.Invalid(nameof(RestExchangeOptions.HttpVersion), $"Invalid HTTP version {request.HttpVersion}: " + notSupportedException.Message);
+                    return new WebCallResult<T>(null, null, null, sw.Elapsed, null, null, request.RequestId, request.Uri.ToString(), request.Content, request.Method, request.GetHeaders(), ResultDataSource.Server, default, error);
+                }
+
+                throw;
+            }
             finally
             {
                 accessor?.Clear();
@@ -543,10 +562,11 @@ namespace CryptoExchange.Net.Clients
         /// This method will be called for each response to be able to check if the response is an error or not.
         /// If the response is an error this method should return the parsed error, else it should return null
         /// </summary>
+        /// <param name="requestDefinition">Request definition</param>
         /// <param name="accessor">Data accessor</param>
         /// <param name="responseHeaders">The response headers</param>
         /// <returns>Null if not an error, Error otherwise</returns>
-        protected virtual Error? TryParseError(KeyValuePair<string, string[]>[] responseHeaders, IMessageAccessor accessor) => null;
+        protected virtual Error? TryParseError(RequestDefinition requestDefinition, KeyValuePair<string, string[]>[] responseHeaders, IMessageAccessor accessor) => null;
 
         /// <summary>
         /// Can be used to indicate that a request should be retried. Defaults to false. Make sure to retry a max number of times (based on the the tries parameter) or the request will retry forever.
@@ -673,21 +693,21 @@ namespace CryptoExchange.Net.Clients
         {
             base.SetOptions(options);
 
-            RequestFactory.UpdateSettings(options.Proxy, options.RequestTimeout ?? ClientOptions.RequestTimeout);
+            RequestFactory.UpdateSettings(options.Proxy, options.RequestTimeout ?? ClientOptions.RequestTimeout, ClientOptions.HttpKeepAliveInterval);
         }
 
         internal async Task<WebCallResult<bool>> SyncTimeAsync()
         {
             var timeSyncParams = GetTimeSyncInfo();
             if (timeSyncParams == null)
-                return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
+                return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
 
             if (await timeSyncParams.TimeSyncState.Semaphore.WaitAsync(0).ConfigureAwait(false))
             {
                 if (!timeSyncParams.SyncTime || DateTime.UtcNow - timeSyncParams.TimeSyncState.LastSyncTime < timeSyncParams.RecalculationInterval)
                 {
                     timeSyncParams.TimeSyncState.Semaphore.Release();
-                    return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
+                    return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
                 }
 
                 var localTime = DateTime.UtcNow;
@@ -716,7 +736,7 @@ namespace CryptoExchange.Net.Clients
                 timeSyncParams.TimeSyncState.Semaphore.Release();
             }
 
-            return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
+            return new WebCallResult<bool>(null, null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, true, null);
         }
 
         private bool ShouldCache(RequestDefinition definition)

CryptoExchange.Net/Clients/SocketApiClient.cs

@@ -270,7 +270,7 @@ namespace CryptoExchange.Net.Clients
             }
 
             var waitEvent = new AsyncResetEvent(false);
-            var subQuery = subscription.GetSubQuery(socketConnection);
+            var subQuery = subscription.CreateSubscriptionQuery(socketConnection);
             if (subQuery != null)
             {
                 // Send the request and wait for answer

CryptoExchange.Net/CryptoExchange.Net.csproj

@@ -6,9 +6,9 @@
     <PackageId>CryptoExchange.Net</PackageId>
     <Authors>JKorf</Authors>
     <Description>CryptoExchange.Net is a base library which is used to implement different cryptocurrency (exchange) API's. It provides a standardized way of implementing different API's, which results in a very similar experience for users of the API implementations.</Description>
-    <PackageVersion>9.5.0</PackageVersion>
-    <AssemblyVersion>9.5.0</AssemblyVersion>
-    <FileVersion>9.5.0</FileVersion>
+    <PackageVersion>9.7.0</PackageVersion>
+    <AssemblyVersion>9.7.0</AssemblyVersion>
+    <FileVersion>9.7.0</FileVersion>
     <PackageRequireLicenseAcceptance>false</PackageRequireLicenseAcceptance>
     <PackageTags>OKX;OKX.Net;Mexc;Mexc.Net;Kucoin;Kucoin.Net;Kraken;Kraken.Net;Huobi;Huobi.Net;CoinEx;CoinEx.Net;Bybit;Bybit.Net;Bitget;Bitget.Net;Bitfinex;Bitfinex.Net;Binance;Binance.Net;CryptoCurrency;CryptoCurrency Exchange;CryptoExchange.Net</PackageTags>
     <RepositoryType>git</RepositoryType>

CryptoExchange.Net/Interfaces/IRequest.cs

@@ -28,6 +28,10 @@ namespace CryptoExchange.Net.Interfaces
         /// </summary>
         Uri Uri { get; }
         /// <summary>
+        /// HTTP protocol version
+        /// </summary>
+        Version HttpVersion { get; }
+        /// <summary>
         /// internal request id for tracing
         /// </summary>
         int RequestId { get; }

CryptoExchange.Net/Interfaces/IRequestFactory.cs

@@ -1,4 +1,5 @@
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
 using System;
 using System.Net.Http;
 
@@ -12,25 +13,21 @@ namespace CryptoExchange.Net.Interfaces
         /// <summary>
         /// Create a request for an uri
         /// </summary>
-        /// <param name="method"></param>
-        /// <param name="uri"></param>
-        /// <param name="requestId"></param>
-        /// <returns></returns>
-        IRequest Create(HttpMethod method, Uri uri, int requestId);
+        IRequest Create(Version httpRequestVersion, HttpMethod method, Uri uri, int requestId);
 
         /// <summary>
         /// Configure the requests created by this factory
         /// </summary>
-        /// <param name="requestTimeout">Request timeout to use</param>
+        /// <param name="options">Rest client options</param>
         /// <param name="httpClient">Optional shared http client instance</param>
-        /// <param name="proxy">Optional proxy to use when no http client is provided</param>
-        void Configure(ApiProxy? proxy, TimeSpan requestTimeout, HttpClient? httpClient = null);
+        void Configure(RestExchangeOptions options, HttpClient? httpClient = null);
 
         /// <summary>
         /// Update settings
         /// </summary>
         /// <param name="proxy">Proxy to use</param>
         /// <param name="requestTimeout">Request timeout to use</param>
-        void UpdateSettings(ApiProxy? proxy, TimeSpan requestTimeout);
+        /// <param name="httpKeepAliveInterval">Http client keep alive interval</param>
+        void UpdateSettings(ApiProxy? proxy, TimeSpan requestTimeout, TimeSpan? httpKeepAliveInterval);
     }
 }

CryptoExchange.Net/Interfaces/IResponse.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Net;
 using System.Threading.Tasks;
@@ -15,6 +16,11 @@ namespace CryptoExchange.Net.Interfaces
         /// </summary>
         HttpStatusCode StatusCode { get; }
 
+        /// <summary>
+        /// Http protocol version
+        /// </summary>
+        Version HttpVersion { get; }
+
         /// <summary>
         /// Whether the status code indicates a success status
         /// </summary>

CryptoExchange.Net/LibraryHelpers.cs

@@ -1,5 +1,8 @@
-using System;
+using CryptoExchange.Net.Objects;
+using System;
 using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
 using System.Text;
 
 namespace CryptoExchange.Net
@@ -43,5 +46,58 @@ namespace CryptoExchange.Net
 
             return clientOrderId;
         }
+
+        /// <summary>
+        /// Create a new HttpMessageHandler instance
+        /// </summary>  
+        public static HttpMessageHandler CreateHttpClientMessageHandler(ApiProxy? proxy, TimeSpan? keepAliveInterval)
+        {
+#if NET5_0_OR_GREATER
+            var socketHandler = new SocketsHttpHandler();
+            try
+            {
+                if (keepAliveInterval != null && keepAliveInterval != TimeSpan.Zero)
+                {
+                    socketHandler.KeepAlivePingPolicy = HttpKeepAlivePingPolicy.Always;
+                    socketHandler.KeepAlivePingDelay = keepAliveInterval.Value;
+                    socketHandler.KeepAlivePingTimeout = TimeSpan.FromSeconds(10);
+                }
+
+                socketHandler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
+                socketHandler.DefaultProxyCredentials = CredentialCache.DefaultCredentials;
+            }
+            catch (PlatformNotSupportedException) { }
+            catch (NotImplementedException) { } // Mono runtime throws NotImplementedException
+
+            if (proxy != null)
+            {
+                socketHandler.Proxy = new WebProxy
+                {
+                    Address = new Uri($"{proxy.Host}:{proxy.Port}"),
+                    Credentials = proxy.Password == null ? null : new NetworkCredential(proxy.Login, proxy.Password)
+                };
+            }
+            return socketHandler;
+#else
+            var httpHandler = new HttpClientHandler();
+            try
+            {
+                httpHandler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
+                httpHandler.DefaultProxyCredentials = CredentialCache.DefaultCredentials;
+            }
+            catch (PlatformNotSupportedException) { }
+            catch (NotImplementedException) { } // Mono runtime throws NotImplementedException
+
+            if (proxy != null)
+            {
+                httpHandler.Proxy = new WebProxy
+                {
+                    Address = new Uri($"{proxy.Host}:{proxy.Port}"),
+                    Credentials = proxy.Password == null ? null : new NetworkCredential(proxy.Login, proxy.Password)
+                };
+            }
+            return httpHandler;
+#endif
+        }
     }
 }

CryptoExchange.Net/Objects/CallResult.cs

@@ -205,6 +205,11 @@ namespace CryptoExchange.Net.Objects
         /// The request http method
         /// </summary>
         public HttpMethod? RequestMethod { get; set; }
+        
+        /// <summary>
+        /// HTTP protocol version
+        /// </summary>
+        public Version? HttpVersion { get; set; }
 
         /// <summary>
         /// The headers sent with the request
@@ -251,6 +256,7 @@ namespace CryptoExchange.Net.Objects
         /// </summary>
         public WebCallResult(
             HttpStatusCode? code,
+            Version? httpVersion,
             KeyValuePair<string, string[]>[]? responseHeaders,
             TimeSpan? responseTime,
             string? originalData,
@@ -262,6 +268,7 @@ namespace CryptoExchange.Net.Objects
             Error? error) : base(error)
         {
             ResponseStatusCode = code;
+            HttpVersion = httpVersion;
             ResponseHeaders = responseHeaders;
             ResponseTime = responseTime;
             RequestId = requestId;
@@ -286,7 +293,7 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public WebCallResult AsError(Error error)
         {
-            return new WebCallResult(ResponseStatusCode, ResponseHeaders, ResponseTime, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, error);
+            return new WebCallResult(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, error);
         }
 
         /// <summary>
@@ -297,7 +304,7 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public WebCallResult<K> As<K>([AllowNull] K data)
         {
-            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, 0, null, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Server, data, Error);
+            return new WebCallResult<K>(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, 0, null, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Server, data, Error);
         }
 
         /// <summary>
@@ -334,7 +341,7 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public WebCallResult<K> AsError<K>(Error error)
         {
-            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, 0, null, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Server, default, error);
+            return new WebCallResult<K>(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, 0, null, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Server, default, error);
         }
 
         /// <inheritdoc />
@@ -355,6 +362,11 @@ namespace CryptoExchange.Net.Objects
         /// </summary>
         public HttpMethod? RequestMethod { get; set; }
 
+        /// <summary>
+        /// HTTP protocol version
+        /// </summary>
+        public Version? HttpVersion { get; set; }
+
         /// <summary>
         /// The headers sent with the request
         /// </summary>
@@ -403,21 +415,9 @@ namespace CryptoExchange.Net.Objects
         /// <summary>
         /// Create a new result
         /// </summary>
-        /// <param name="code"></param>
-        /// <param name="responseHeaders"></param>
-        /// <param name="responseTime"></param>
-        /// <param name="responseLength"></param>
-        /// <param name="originalData"></param>
-        /// <param name="requestId"></param>
-        /// <param name="requestUrl"></param>
-        /// <param name="requestBody"></param>
-        /// <param name="requestMethod"></param>
-        /// <param name="requestHeaders"></param>
-        /// <param name="dataSource"></param>
-        /// <param name="data"></param>
-        /// <param name="error"></param>
         public WebCallResult(
             HttpStatusCode? code,
+            Version? httpVersion,
             KeyValuePair<string, string[]>[]? responseHeaders,
             TimeSpan? responseTime,
             long? responseLength,
@@ -431,6 +431,7 @@ namespace CryptoExchange.Net.Objects
             [AllowNull] T data,
             Error? error) : base(data, originalData, error)
         {
+            HttpVersion = httpVersion;
             ResponseStatusCode = code;
             ResponseHeaders = responseHeaders;
             ResponseTime = responseTime;
@@ -450,7 +451,7 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public new WebCallResult AsDataless()
         {
-            return new WebCallResult(ResponseStatusCode, ResponseHeaders, ResponseTime, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, Error);
+            return new WebCallResult(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, Error);
         }
         /// <summary>
         /// Copy as a dataless result
@@ -458,14 +459,14 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public new WebCallResult AsDatalessError(Error error)
         {
-            return new WebCallResult(ResponseStatusCode, ResponseHeaders, ResponseTime, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, error);
+            return new WebCallResult(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, error);
         }
 
         /// <summary>
         /// Create a new error result
         /// </summary>
         /// <param name="error">The error</param>
-        public WebCallResult(Error? error) : this(null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, default, error) { }
+        public WebCallResult(Error? error) : this(null, null, null, null, null, null, null, null, null, null, null, ResultDataSource.Server, default, error) { }
 
         /// <summary>
         /// Copy the WebCallResult to a new data type
@@ -475,7 +476,7 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public new WebCallResult<K> As<K>([AllowNull] K data)
         {
-            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, data, Error);
+            return new WebCallResult<K>(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, data, Error);
         }
 
         /// <summary>
@@ -486,7 +487,7 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public new WebCallResult<K> AsError<K>(Error error)
         {
-            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, default, error);
+            return new WebCallResult<K>(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, default, error);
         }
 
         /// <summary>
@@ -498,7 +499,7 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         public new WebCallResult<K> AsErrorWithData<K>(Error error, K data)
         {
-            return new WebCallResult<K>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, data, error);
+            return new WebCallResult<K>(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, data, error);
         }
 
         /// <summary>
@@ -569,7 +570,7 @@ namespace CryptoExchange.Net.Objects
         /// <returns></returns>
         internal WebCallResult<T> Cached()
         {
-            return new WebCallResult<T>(ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Cache, Data, Error);
+            return new WebCallResult<T>(ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, ResultDataSource.Cache, Data, Error);
         }
 
         /// <inheritdoc />

CryptoExchange.Net/Objects/Enums.cs

@@ -251,4 +251,20 @@ namespace CryptoExchange.Net.Objects
         /// </summary>
         DEX
     }
+
+    /// <summary>
+    /// Timeout behavior for queries
+    /// </summary>
+    public enum TimeoutBehavior
+    {
+        /// <summary>
+        /// Fail the request
+        /// </summary>
+        Fail,
+        /// <summary>
+        /// Mark the query as successful
+        /// </summary>
+        Succeed
+    }
+
 }

CryptoExchange.Net/Objects/Error.cs

@@ -11,9 +11,11 @@ namespace CryptoExchange.Net.Objects
 
         private int? _code;
         /// <summary>
-        /// The error code from the server
+        /// The int error code the server returned; or the http status code int value if there was no error code.<br />
+        /// <br />
+        /// <i>Note:</i><br />
+        /// The <see cref="ErrorCode"/> property should be used for more generic error checking; it might contain a string error code if the server does not return an int code.
         /// </summary>
-        [Obsolete("Use ErrorCode instead", false)]
         public int? Code 
         { 
             get

CryptoExchange.Net/Objects/Options/RestExchangeOptions.cs

@@ -1,5 +1,7 @@
 using CryptoExchange.Net.Authentication;
 using System;
+using System.Net;
+using System.Net.Http;
 
 namespace CryptoExchange.Net.Objects.Options
 {
@@ -28,6 +30,20 @@ namespace CryptoExchange.Net.Objects.Options
         /// </summary>
         public TimeSpan CachingMaxAge { get; set; } = TimeSpan.FromSeconds(5);
 
+        /// <summary>
+        /// The HTTP protocol version to use, typically 2.0 or 1.1
+        /// </summary>
+        public Version HttpVersion { get; set; }
+#if NET5_0_OR_GREATER
+            = new Version(2, 0);
+#else
+            = new Version(1, 1);
+#endif
+        /// <summary>
+        /// Http client keep alive interval for keeping connections open
+        /// </summary>
+        public TimeSpan? HttpKeepAliveInterval { get; set; } = TimeSpan.FromSeconds(15);
+
         /// <summary>
         /// Set the values of this options on the target options
         /// </summary>
@@ -43,6 +59,8 @@ namespace CryptoExchange.Net.Objects.Options
             item.RateLimitingBehaviour = RateLimitingBehaviour;
             item.CachingEnabled = CachingEnabled;
             item.CachingMaxAge = CachingMaxAge;
+            item.HttpVersion = HttpVersion;
+            item.HttpKeepAliveInterval = HttpKeepAliveInterval;
             return item;
         }
     }

CryptoExchange.Net/Objects/RequestDefinition.cs

@@ -62,6 +62,11 @@ namespace CryptoExchange.Net.Objects
         /// </summary>
         public bool PreventCaching { get; set; }
 
+        /// <summary>
+        /// Whether the response to this requests should attempted to be parsed even when the status indicates failure
+        /// </summary>
+        public bool TryParseOnNonSuccess { get; set; }
+
         /// <summary>
         /// Connection id
         /// </summary>

CryptoExchange.Net/Objects/RequestDefinitionCache.cs

@@ -46,6 +46,7 @@ namespace CryptoExchange.Net.Objects
         /// <param name="parameterPosition">Parameter position</param>
         /// <param name="arraySerialization">Array serialization type</param>
         /// <param name="preventCaching">Prevent request caching</param>
+        /// <param name="tryParseOnNonSuccess">Try parse the response even when status is not success</param>
         /// <returns></returns>
         public RequestDefinition GetOrCreate(
             HttpMethod method,
@@ -57,8 +58,9 @@ namespace CryptoExchange.Net.Objects
             RequestBodyFormat? requestBodyFormat = null,
             HttpMethodParameterPosition? parameterPosition = null,
             ArrayParametersSerialization? arraySerialization = null,
-            bool? preventCaching = null)
-            => GetOrCreate(method + path, method, path, rateLimitGate, weight, authenticated, limitGuard, requestBodyFormat, parameterPosition, arraySerialization, preventCaching);
+            bool? preventCaching = null,
+            bool? tryParseOnNonSuccess = null)
+            => GetOrCreate(method + path, method, path, rateLimitGate, weight, authenticated, limitGuard, requestBodyFormat, parameterPosition, arraySerialization, preventCaching, tryParseOnNonSuccess);
 
         /// <summary>
         /// Get a definition if it is already in the cache or create a new definition and add it to the cache
@@ -74,6 +76,7 @@ namespace CryptoExchange.Net.Objects
         /// <param name="parameterPosition">Parameter position</param>
         /// <param name="arraySerialization">Array serialization type</param>
         /// <param name="preventCaching">Prevent request caching</param>
+        /// <param name="tryParseOnNonSuccess">Try parse the response even when status is not success</param>
         /// <returns></returns>
         public RequestDefinition GetOrCreate(
             string identifier,
@@ -86,7 +89,8 @@ namespace CryptoExchange.Net.Objects
             RequestBodyFormat? requestBodyFormat = null,
             HttpMethodParameterPosition? parameterPosition = null,
             ArrayParametersSerialization? arraySerialization = null,
-            bool? preventCaching = null)
+            bool? preventCaching = null,
+            bool? tryParseOnNonSuccess = null)
         {
 
             if (!_definitions.TryGetValue(identifier, out var def))
@@ -100,7 +104,8 @@ namespace CryptoExchange.Net.Objects
                     ArraySerialization = arraySerialization,
                     RequestBodyFormat = requestBodyFormat,
                     ParameterPosition = parameterPosition,
-                    PreventCaching = preventCaching ?? false
+                    PreventCaching = preventCaching ?? false,
+                    TryParseOnNonSuccess = tryParseOnNonSuccess ?? false
                 };
                 _definitions.TryAdd(identifier, def);
             }

CryptoExchange.Net/Requests/Request.cs

@@ -50,6 +50,9 @@ namespace CryptoExchange.Net.Requests
         /// <inheritdoc />
         public Uri Uri => _request.RequestUri!;
 
+        /// <inheritdoc />
+        public Version HttpVersion => _request.Version!;
+
         /// <inheritdoc />
         public int RequestId { get; }
 
@@ -81,7 +84,9 @@ namespace CryptoExchange.Net.Requests
         /// <inheritdoc />
         public async Task<IResponse> GetResponseAsync(CancellationToken cancellationToken)
         {
-            return new Response(await _httpClient.SendAsync(_request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false));
+            var response = await _httpClient.SendAsync(_request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
+            
+            return new Response(response);
         }
     }
 }

CryptoExchange.Net/Requests/RequestFactory.cs

@@ -3,6 +3,7 @@ using System.Net;
 using System.Net.Http;
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
 
 namespace CryptoExchange.Net.Requests
 {
@@ -14,54 +15,43 @@ namespace CryptoExchange.Net.Requests
         private HttpClient? _httpClient;
 
         /// <inheritdoc />
-        public void Configure(ApiProxy? proxy, TimeSpan requestTimeout, HttpClient? client = null)
+        public void Configure(RestExchangeOptions options, HttpClient? client = null)
         {
             if (client == null)
-                client = CreateClient(proxy, requestTimeout);
+                client = CreateClient(options.Proxy, options.RequestTimeout, options.HttpKeepAliveInterval);
 
             _httpClient = client;
         }
 
         /// <inheritdoc />
-        public IRequest Create(HttpMethod method, Uri uri, int requestId)
+        public IRequest Create(Version httpRequestVersion, HttpMethod method, Uri uri, int requestId)
         {
             if (_httpClient == null)
                 throw new InvalidOperationException("Cant create request before configuring http client");
 
-            return new Request(new HttpRequestMessage(method, uri), _httpClient, requestId);
+            var requestMessage = new HttpRequestMessage(method, uri);
+            requestMessage.Version = httpRequestVersion;
+#if NET5_0_OR_GREATER
+            requestMessage.VersionPolicy = HttpVersionPolicy.RequestVersionOrLower;
+#endif
+            return new Request(requestMessage, _httpClient, requestId);
         }
 
         /// <inheritdoc />
-        public void UpdateSettings(ApiProxy? proxy, TimeSpan requestTimeout)
+        public void UpdateSettings(ApiProxy? proxy, TimeSpan requestTimeout, TimeSpan? httpKeepAliveInterval)
         {
-            _httpClient = CreateClient(proxy, requestTimeout);
+            _httpClient = CreateClient(proxy, requestTimeout, httpKeepAliveInterval);
         }
 
-        private static HttpClient CreateClient(ApiProxy? proxy, TimeSpan requestTimeout)
+        private static HttpClient CreateClient(ApiProxy? proxy, TimeSpan requestTimeout, TimeSpan? httpKeepAliveInterval)
         {
-            var handler = new HttpClientHandler();
-            try
-            {
-                handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
-                handler.DefaultProxyCredentials = CredentialCache.DefaultCredentials;
-            }
-            catch (PlatformNotSupportedException) { }
-            catch (NotImplementedException) { } // Mono runtime throws NotImplementedException
-
-            if (proxy != null)
-            {
-                handler.Proxy = new WebProxy
-                {
-                    Address = new Uri($"{proxy.Host}:{proxy.Port}"),
-                    Credentials = proxy.Password == null ? null : new NetworkCredential(proxy.Login, proxy.Password)
-                };
-            }
-
+            var handler = LibraryHelpers.CreateHttpClientMessageHandler(proxy, httpKeepAliveInterval);
             var client = new HttpClient(handler)
             {
-                Timeout = requestTimeout
+                Timeout = requestTimeout                
             };
             return client;
         }
+
     }
 }

CryptoExchange.Net/Requests/Response.cs

@@ -1,4 +1,5 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.IO;
 using System.Linq;
 using System.Net;
@@ -18,6 +19,9 @@ namespace CryptoExchange.Net.Requests
         /// <inheritdoc />
         public HttpStatusCode StatusCode => _response.StatusCode;
 
+        /// <inheritdoc />
+        public Version HttpVersion => _response.Version;
+
         /// <inheritdoc />
         public bool IsSuccessStatusCode => _response.IsSuccessStatusCode;
 

CryptoExchange.Net/SharedApis/Models/ExchangeWebResult.cs

@@ -48,6 +48,7 @@ namespace CryptoExchange.Net.SharedApis
             WebCallResult<T> result,
             INextPageToken? nextPageToken = null) :
             base(result.ResponseStatusCode,
+                result.HttpVersion,
                 result.ResponseHeaders,
                 result.ResponseTime,
                 result.ResponseLength,
@@ -75,6 +76,7 @@ namespace CryptoExchange.Net.SharedApis
             WebCallResult<T> result,
             INextPageToken? nextPageToken = null) :
             base(result.ResponseStatusCode,
+                result.HttpVersion,
                 result.ResponseHeaders,
                 result.ResponseTime,
                 result.ResponseLength,
@@ -100,6 +102,7 @@ namespace CryptoExchange.Net.SharedApis
             string exchange,
             TradingMode[]? dataTradeModes,
             HttpStatusCode? code,
+            Version? httpVersion,
             KeyValuePair<string, string[]>[]? responseHeaders,
             TimeSpan? responseTime,
             long? responseLength,
@@ -114,6 +117,7 @@ namespace CryptoExchange.Net.SharedApis
             Error? error,
             INextPageToken? nextPageToken = null) : base(
                 code,
+                httpVersion,
                 responseHeaders,
                 responseTime,
                 responseLength,
@@ -140,7 +144,7 @@ namespace CryptoExchange.Net.SharedApis
         /// <returns></returns>
         public new ExchangeWebResult<K> As<K>([AllowNull] K data)
         {
-            return new ExchangeWebResult<K>(Exchange, DataTradeMode, ResponseStatusCode, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, data, Error, NextPageToken);
+            return new ExchangeWebResult<K>(Exchange, DataTradeMode, ResponseStatusCode, HttpVersion, ResponseHeaders, ResponseTime, ResponseLength, OriginalData, RequestId, RequestUrl, RequestBody, RequestMethod, RequestHeaders, DataSource, data, Error, NextPageToken);
         }
 
         /// <inheritdoc />

CryptoExchange.Net/Sockets/CryptoExchangeWebSocketClient.cs

@@ -1,6 +1,7 @@
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Logging.Extensions;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Errors;
 using CryptoExchange.Net.Objects.Sockets;
 using CryptoExchange.Net.RateLimiting;
 using Microsoft.Extensions.Logging;
@@ -252,6 +253,11 @@ namespace CryptoExchange.Net.Sockets
                         await (OnConnectRateLimited?.Invoke() ?? Task.CompletedTask).ConfigureAwait(false);
                         return new CallResult(new ServerRateLimitError(we.Message, we));
                     }
+
+                    if (_socket.HttpStatusCode == HttpStatusCode.Unauthorized)
+                    {
+                        return new CallResult(new ServerError(new ErrorInfo(ErrorType.Unauthorized, "Server returned status code `401` when `101` was expected")));
+                    }
 #else
                     // ClientWebSocket.HttpStatusCode is only available in .NET6+ https://learn.microsoft.com/en-us/dotnet/api/system.net.websockets.clientwebsocket.httpstatuscode?view=net-8.0
                     // Try to read 429 from the message instead

CryptoExchange.Net/Sockets/Query.cs

@@ -29,6 +29,11 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         public TimeSpan? RequestTimeout { get; set; }
 
+        /// <summary>
+        /// What should happen if the query times out
+        /// </summary>
+        public TimeoutBehavior TimeoutBehavior { get; set; } = TimeoutBehavior.Fail;
+
         /// <summary>
         /// The number of required responses. Can be more than 1 when for example subscribing multiple symbols streams in a single request,
         /// and each symbol receives it's own confirmation response
@@ -183,7 +188,7 @@ namespace CryptoExchange.Net.Sockets
         /// <inheritdoc />
         public override async Task<CallResult> Handle(SocketConnection connection, DataEvent<object> message, MessageHandlerLink check)
         {
-            if (!PreCheckMessage(message))
+            if (!PreCheckMessage(connection, message))
                 return CallResult.SuccessResult;
 
             CurrentResponses++;
@@ -208,18 +213,20 @@ namespace CryptoExchange.Net.Sockets
         /// <summary>
         /// Validate if a message is actually processable by this query
         /// </summary>
-        /// <param name="message"></param>
-        /// <returns></returns>
-        public virtual bool PreCheckMessage(DataEvent<object> message) => true;
+        public virtual bool PreCheckMessage(SocketConnection connection, DataEvent<object> message) => true;
 
         /// <inheritdoc />
         public override void Timeout()
         {
             if (Completed)
                 return;
-
+                        
             Completed = true;
-            Result = new CallResult<THandlerResponse>(new TimeoutError());
+            if (TimeoutBehavior == TimeoutBehavior.Fail)
+                Result = new CallResult<THandlerResponse>(new TimeoutError());
+            else
+                Result = new CallResult<THandlerResponse>(default, null, default);
+
             ContinueAwaiter?.Set();
             _event.Set();
         }

CryptoExchange.Net/Sockets/SocketConnection.cs

@@ -202,6 +202,18 @@ namespace CryptoExchange.Net.Sockets
             }
         }
 
+        /// <summary>
+        /// The number of current pending requests
+        /// </summary>
+        public int PendingRequests
+        {
+            get
+            {
+                lock (_listenersLock)
+                    return _listeners.OfType<Query>().Where(x => !x.Completed).Count();
+            }
+        }
+
         private bool _pausedActivity;
         private readonly object _listenersLock;
         private readonly List<IMessageProcessor> _listeners;
@@ -519,7 +531,10 @@ namespace CryptoExchange.Net.Sockets
                         {
                             // If this message is for this listener then it is automatically confirmed, even if the subscription is not (yet) confirmed
                             subscriptionProcessor.Confirmed = true;
-                            // This doesn't trigger a waiting subscribe query, should probably also somehow set the wait event for that
+                            if (subscriptionProcessor.SubscriptionQuery?.TimeoutBehavior == TimeoutBehavior.Succeed)
+                                // If this subscription has a query waiting for a timeout (success if there is no error response)
+                                // then time it out now as the data is being received, so we assume it's successful
+                                subscriptionProcessor.SubscriptionQuery.Timeout();
                         }
 
                         // 5. Deserialize the message
@@ -996,7 +1011,7 @@ namespace CryptoExchange.Net.Sockets
                         return result;
                     }
 
-                    var subQuery = subscription.GetSubQuery(this);
+                    var subQuery = subscription.CreateSubscriptionQuery(this);
                     if (subQuery == null)
                     {
                         subscription.IsResubscribing = false;
@@ -1031,7 +1046,7 @@ namespace CryptoExchange.Net.Sockets
 
         internal async Task UnsubscribeAsync(Subscription subscription)
         {
-            var unsubscribeRequest = subscription.GetUnsubQuery();
+            var unsubscribeRequest = subscription.CreateUnsubscriptionQuery(this);
             if (unsubscribeRequest == null)
                 return;
 
@@ -1044,7 +1059,7 @@ namespace CryptoExchange.Net.Sockets
             if (!_socket.IsOpen)
                 return new CallResult(new WebError("Socket is not connected"));
 
-            var subQuery = subscription.GetSubQuery(this);
+            var subQuery = subscription.CreateSubscriptionQuery(this);
             if (subQuery == null)
                 return CallResult.SuccessResult;
 

CryptoExchange.Net/Sockets/Subscription.cs

@@ -80,6 +80,16 @@ namespace CryptoExchange.Net.Sockets
         /// </summary>
         public string? Topic { get; set; }
 
+        /// <summary>
+        /// The subscribe query for this subscription
+        /// </summary>
+        public Query? SubscriptionQuery { get; private set; }
+
+        /// <summary>
+        /// The unsubscribe query for this subscription
+        /// </summary>
+        public Query? UnsubscriptionQuery { get; private set; }
+
         /// <summary>
         /// ctor
         /// </summary>
@@ -91,11 +101,21 @@ namespace CryptoExchange.Net.Sockets
             Id = ExchangeHelpers.NextId();
         }
 
+        /// <summary>
+        /// Create a new subscription query
+        /// </summary>
+        public Query? CreateSubscriptionQuery(SocketConnection connection)
+        {
+            var query = GetSubQuery(connection);
+            SubscriptionQuery = query;
+            return query;
+        }
+
         /// <summary>
         /// Get the subscribe query to send when subscribing
         /// </summary>
         /// <returns></returns>
-        public abstract Query? GetSubQuery(SocketConnection connection);
+        protected abstract Query? GetSubQuery(SocketConnection connection);
 
         /// <summary>
         /// Handle a subscription query response
@@ -109,11 +129,21 @@ namespace CryptoExchange.Net.Sockets
         /// <param name="message"></param>
         public virtual void HandleUnsubQueryResponse(object message) { }
 
+        /// <summary>
+        /// Create a new unsubscription query
+        /// </summary>
+        public Query? CreateUnsubscriptionQuery(SocketConnection connection)
+        {
+            var query = GetUnsubQuery(connection);
+            UnsubscriptionQuery = query;
+            return query;
+        }
+
         /// <summary>
         /// Get the unsubscribe query to send when unsubscribing
         /// </summary>
         /// <returns></returns>
-        public abstract Query? GetUnsubQuery();
+        protected abstract Query? GetUnsubQuery(SocketConnection connection);
 
         /// <inheritdoc />
         public virtual CallResult<object> Deserialize(IMessageAccessor message, Type type) => message.Deserialize(type);

CryptoExchange.Net/Sockets/SystemSubscription.cs

@@ -22,9 +22,9 @@ namespace CryptoExchange.Net.Sockets
         }
 
         /// <inheritdoc />
-        public override Query? GetSubQuery(SocketConnection connection) => null;
+        protected override Query? GetSubQuery(SocketConnection connection) => null;
 
         /// <inheritdoc />
-        public override Query? GetUnsubQuery() => null;
+        protected override Query? GetUnsubQuery(SocketConnection connection) => null;
     }
 }

CryptoExchange.Net/Testing/Implementations/TestRequest.cs

@@ -21,6 +21,8 @@ namespace CryptoExchange.Net.Testing.Implementations
 
         public Uri Uri { get; set; }
 
+        public Version HttpVersion { get; set; }
+
         public int RequestId { get; set; }
 
 #pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider declaring as nullable.

CryptoExchange.Net/Testing/Implementations/TestRequestFactory.cs

@@ -1,5 +1,6 @@
 using CryptoExchange.Net.Interfaces;
 using CryptoExchange.Net.Objects;
+using CryptoExchange.Net.Objects.Options;
 using System;
 using System.Net.Http;
 
@@ -14,11 +15,11 @@ namespace CryptoExchange.Net.Testing.Implementations
             _request = request;
         }
 
-        public void Configure(ApiProxy? proxy, TimeSpan requestTimeout, HttpClient? httpClient = null)
-        {
+        public void Configure(RestExchangeOptions options, HttpClient? client)
+        { 
         }
 
-        public IRequest Create(HttpMethod method, Uri uri, int requestId)
+        public IRequest Create(Version httpRequestVersion, HttpMethod method, Uri uri, int requestId)
         {
             _request.Method = method;
             _request.Uri = uri;
@@ -26,6 +27,6 @@ namespace CryptoExchange.Net.Testing.Implementations
             return _request;
         }
 
-        public void UpdateSettings(ApiProxy? proxy, TimeSpan requestTimeout) {}
+        public void UpdateSettings(ApiProxy? proxy, TimeSpan requestTimeout, TimeSpan? httpKeepAliveInterval) {}
     }
 }

CryptoExchange.Net/Testing/Implementations/TestResponse.cs

@@ -1,4 +1,5 @@
 using CryptoExchange.Net.Interfaces;
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Net;
@@ -11,6 +12,7 @@ namespace CryptoExchange.Net.Testing.Implementations
         private readonly Stream _response;
 
         public HttpStatusCode StatusCode { get; }
+        public Version HttpVersion { get; }
 
         public bool IsSuccessStatusCode { get; }
 
@@ -21,6 +23,7 @@ namespace CryptoExchange.Net.Testing.Implementations
         public TestResponse(HttpStatusCode code, Stream response)
         {
             StatusCode = code;
+            HttpVersion = new Version(2, 0);
             IsSuccessStatusCode = code == HttpStatusCode.OK;
             _response = response;
         }

CryptoExchange.Net/Testing/TestHelpers.cs

@@ -128,12 +128,7 @@ namespace CryptoExchange.Net.Testing
             var uriParams = client.ParameterPositions[method] == HttpMethodParameterPosition.InUri ? client.CreateParameterDictionary(parameters) : null;
             var bodyParams = client.ParameterPositions[method] == HttpMethodParameterPosition.InBody ? client.CreateParameterDictionary(parameters) : null;
 
-            var headers = new Dictionary<string, string>();
-
-            authProvider.TimeProvider = new TestAuthTimeProvider(time ?? new DateTime(2024, 01, 01, 0, 0, 0, DateTimeKind.Utc));
-            authProvider.ProcessRequest(
-                client,
-                new RestRequestConfiguration(
+            var requestDefinition = new RestRequestConfiguration(
                     new RequestDefinition(path, method)
                     {
                         Authenticated = true
@@ -141,14 +136,19 @@ namespace CryptoExchange.Net.Testing
                     host,
                     uriParams ?? new Dictionary<string, object>(),
                     bodyParams ?? new Dictionary<string, object>(),
-                    headers,
+                    new Dictionary<string, string>(),
                     client.ArraySerialization,
                     client.ParameterPositions[method],
                     client.RequestBodyFormat
-                    )
+                    );
+
+            authProvider.TimeProvider = new TestAuthTimeProvider(time ?? new DateTime(2024, 01, 01, 0, 0, 0, DateTimeKind.Utc));
+            authProvider.ProcessRequest(
+                client,
+                requestDefinition
                 );
 
-            var signature = getSignature(uriParams, bodyParams, headers);
+            var signature = getSignature(requestDefinition.QueryParameters, requestDefinition.BodyParameters, requestDefinition.Headers);
 
             if (!string.Equals(signature, expectedSignature, compareCase ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase))
                 throw new Exception($"Signatures do not match. Expected: {expectedSignature}, Actual: {signature}");

README.md

@@ -38,6 +38,10 @@ Full list of all libraries part of the CryptoExchange.Net ecosystem. Consider us
 
 Any of these can be installed independently or install [CryptoClients.Net](https://github.com/jkorf/CryptoClients.Net) which includes all exchange API's.
 
+### Full demo application
+A full demo application is available using the [CryptoClients.Net](https://github.com/jkorf/CryptoClients.Net) library:  
+https://github.com/JKorf/CryptoManager.Net
+
 ## Discord
 [![Nuget version](https://img.shields.io/discord/847020490588422145?style=for-the-badge)](https://discord.gg/MSpeEtSY8t)  
 A Discord server is available [here](https://discord.gg/MSpeEtSY8t). Feel free to join for discussion and/or questions around the CryptoExchange.Net and implementation libraries.
@@ -59,6 +63,19 @@ Make a one time donation in a crypto currency of your choice. If you prefer to d
 Alternatively, sponsor me on Github using [Github Sponsors](https://github.com/sponsors/JKorf). 
 
 ## Release notes
+* Version 9.7.0 - 01 Sep 2025
+    * Added LibraryHelpers.CreateHttpClientMessageHandle to standardize HttpMessageHandler creation
+    * Added REST client option for selecting HTTP protocol version
+    * Added REST client option for HTTP client keep alive interval
+    * Added HttpVersion to WebCallResult responses
+    * Updated request logic to default to using HTTP version 2.0 for dotnet core
+
+* Version 9.6.0 - 25 Aug 2025
+    * Added support for parsing REST response even though status indicates error
+    * Added better support for subscriptions without subscribe confirmation
+    * Added check in websocket for receiving 401 unauthorized http response status when 101 was expected
+    * Removed obsolete attribute on Error.Code property, updated the description
+
 * Version 9.5.0 - 19 Aug 2025
     * Added better error handling support
     * Added ErrorDescription, ErrorType and IsTransient to Error object