diff --git a/HTX.Net.UnitTests/HTXRestClientTests.cs b/HTX.Net.UnitTests/HTXRestClientTests.cs
index e603b857..ba2f4a10 100644
--- a/HTX.Net.UnitTests/HTXRestClientTests.cs
+++ b/HTX.Net.UnitTests/HTXRestClientTests.cs
@@ -9,6 +9,10 @@
 using System.Net.Http;
 using System.Collections.Generic;
 using System.Text.Json;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using HTX.Net.Interfaces.Clients;
+using CryptoExchange.Net.Objects;
 
 namespace HTX.Net.UnitTests
 {
@@ -83,5 +87,103 @@ public void CheckInterfaces()
             CryptoExchange.Net.Testing.TestHelpers.CheckForMissingRestInterfaces<HTXRestClient>();
             CryptoExchange.Net.Testing.TestHelpers.CheckForMissingSocketInterfaces<HTXSocketClient>();
         }
+
+        [Test]
+        [TestCase(TradeEnvironmentNames.Live, "https://api.huobi.pro")]
+        [TestCase("", "https://api.huobi.pro")]
+        public void TestConstructorEnvironments(string environmentName, string expected)
+        {
+            var configuration = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    { "HTX:Environment:Name", environmentName },
+                }).Build();
+
+            var collection = new ServiceCollection();
+            collection.AddHTX(configuration.GetSection("HTX"));
+            var provider = collection.BuildServiceProvider();
+
+            var client = provider.GetRequiredService<IHTXRestClient>();
+
+            var address = client.SpotApi.BaseAddress;
+
+            Assert.That(address, Is.EqualTo(expected));
+        }
+
+        [Test]
+        public void TestConstructorNullEnvironment()
+        {
+            var configuration = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    { "HTX", null },
+                }).Build();
+
+            var collection = new ServiceCollection();
+            collection.AddHTX(configuration.GetSection("HTX"));
+            var provider = collection.BuildServiceProvider();
+
+            var client = provider.GetRequiredService<IHTXRestClient>();
+
+            var address = client.SpotApi.BaseAddress;
+
+            Assert.That(address, Is.EqualTo("https://api.huobi.pro"));
+        }
+
+        [Test]
+        public void TestConstructorApiOverwriteEnvironment()
+        {
+            var configuration = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    { "HTX:Environment:Name", "test" },
+                    { "HTX:Rest:Environment:Name", "live" },
+                }).Build();
+
+            var collection = new ServiceCollection();
+            collection.AddHTX(configuration.GetSection("HTX"));
+            var provider = collection.BuildServiceProvider();
+
+            var client = provider.GetRequiredService<IHTXRestClient>();
+
+            var address = client.SpotApi.BaseAddress;
+
+            Assert.That(address, Is.EqualTo("https://api.huobi.pro"));
+        }
+
+        [Test]
+        public void TestConstructorConfiguration()
+        {
+            var configuration = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    { "ApiCredentials:Key", "123" },
+                    { "ApiCredentials:Secret", "456" },
+                    { "Socket:ApiCredentials:Key", "456" },
+                    { "Socket:ApiCredentials:Secret", "789" },
+                    { "Rest:OutputOriginalData", "true" },
+                    { "Socket:OutputOriginalData", "false" },
+                    { "Rest:Proxy:Host", "host" },
+                    { "Rest:Proxy:Port", "80" },
+                    { "Socket:Proxy:Host", "host2" },
+                    { "Socket:Proxy:Port", "81" },
+                }).Build();
+
+            var collection = new ServiceCollection();
+            collection.AddHTX(configuration);
+            var provider = collection.BuildServiceProvider();
+
+            var restClient = provider.GetRequiredService<IHTXRestClient>();
+            var socketClient = provider.GetRequiredService<IHTXSocketClient>();
+
+            Assert.That(((BaseApiClient)restClient.SpotApi).OutputOriginalData, Is.True);
+            Assert.That(((BaseApiClient)socketClient.SpotApi).OutputOriginalData, Is.False);
+            Assert.That(((BaseApiClient)restClient.SpotApi).AuthenticationProvider.ApiKey, Is.EqualTo("123"));
+            Assert.That(((BaseApiClient)socketClient.SpotApi).AuthenticationProvider.ApiKey, Is.EqualTo("456"));
+            Assert.That(((BaseApiClient)restClient.SpotApi).ClientOptions.Proxy.Host, Is.EqualTo("host"));
+            Assert.That(((BaseApiClient)restClient.SpotApi).ClientOptions.Proxy.Port, Is.EqualTo(80));
+            Assert.That(((BaseApiClient)socketClient.SpotApi).ClientOptions.Proxy.Host, Is.EqualTo("host2"));
+            Assert.That(((BaseApiClient)socketClient.SpotApi).ClientOptions.Proxy.Port, Is.EqualTo(81));
+        }
     }
 }
diff --git a/HTX.Net.UnitTests/HTXRestIntegrationTests.cs b/HTX.Net.UnitTests/HTXRestIntegrationTests.cs
index 4764942d..28cf3846 100644
--- a/HTX.Net.UnitTests/HTXRestIntegrationTests.cs
+++ b/HTX.Net.UnitTests/HTXRestIntegrationTests.cs
@@ -10,6 +10,7 @@
 using System.Text;
 using System.Threading.Tasks;
 using HTX.Net.Enums;
+using Microsoft.Extensions.Options;
 
 namespace HTX.Net.UnitTests
 {
@@ -28,11 +29,11 @@ public override HTXRestClient GetClient(ILoggerFactory loggerFactory)
             var sec = Environment.GetEnvironmentVariable("APISECRET");
 
             Authenticated = key != null && sec != null;
-            return new HTXRestClient(null, loggerFactory, opts =>
+            return new HTXRestClient(null, loggerFactory, Options.Create(new Objects.Options.HTXRestOptions
             {
-                opts.OutputOriginalData = true;
-                opts.ApiCredentials = Authenticated ? new ApiCredentials(key, sec) : null;
-            });
+                OutputOriginalData = true,
+                ApiCredentials = Authenticated ? new ApiCredentials(key, sec) : null
+            }));
         }
 
         [Test]
diff --git a/HTX.Net/Clients/HTXRestClient.cs b/HTX.Net/Clients/HTXRestClient.cs
index 69b99022..4856e733 100644
--- a/HTX.Net/Clients/HTXRestClient.cs
+++ b/HTX.Net/Clients/HTXRestClient.cs
@@ -5,6 +5,7 @@
 using CryptoExchange.Net.Clients;
 using HTX.Net.Interfaces.Clients.UsdtFuturesApi;
 using HTX.Net.Clients.UsdtFutures;
+using Microsoft.Extensions.Options;
 
 namespace HTX.Net.Clients
 {
@@ -26,26 +27,24 @@ public class HTXRestClient : BaseRestClient, IHTXRestClient
         /// Create a new instance of the HTXRestClient using provided options
         /// </summary>
         /// <param name="optionsDelegate">Option configuration delegate</param>
-        public HTXRestClient(Action<HTXRestOptions>? optionsDelegate = null) : this(null, null, optionsDelegate)
+        public HTXRestClient(Action<HTXRestOptions>? optionsDelegate = null)
+            : this(null, null, Options.Create(ApplyOptionsDelegate(optionsDelegate)))
         {
         }
 
         /// <summary>
         /// Create a new instance of the HTXRestClient
         /// </summary>
-        /// <param name="optionsDelegate">Option configuration delegate</param>
+        /// <param name="options">Option configuration delegate</param>
         /// <param name="loggerFactory">The logger factory</param>
         /// <param name="httpClient">Http client for this client</param>
-        public HTXRestClient(HttpClient? httpClient, ILoggerFactory? loggerFactory, Action<HTXRestOptions>? optionsDelegate = null)
+        public HTXRestClient(HttpClient? httpClient, ILoggerFactory? loggerFactory, IOptions<HTXRestOptions> options)
             : base(loggerFactory, "HTX")
         {
-            var options = HTXRestOptions.Default.Copy();
-            if (optionsDelegate != null)
-                optionsDelegate(options);
-            Initialize(options);
+            Initialize(options.Value);
 
-            SpotApi = AddApiClient(new HTXRestClientSpotApi(_logger, httpClient, options));
-            UsdtFuturesApi = AddApiClient(new HTXRestClientUsdtFuturesApi(_logger, httpClient, options));
+            SpotApi = AddApiClient(new HTXRestClientSpotApi(_logger, httpClient, options.Value));
+            UsdtFuturesApi = AddApiClient(new HTXRestClientUsdtFuturesApi(_logger, httpClient, options.Value));
         }
         #endregion
 
@@ -56,9 +55,7 @@ public HTXRestClient(HttpClient? httpClient, ILoggerFactory? loggerFactory, Acti
         /// <param name="optionsDelegate">Option configuration delegate</param>
         public static void SetDefaultOptions(Action<HTXRestOptions> optionsDelegate)
         {
-            var options = HTXRestOptions.Default.Copy();
-            optionsDelegate(options);
-            HTXRestOptions.Default = options;
+            HTXRestOptions.Default = ApplyOptionsDelegate(optionsDelegate);
         }
 
         /// <inheritdoc />
diff --git a/HTX.Net/Clients/HTXSocketClient.cs b/HTX.Net/Clients/HTXSocketClient.cs
index fff8b4b0..e90afa0b 100644
--- a/HTX.Net/Clients/HTXSocketClient.cs
+++ b/HTX.Net/Clients/HTXSocketClient.cs
@@ -5,6 +5,7 @@
 using HTX.Net.Interfaces.Clients.SpotApi;
 using HTX.Net.Interfaces.Clients.UsdtFuturesApi;
 using HTX.Net.Objects.Options;
+using Microsoft.Extensions.Options;
 
 namespace HTX.Net.Clients
 {
@@ -19,19 +20,13 @@ public class HTXSocketClient : BaseSocketClient, IHTXSocketClient
         #endregion
 
         #region ctor
-        /// <summary>
-        /// Create a new instance of the HTXSocketClient
-        /// </summary>
-        /// <param name="loggerFactory">The logger factory</param>
-        public HTXSocketClient(ILoggerFactory? loggerFactory = null) : this((x) => { }, loggerFactory)
-        {
-        }
 
         /// <summary>
         /// Create a new instance of the HTXSocketClient
         /// </summary>
         /// <param name="optionsDelegate">Option configuration delegate</param>
-        public HTXSocketClient(Action<HTXSocketOptions> optionsDelegate) : this(optionsDelegate, null)
+        public HTXSocketClient(Action<HTXSocketOptions>? optionsDelegate = null)
+            : this(Options.Create(ApplyOptionsDelegate(optionsDelegate)), null)
         {
         }
 
@@ -39,15 +34,13 @@ public HTXSocketClient(Action<HTXSocketOptions> optionsDelegate) : this(optionsD
         /// Create a new instance of the HTXSocketClient
         /// </summary>
         /// <param name="loggerFactory">The logger factory</param>
-        /// <param name="optionsDelegate">Option configuration delegate</param>
-        public HTXSocketClient(Action<HTXSocketOptions> optionsDelegate, ILoggerFactory? loggerFactory = null) : base(loggerFactory, "HTX")
+        /// <param name="options">Option configuration</param>
+        public HTXSocketClient(IOptions<HTXSocketOptions> options, ILoggerFactory? loggerFactory = null) : base(loggerFactory, "HTX")
         {
-            var options = HTXSocketOptions.Default.Copy();
-            optionsDelegate(options);
-            Initialize(options);
+            Initialize(options.Value);
 
-            SpotApi = AddApiClient(new HTXSocketClientSpotApi(_logger, options));
-            UsdtFuturesApi = AddApiClient(new HTXSocketClientUsdtFuturesApi(_logger, options));
+            SpotApi = AddApiClient(new HTXSocketClientSpotApi(_logger, options.Value));
+            UsdtFuturesApi = AddApiClient(new HTXSocketClientUsdtFuturesApi(_logger, options.Value));
         }
         #endregion
 
@@ -58,9 +51,7 @@ public HTXSocketClient(Action<HTXSocketOptions> optionsDelegate, ILoggerFactory?
         /// <param name="optionsDelegate">Option configuration delegate</param>
         public static void SetDefaultOptions(Action<HTXSocketOptions> optionsDelegate)
         {
-            var options = HTXSocketOptions.Default.Copy();
-            optionsDelegate(options);
-            HTXSocketOptions.Default = options;
+            HTXSocketOptions.Default = ApplyOptionsDelegate(optionsDelegate);
         }
 
         /// <inheritdoc />
diff --git a/HTX.Net/ExtensionMethods/ServiceCollectionExtensions.cs b/HTX.Net/ExtensionMethods/ServiceCollectionExtensions.cs
index 2f19121e..40e9c5cb 100644
--- a/HTX.Net/ExtensionMethods/ServiceCollectionExtensions.cs
+++ b/HTX.Net/ExtensionMethods/ServiceCollectionExtensions.cs
@@ -5,6 +5,8 @@
 using HTX.Net.Interfaces.Clients;
 using HTX.Net.Objects.Options;
 using HTX.Net.SymbolOrderBooks;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Options;
 using System.Net;
 
 namespace Microsoft.Extensions.DependencyInjection
@@ -14,47 +16,114 @@ namespace Microsoft.Extensions.DependencyInjection
     /// </summary>
     public static class ServiceCollectionExtensions
     {
+
         /// <summary>
-        /// Add the IRestHTXClient and IHTXSocketClient to the sevice collection so they can be injected
+        /// Add services such as the IHTXRestClient and IHTXSocketClient. Configures the services based on the provided configuration.
         /// </summary>
         /// <param name="services">The service collection</param>
-        /// <param name="defaultRestOptionsDelegate">Set default options for the rest client</param>
-        /// <param name="defaultSocketOptionsDelegate">Set default options for the socket client</param>
-        /// <param name="socketClientLifeTime">The lifetime of the IHTXSocketClient for the service collection. Defaults to Singleton.</param>
+        /// <param name="configuration">The configuration(section) containing the options</param>
         /// <returns></returns>
         public static IServiceCollection AddHTX(
             this IServiceCollection services,
-            Action<HTXRestOptions>? defaultRestOptionsDelegate = null,
-            Action<HTXSocketOptions>? defaultSocketOptionsDelegate = null,
-            ServiceLifetime? socketClientLifeTime = null)
+            IConfiguration configuration)
         {
-            var restOptions = HTXRestOptions.Default.Copy();
+            var options = new HTXOptions();
+            // Reset environment so we know if theyre overriden
+            options.Rest.Environment = null!;
+            options.Socket.Environment = null!;
+            configuration.Bind(options);
 
-            if (defaultRestOptionsDelegate != null)
-            {
-                defaultRestOptionsDelegate(restOptions);
-                HTXRestClient.SetDefaultOptions(defaultRestOptionsDelegate);
-            }
+            if (options.Rest == null || options.Socket == null)
+                throw new ArgumentException("Options null");
 
-            if (defaultSocketOptionsDelegate != null)
-                HTXSocketClient.SetDefaultOptions(defaultSocketOptionsDelegate);
+            var restEnvName = options.Rest.Environment?.Name ?? options.Environment?.Name ?? HTXEnvironment.Live.Name;
+            var socketEnvName = options.Socket.Environment?.Name ?? options.Environment?.Name ?? HTXEnvironment.Live.Name;
+            options.Rest.Environment = HTXEnvironment.GetEnvironmentByName(restEnvName) ?? options.Rest.Environment!;
+            options.Rest.ApiCredentials = options.Rest.ApiCredentials ?? options.ApiCredentials;
+            options.Socket.Environment = HTXEnvironment.GetEnvironmentByName(socketEnvName) ?? options.Socket.Environment!;
+            options.Socket.ApiCredentials = options.Socket.ApiCredentials ?? options.ApiCredentials;
 
-            services.AddHttpClient<IHTXRestClient, HTXRestClient>(options =>
-            {
-                options.Timeout = restOptions.RequestTimeout;
-            }).ConfigurePrimaryHttpMessageHandler(() =>
+
+            services.AddSingleton(x => Options.Options.Create(options.Rest));
+            services.AddSingleton(x => Options.Options.Create(options.Socket));
+
+            return AddHTXCore(services, options.SocketClientLifeTime);
+        }
+
+        /// <summary>
+        /// Add services such as the IHTXRestClient and IHTXSocketClient. Services will be configured based on the provided options.
+        /// </summary>
+        /// <param name="services">The service collection</param>
+        /// <param name="optionsDelegate">Set options for the HTX services</param>
+        /// <returns></returns>
+        public static IServiceCollection AddHTX(
+            this IServiceCollection services,
+            Action<HTXOptions>? optionsDelegate = null)
+        {
+            var options = new HTXOptions();
+            // Reset environment so we know if theyre overriden
+            options.Rest.Environment = null!;
+            options.Socket.Environment = null!;
+            optionsDelegate?.Invoke(options);
+            if (options.Rest == null || options.Socket == null)
+                throw new ArgumentException("Options null");
+
+            options.Rest.Environment = options.Rest.Environment ?? options.Environment ?? HTXEnvironment.Live;
+            options.Rest.ApiCredentials = options.Rest.ApiCredentials ?? options.ApiCredentials;
+            options.Socket.Environment = options.Socket.Environment ?? options.Environment ?? HTXEnvironment.Live;
+            options.Socket.ApiCredentials = options.Socket.ApiCredentials ?? options.ApiCredentials;
+
+            services.AddSingleton(x => Options.Options.Create(options.Rest));
+            services.AddSingleton(x => Options.Options.Create(options.Socket));
+
+            return AddHTXCore(services, options.SocketClientLifeTime);
+        }
+
+        /// <summary>
+        /// DEPRECATED; use <see cref="AddHTX(IServiceCollection, Action{HTXOptions}?)" /> instead
+        /// </summary>
+        public static IServiceCollection AddHTX(
+            this IServiceCollection services,
+            Action<HTXRestOptions> restDelegate,
+            Action<HTXSocketOptions>? socketDelegate = null,
+            ServiceLifetime? socketClientLifeTime = null)
+        {
+            services.Configure<HTXRestOptions>((x) => { restDelegate?.Invoke(x); });
+            services.Configure<HTXSocketOptions>((x) => { socketDelegate?.Invoke(x); });
+
+            return AddHTXCore(services, socketClientLifeTime);
+        }
+
+        private static IServiceCollection AddHTXCore(
+            this IServiceCollection services,
+            ServiceLifetime? socketClientLifeTime = null)
+        {
+            services.AddHttpClient<IHTXRestClient, HTXRestClient>((client, serviceProvider) =>
             {
+                var options = serviceProvider.GetRequiredService<IOptions<HTXRestOptions>>().Value;
+                client.Timeout = options.RequestTimeout;
+                return new HTXRestClient(client, serviceProvider.GetRequiredService<ILoggerFactory>(), serviceProvider.GetRequiredService<IOptions<HTXRestOptions>>());
+            }).ConfigurePrimaryHttpMessageHandler((serviceProvider) => {
                 var handler = new HttpClientHandler();
-                if (restOptions.Proxy != null)
+                try
+                {
+                    handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
+                }
+                catch (PlatformNotSupportedException)
+                { }
+
+                var options = serviceProvider.GetRequiredService<IOptions<HTXRestOptions>>().Value;
+                if (options.Proxy != null)
                 {
                     handler.Proxy = new WebProxy
                     {
-                        Address = new Uri($"{restOptions.Proxy.Host}:{restOptions.Proxy.Port}"),
-                        Credentials = restOptions.Proxy.Password == null ? null : new NetworkCredential(restOptions.Proxy.Login, restOptions.Proxy.Password)
+                        Address = new Uri($"{options.Proxy.Host}:{options.Proxy.Port}"),
+                        Credentials = options.Proxy.Password == null ? null : new NetworkCredential(options.Proxy.Login, options.Proxy.Password)
                     };
                 }
                 return handler;
             });
+            services.Add(new ServiceDescriptor(typeof(IHTXSocketClient), x => { return new HTXSocketClient(x.GetRequiredService<IOptions<HTXSocketOptions>>(), x.GetRequiredService<ILoggerFactory>()); }, socketClientLifeTime ?? ServiceLifetime.Singleton));
 
             services.AddTransient<ICryptoRestClient, CryptoRestClient>();
             services.AddTransient<ICryptoSocketClient, CryptoSocketClient>();
@@ -67,10 +136,6 @@ public static IServiceCollection AddHTX(
             services.RegisterSharedSocketInterfaces(x => x.GetRequiredService<IHTXSocketClient>().UsdtFuturesApi.SharedClient);
 
             services.AddTransient(x => x.GetRequiredService<IHTXRestClient>().SpotApi.CommonSpotClient);
-            if (socketClientLifeTime == null)
-                services.AddSingleton<IHTXSocketClient, HTXSocketClient>();
-            else
-                services.Add(new ServiceDescriptor(typeof(IHTXSocketClient), typeof(HTXSocketClient), socketClientLifeTime.Value));
             return services;
         }
     }
diff --git a/HTX.Net/HTX.Net.csproj b/HTX.Net/HTX.Net.csproj
index eb5c87b5..d13d9425 100644
--- a/HTX.Net/HTX.Net.csproj
+++ b/HTX.Net/HTX.Net.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
     <Nullable>enable</Nullable>
@@ -48,7 +48,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="CryptoExchange.Net" Version="8.2.0" />
+    <PackageReference Include="CryptoExchange.Net" Version="8.3.0" />
     <PackageReference Include="Microsoft.CodeAnalysis.NetAnalyzers" Version="8.0.0">
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
diff --git a/HTX.Net/HTX.Net.xml b/HTX.Net/HTX.Net.xml
index b8677483..24fc1a56 100644
--- a/HTX.Net/HTX.Net.xml
+++ b/HTX.Net/HTX.Net.xml
@@ -19,11 +19,11 @@
             </summary>
             <param name="optionsDelegate">Option configuration delegate</param>
         </member>
-        <member name="M:HTX.Net.Clients.HTXRestClient.#ctor(System.Net.Http.HttpClient,Microsoft.Extensions.Logging.ILoggerFactory,System.Action{HTX.Net.Objects.Options.HTXRestOptions})">
+        <member name="M:HTX.Net.Clients.HTXRestClient.#ctor(System.Net.Http.HttpClient,Microsoft.Extensions.Logging.ILoggerFactory,Microsoft.Extensions.Options.IOptions{HTX.Net.Objects.Options.HTXRestOptions})">
             <summary>
             Create a new instance of the HTXRestClient
             </summary>
-            <param name="optionsDelegate">Option configuration delegate</param>
+            <param name="options">Option configuration delegate</param>
             <param name="loggerFactory">The logger factory</param>
             <param name="httpClient">Http client for this client</param>
         </member>
@@ -45,24 +45,18 @@
         <member name="P:HTX.Net.Clients.HTXSocketClient.UsdtFuturesApi">
             <inheritdoc />
         </member>
-        <member name="M:HTX.Net.Clients.HTXSocketClient.#ctor(Microsoft.Extensions.Logging.ILoggerFactory)">
-            <summary>
-            Create a new instance of the HTXSocketClient
-            </summary>
-            <param name="loggerFactory">The logger factory</param>
-        </member>
         <member name="M:HTX.Net.Clients.HTXSocketClient.#ctor(System.Action{HTX.Net.Objects.Options.HTXSocketOptions})">
             <summary>
             Create a new instance of the HTXSocketClient
             </summary>
             <param name="optionsDelegate">Option configuration delegate</param>
         </member>
-        <member name="M:HTX.Net.Clients.HTXSocketClient.#ctor(System.Action{HTX.Net.Objects.Options.HTXSocketOptions},Microsoft.Extensions.Logging.ILoggerFactory)">
+        <member name="M:HTX.Net.Clients.HTXSocketClient.#ctor(Microsoft.Extensions.Options.IOptions{HTX.Net.Objects.Options.HTXSocketOptions},Microsoft.Extensions.Logging.ILoggerFactory)">
             <summary>
             Create a new instance of the HTXSocketClient
             </summary>
             <param name="loggerFactory">The logger factory</param>
-            <param name="optionsDelegate">Option configuration delegate</param>
+            <param name="options">Option configuration</param>
         </member>
         <member name="M:HTX.Net.Clients.HTXSocketClient.SetDefaultOptions(System.Action{HTX.Net.Objects.Options.HTXSocketOptions})">
             <summary>
@@ -3382,6 +3376,16 @@
             Socket base address for the USDT margin swap API
             </summary>
         </member>
+        <member name="M:HTX.Net.HTXEnvironment.#ctor">
+            <summary>
+            ctor for DI, use <see cref="M:HTX.Net.HTXEnvironment.CreateCustom(System.String,System.String,System.String,System.String,System.String)"/> for creating a custom environment
+            </summary>
+        </member>
+        <member name="M:HTX.Net.HTXEnvironment.GetEnvironmentByName(System.String)">
+            <summary>
+            Get the HTX environment by name
+            </summary>
+        </member>
         <member name="P:HTX.Net.HTXEnvironment.Live">
             <summary>
             Live environment
@@ -3408,6 +3412,16 @@
             Exchange name
             </summary>
         </member>
+        <member name="P:HTX.Net.HTXExchange.DisplayName">
+            <summary>
+            Exchange name
+            </summary>
+        </member>
+        <member name="P:HTX.Net.HTXExchange.ImageUrl">
+            <summary>
+            Url to exchange image
+            </summary>
+        </member>
         <member name="P:HTX.Net.HTXExchange.Url">
             <summary>
             Url to the main website
@@ -17368,6 +17382,36 @@
             Err msg
             </summary>
         </member>
+        <member name="T:HTX.Net.Objects.Options.HTXOptions">
+            <summary>
+            HTX options
+            </summary>
+        </member>
+        <member name="P:HTX.Net.Objects.Options.HTXOptions.Rest">
+            <summary>
+            Rest client options
+            </summary>
+        </member>
+        <member name="P:HTX.Net.Objects.Options.HTXOptions.Socket">
+            <summary>
+            Socket client options
+            </summary>
+        </member>
+        <member name="P:HTX.Net.Objects.Options.HTXOptions.Environment">
+            <summary>
+            Trade environment. Contains info about URL's to use to connect to the API. Use `HTXEnvironment` to swap environment, for example `Environment = HTXEnvironment.Live`
+            </summary>
+        </member>
+        <member name="P:HTX.Net.Objects.Options.HTXOptions.ApiCredentials">
+            <summary>
+            The api credentials used for signing requests.
+            </summary>
+        </member>
+        <member name="P:HTX.Net.Objects.Options.HTXOptions.SocketClientLifeTime">
+            <summary>
+            The DI service lifetime for the IHTXSocketClient
+            </summary>
+        </member>
         <member name="T:HTX.Net.Objects.Options.HTXOrderBookOptions">
             <summary>
             Options for the HTX SymbolOrderBook
@@ -17403,6 +17447,11 @@
             Default options for the HTXRestClient
             </summary>
         </member>
+        <member name="M:HTX.Net.Objects.Options.HTXRestOptions.#ctor">
+            <summary>
+            ctor
+            </summary>
+        </member>
         <member name="P:HTX.Net.Objects.Options.HTXRestOptions.SignPublicRequests">
             <summary>
             Whether public requests should be signed if ApiCredentials are provided. Needed for accurate rate limiting.
@@ -17433,6 +17482,11 @@
             Default options for the HTXSocketClient
             </summary>
         </member>
+        <member name="M:HTX.Net.Objects.Options.HTXSocketOptions.#ctor">
+            <summary>
+            ctor
+            </summary>
+        </member>
         <member name="P:HTX.Net.Objects.Options.HTXSocketOptions.BrokerId">
             <summary>
             Broker id
@@ -17576,15 +17630,26 @@
             Extensions for DI
             </summary>
         </member>
-        <member name="M:Microsoft.Extensions.DependencyInjection.ServiceCollectionExtensions.AddHTX(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Action{HTX.Net.Objects.Options.HTXRestOptions},System.Action{HTX.Net.Objects.Options.HTXSocketOptions},System.Nullable{Microsoft.Extensions.DependencyInjection.ServiceLifetime})">
+        <member name="M:Microsoft.Extensions.DependencyInjection.ServiceCollectionExtensions.AddHTX(Microsoft.Extensions.DependencyInjection.IServiceCollection,Microsoft.Extensions.Configuration.IConfiguration)">
+            <summary>
+            Add services such as the IHTXRestClient and IHTXSocketClient. Configures the services based on the provided configuration.
+            </summary>
+            <param name="services">The service collection</param>
+            <param name="configuration">The configuration(section) containing the options</param>
+            <returns></returns>
+        </member>
+        <member name="M:Microsoft.Extensions.DependencyInjection.ServiceCollectionExtensions.AddHTX(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Action{HTX.Net.Objects.Options.HTXOptions})">
             <summary>
-            Add the IRestHTXClient and IHTXSocketClient to the sevice collection so they can be injected
+            Add services such as the IHTXRestClient and IHTXSocketClient. Services will be configured based on the provided options.
             </summary>
             <param name="services">The service collection</param>
-            <param name="defaultRestOptionsDelegate">Set default options for the rest client</param>
-            <param name="defaultSocketOptionsDelegate">Set default options for the socket client</param>
-            <param name="socketClientLifeTime">The lifetime of the IHTXSocketClient for the service collection. Defaults to Singleton.</param>
+            <param name="optionsDelegate">Set options for the HTX services</param>
             <returns></returns>
         </member>
+        <member name="M:Microsoft.Extensions.DependencyInjection.ServiceCollectionExtensions.AddHTX(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Action{HTX.Net.Objects.Options.HTXRestOptions},System.Action{HTX.Net.Objects.Options.HTXSocketOptions},System.Nullable{Microsoft.Extensions.DependencyInjection.ServiceLifetime})">
+            <summary>
+            DEPRECATED; use <see cref="M:Microsoft.Extensions.DependencyInjection.ServiceCollectionExtensions.AddHTX(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Action{HTX.Net.Objects.Options.HTXOptions})" /> instead
+            </summary>
+        </member>
     </members>
 </doc>
diff --git a/HTX.Net/HTXEnvironment.cs b/HTX.Net/HTXEnvironment.cs
index 405bcc03..6b886e47 100644
--- a/HTX.Net/HTXEnvironment.cs
+++ b/HTX.Net/HTXEnvironment.cs
@@ -39,6 +39,26 @@ internal HTXEnvironment(string name,
             UsdtMarginSwapSocketBaseAddress = usdtMarginSwapSocketBaseAddress;
         }
 
+        /// <summary>
+        /// ctor for DI, use <see cref="CreateCustom"/> for creating a custom environment
+        /// </summary>
+#pragma warning disable CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
+        public HTXEnvironment() : base(TradeEnvironmentNames.Live)
+#pragma warning restore CS8618 // Non-nullable field must contain a non-null value when exiting constructor. Consider adding the 'required' modifier or declaring as nullable.
+        { }
+
+        /// <summary>
+        /// Get the HTX environment by name
+        /// </summary>
+        public static HTXEnvironment? GetEnvironmentByName(string? name)
+         => name switch
+         {
+             TradeEnvironmentNames.Live => Live,
+             "" => Live,
+             null => Live,
+             _ => default
+         };
+
         /// <summary>
         /// Live environment
         /// </summary>
diff --git a/HTX.Net/HTXExchange.cs b/HTX.Net/HTXExchange.cs
index ab2f782e..a0728f82 100644
--- a/HTX.Net/HTXExchange.cs
+++ b/HTX.Net/HTXExchange.cs
@@ -16,6 +16,16 @@ public static class HTXExchange
         /// </summary>
         public static string ExchangeName => "HTX";
 
+        /// <summary>
+        /// Exchange name
+        /// </summary>
+        public static string DisplayName => "HTX";
+
+        /// <summary>
+        /// Url to exchange image
+        /// </summary>
+        public static string ImageUrl { get; } = "https://raw.githubusercontent.com/JKorf/HTX.Net/master/HTX.Net/Icon/icon.png";
+
         /// <summary>
         /// Url to the main website
         /// </summary>
diff --git a/HTX.Net/Objects/Options/HTXOptions.cs b/HTX.Net/Objects/Options/HTXOptions.cs
new file mode 100644
index 00000000..f0d56096
--- /dev/null
+++ b/HTX.Net/Objects/Options/HTXOptions.cs
@@ -0,0 +1,38 @@
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace HTX.Net.Objects.Options
+{
+    /// <summary>
+    /// HTX options
+    /// </summary>
+    public class HTXOptions
+    {
+        /// <summary>
+        /// Rest client options
+        /// </summary>
+        public HTXRestOptions Rest { get; set; } = new HTXRestOptions();
+
+        /// <summary>
+        /// Socket client options
+        /// </summary>
+        public HTXSocketOptions Socket { get; set; } = new HTXSocketOptions();
+
+        /// <summary>
+        /// Trade environment. Contains info about URL's to use to connect to the API. Use `HTXEnvironment` to swap environment, for example `Environment = HTXEnvironment.Live`
+        /// </summary>
+        public HTXEnvironment? Environment { get; set; }
+
+        /// <summary>
+        /// The api credentials used for signing requests.
+        /// </summary>
+        public ApiCredentials? ApiCredentials { get; set; }
+
+        /// <summary>
+        /// The DI service lifetime for the IHTXSocketClient
+        /// </summary>
+        public ServiceLifetime? SocketClientLifeTime { get; set; }
+    }
+}
diff --git a/HTX.Net/Objects/Options/HTXRestOptions.cs b/HTX.Net/Objects/Options/HTXRestOptions.cs
index 9804e74d..a677e7d8 100644
--- a/HTX.Net/Objects/Options/HTXRestOptions.cs
+++ b/HTX.Net/Objects/Options/HTXRestOptions.cs
@@ -10,11 +10,19 @@ public class HTXRestOptions : RestExchangeOptions<HTXEnvironment>
         /// <summary>
         /// Default options for the HTXRestClient
         /// </summary>
-        public static HTXRestOptions Default { get; set; } = new HTXRestOptions()
+        internal static HTXRestOptions Default { get; set; } = new HTXRestOptions()
         {
             Environment = HTXEnvironment.Live
         };
 
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public HTXRestOptions()
+        {
+            Default?.Set(this);
+        }
+
         /// <summary>
         /// Whether public requests should be signed if ApiCredentials are provided. Needed for accurate rate limiting.
         /// </summary>
@@ -35,14 +43,14 @@ public class HTXRestOptions : RestExchangeOptions<HTXEnvironment>
         /// </summary>
         public RestApiOptions UsdtMarginSwapOptions { get; private set; } = new RestApiOptions();
 
-        internal HTXRestOptions Copy()
+        internal HTXRestOptions Set(HTXRestOptions targetOptions)
         {
-            var options = Copy<HTXRestOptions>();
-            options.SpotOptions = SpotOptions.Copy<RestApiOptions>();
-            options.UsdtMarginSwapOptions = UsdtMarginSwapOptions.Copy<RestApiOptions>();
-            options.SignPublicRequests = SignPublicRequests;
-            options.BrokerId = BrokerId;
-            return options;
+            targetOptions = base.Set<HTXRestOptions>(targetOptions);
+            targetOptions.SignPublicRequests = SignPublicRequests;
+            targetOptions.BrokerId = BrokerId;
+            targetOptions.SpotOptions = SpotOptions.Set(targetOptions.SpotOptions);
+            targetOptions.UsdtMarginSwapOptions = UsdtMarginSwapOptions.Set(targetOptions.UsdtMarginSwapOptions);
+            return targetOptions;
         }
     }
 }
diff --git a/HTX.Net/Objects/Options/HTXSocketOptions.cs b/HTX.Net/Objects/Options/HTXSocketOptions.cs
index 2c9d51dd..be8deacc 100644
--- a/HTX.Net/Objects/Options/HTXSocketOptions.cs
+++ b/HTX.Net/Objects/Options/HTXSocketOptions.cs
@@ -10,12 +10,20 @@ public class HTXSocketOptions : SocketExchangeOptions<HTXEnvironment>
         /// <summary>
         /// Default options for the HTXSocketClient
         /// </summary>
-        public static HTXSocketOptions Default { get; set; } = new HTXSocketOptions
+        internal static HTXSocketOptions Default { get; set; } = new HTXSocketOptions
         {
             Environment = HTXEnvironment.Live,
             SocketSubscriptionsCombineTarget = 10
         };
 
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public HTXSocketOptions()
+        {
+            Default?.Set(this);
+        }
+
         /// <summary>
         /// Broker id
         /// </summary>
@@ -31,13 +39,13 @@ public class HTXSocketOptions : SocketExchangeOptions<HTXEnvironment>
         /// </summary>
         public SocketApiOptions UsdtMarginSwapOptions { get; private set; } = new SocketApiOptions();
 
-        internal HTXSocketOptions Copy()
+        internal HTXSocketOptions Set(HTXSocketOptions targetOptions)
         {
-            var options = Copy<HTXSocketOptions>();
-            options.BrokerId = BrokerId;
-            options.SpotOptions = SpotOptions.Copy<SocketApiOptions>();
-            options.UsdtMarginSwapOptions = UsdtMarginSwapOptions.Copy<SocketApiOptions>();
-            return options;
+            targetOptions = base.Set<HTXSocketOptions>(targetOptions);
+            targetOptions.BrokerId = BrokerId;
+            targetOptions.SpotOptions = SpotOptions.Set(targetOptions.SpotOptions);
+            targetOptions.UsdtMarginSwapOptions = UsdtMarginSwapOptions.Set(targetOptions.UsdtMarginSwapOptions);
+            return targetOptions;
         }
     }
 }
diff --git a/docs/index.html b/docs/index.html
index 08a0e8eb..b633de2e 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -190,8 +190,14 @@ <h2>API Access</h2>
           
 		  <p>HTX.Net can be configured using Dotnet dependency injection, after which the clients can be injected into your services. It also correctly configures logging and HttpClient usage.</p>
 		  
-		  <pre><code>builder.Services.AddHTX(options => {
-  // Options can be configured here, for example:
+		  <pre><code>// Configure options from config file
+// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example
+builder.Services.AddHTX(builder.Configuration.GetSection("HTX"));
+		  
+// OR
+		  
+ builder.Services.AddHTX(options => {
+  // Configure options in code
   options.ApiCredentials = new ApiCredentials("APIKEY", "APISECRET");
 });</code></pre>