diff --git a/WhiteBit.Net.UnitTests/WhiteBitRestClientTests.cs b/WhiteBit.Net.UnitTests/WhiteBitRestClientTests.cs
index 3e50c3d..33e209a 100644
--- a/WhiteBit.Net.UnitTests/WhiteBitRestClientTests.cs
+++ b/WhiteBit.Net.UnitTests/WhiteBitRestClientTests.cs
@@ -1,10 +1,14 @@
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Clients;
 using CryptoExchange.Net.Converters.JsonNet;
+using CryptoExchange.Net.Objects;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
 using NUnit.Framework;
 using System.Collections.Generic;
 using System.Net.Http;
 using WhiteBit.Net.Clients;
+using WhiteBit.Net.Interfaces.Clients;
 
 namespace WhiteBit.Net.UnitTests
 {
@@ -42,5 +46,105 @@ public void CheckInterfaces()
             CryptoExchange.Net.Testing.TestHelpers.CheckForMissingRestInterfaces<WhiteBitRestClient>();
             CryptoExchange.Net.Testing.TestHelpers.CheckForMissingSocketInterfaces<WhiteBitSocketClient>();
         }
+
+        [Test]
+        [TestCase(TradeEnvironmentNames.Live, "https://whitebit.com")]
+        [TestCase("", "https://whitebit.com")]
+        public void TestConstructorEnvironments(string environmentName, string expected)
+        {
+            var configuration = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    { "WhiteBit:Environment:Name", environmentName },
+                }).Build();
+
+            var collection = new ServiceCollection();
+            collection.AddWhiteBit(configuration.GetSection("WhiteBit"));
+            var provider = collection.BuildServiceProvider();
+
+            var client = provider.GetRequiredService<IWhiteBitRestClient>();
+
+            var address = client.V4Api.BaseAddress;
+
+            Assert.That(address, Is.EqualTo(expected));
+        }
+
+        [Test]
+        public void TestConstructorNullEnvironment()
+        {
+            var configuration = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    { "WhiteBit", null },
+                }).Build();
+
+            var collection = new ServiceCollection();
+            collection.AddWhiteBit(configuration.GetSection("WhiteBit"));
+            var provider = collection.BuildServiceProvider();
+
+            var client = provider.GetRequiredService<IWhiteBitRestClient>();
+
+            var address = client.V4Api.BaseAddress;
+
+            Assert.That(address, Is.EqualTo("https://whitebit.com"));
+        }
+
+        [Test]
+        public void TestConstructorApiOverwriteEnvironment()
+        {
+            var configuration = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    { "WhiteBit:Environment:Name", "test" },
+                    { "WhiteBit:Rest:Environment:Name", "live" },
+                }).Build();
+
+            var collection = new ServiceCollection();
+            collection.AddWhiteBit(configuration.GetSection("WhiteBit"));
+            var provider = collection.BuildServiceProvider();
+
+            var client = provider.GetRequiredService<IWhiteBitRestClient>();
+
+            var address = client.V4Api.BaseAddress;
+
+            Assert.That(address, Is.EqualTo("https://whitebit.com"));
+        }
+
+        [Test]
+        public void TestConstructorConfiguration()
+        {
+            var configuration = new ConfigurationBuilder()
+                .AddInMemoryCollection(new Dictionary<string, string>
+                {
+                    { "ApiCredentials:Key", "123" },
+                    { "ApiCredentials:Secret", "456" },
+                    { "ApiCredentials:PassPhrase", "222" },
+                    { "Socket:ApiCredentials:Key", "456" },
+                    { "Socket:ApiCredentials:Secret", "789" },
+                    { "Socket:ApiCredentials:PassPhrase", "111" },
+                    { "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.AddWhiteBit(configuration);
+            var provider = collection.BuildServiceProvider();
+
+            var restClient = provider.GetRequiredService<IWhiteBitRestClient>();
+            var socketClient = provider.GetRequiredService<IWhiteBitSocketClient>();
+
+            Assert.That(((BaseApiClient)restClient.V4Api).OutputOriginalData, Is.True);
+            Assert.That(((BaseApiClient)socketClient.V4Api).OutputOriginalData, Is.False);
+            Assert.That(((BaseApiClient)restClient.V4Api).AuthenticationProvider.ApiKey, Is.EqualTo("123"));
+            Assert.That(((BaseApiClient)socketClient.V4Api).AuthenticationProvider.ApiKey, Is.EqualTo("456"));
+            Assert.That(((BaseApiClient)restClient.V4Api).ClientOptions.Proxy.Host, Is.EqualTo("host"));
+            Assert.That(((BaseApiClient)restClient.V4Api).ClientOptions.Proxy.Port, Is.EqualTo(80));
+            Assert.That(((BaseApiClient)socketClient.V4Api).ClientOptions.Proxy.Host, Is.EqualTo("host2"));
+            Assert.That(((BaseApiClient)socketClient.V4Api).ClientOptions.Proxy.Port, Is.EqualTo(81));
+        }
     }
 }
diff --git a/WhiteBit.Net.UnitTests/WhiteBitRestIntegrationTests.cs b/WhiteBit.Net.UnitTests/WhiteBitRestIntegrationTests.cs
index 243420a..bd3c72b 100644
--- a/WhiteBit.Net.UnitTests/WhiteBitRestIntegrationTests.cs
+++ b/WhiteBit.Net.UnitTests/WhiteBitRestIntegrationTests.cs
@@ -9,6 +9,7 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using Microsoft.Extensions.Options;
 
 namespace WhiteBit.Net.UnitTests
 {
@@ -27,11 +28,11 @@ public override WhiteBitRestClient GetClient(ILoggerFactory loggerFactory)
             var sec = Environment.GetEnvironmentVariable("APISECRET");
 
             Authenticated = key != null && sec != null;
-            return new WhiteBitRestClient(null, loggerFactory, opts =>
+            return new WhiteBitRestClient(null, loggerFactory, Options.Create(new Objects.Options.WhiteBitRestOptions
             {
-                opts.OutputOriginalData = true;
-                opts.ApiCredentials = Authenticated ? new ApiCredentials(key, sec) : null;
-            });
+                OutputOriginalData = true,
+                ApiCredentials = Authenticated ? new ApiCredentials(key, sec) : null
+            }));
         }
 
         [Test]
diff --git a/WhiteBit.Net/Clients/WhiteBitRestClient.cs b/WhiteBit.Net/Clients/WhiteBitRestClient.cs
index 7721dff..c2726b5 100644
--- a/WhiteBit.Net/Clients/WhiteBitRestClient.cs
+++ b/WhiteBit.Net/Clients/WhiteBitRestClient.cs
@@ -7,6 +7,7 @@
 using CryptoExchange.Net.Clients;
 using WhiteBit.Net.Interfaces.Clients.V4Api;
 using WhiteBit.Net.Clients.V4Api;
+using Microsoft.Extensions.Options;
 
 namespace WhiteBit.Net.Clients
 {
@@ -28,24 +29,22 @@ public class WhiteBitRestClient : BaseRestClient, IWhiteBitRestClient
         /// Create a new instance of the WhiteBitRestClient using provided options
         /// </summary>
         /// <param name="optionsDelegate">Option configuration delegate</param>
-        public WhiteBitRestClient(Action<WhiteBitRestOptions>? optionsDelegate = null) : this(null, null, optionsDelegate)
+        public WhiteBitRestClient(Action<WhiteBitRestOptions>? optionsDelegate = null)
+            : this(null, null, Options.Create(ApplyOptionsDelegate(optionsDelegate)))
         {
         }
 
         /// <summary>
         /// Create a new instance of the WhiteBitRestClient using provided options
         /// </summary>
-        /// <param name="optionsDelegate">Option configuration delegate</param>
+        /// <param name="options">Option configuration</param>
         /// <param name="loggerFactory">The logger factory</param>
         /// <param name="httpClient">Http client for this client</param>
-        public WhiteBitRestClient(HttpClient? httpClient, ILoggerFactory? loggerFactory, Action<WhiteBitRestOptions>? optionsDelegate = null) : base(loggerFactory, "WhiteBit")
+        public WhiteBitRestClient(HttpClient? httpClient, ILoggerFactory? loggerFactory, IOptions<WhiteBitRestOptions> options) : base(loggerFactory, "WhiteBit")
         {
-            var options = WhiteBitRestOptions.Default.Copy();
-            if (optionsDelegate != null)
-                optionsDelegate(options);
-            Initialize(options);
+            Initialize(options.Value);
 
-            V4Api = AddApiClient(new WhiteBitRestClientV4Api(_logger, httpClient, options));
+            V4Api = AddApiClient(new WhiteBitRestClientV4Api(_logger, httpClient, options.Value));
         }
 
         #endregion
@@ -56,9 +55,7 @@ public WhiteBitRestClient(HttpClient? httpClient, ILoggerFactory? loggerFactory,
         /// <param name="optionsDelegate">Option configuration delegate</param>
         public static void SetDefaultOptions(Action<WhiteBitRestOptions> optionsDelegate)
         {
-            var options = WhiteBitRestOptions.Default.Copy();
-            optionsDelegate(options);
-            WhiteBitRestOptions.Default = options;
+            WhiteBitRestOptions.Default = ApplyOptionsDelegate(optionsDelegate);
         }
 
         /// <inheritdoc />
diff --git a/WhiteBit.Net/Clients/WhiteBitSocketClient.cs b/WhiteBit.Net/Clients/WhiteBitSocketClient.cs
index 2420b14..8277698 100644
--- a/WhiteBit.Net/Clients/WhiteBitSocketClient.cs
+++ b/WhiteBit.Net/Clients/WhiteBitSocketClient.cs
@@ -1,6 +1,7 @@
 using CryptoExchange.Net.Authentication;
 using CryptoExchange.Net.Clients;
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using System;
 using WhiteBit.Net.Clients.V4Api;
 using WhiteBit.Net.Interfaces.Clients;
@@ -23,19 +24,12 @@ public class WhiteBitSocketClient : BaseSocketClient, IWhiteBitSocketClient
         #endregion
 
         #region constructor/destructor
-        /// <summary>
-        /// Create a new instance of WhiteBitSocketClient
-        /// </summary>
-        /// <param name="loggerFactory">The logger factory</param>
-        public WhiteBitSocketClient(ILoggerFactory? loggerFactory = null) : this((x) => { }, loggerFactory)
-        {
-        }
-
         /// <summary>
         /// Create a new instance of WhiteBitSocketClient
         /// </summary>
         /// <param name="optionsDelegate">Option configuration delegate</param>
-        public WhiteBitSocketClient(Action<WhiteBitSocketOptions> optionsDelegate) : this(optionsDelegate, null)
+        public WhiteBitSocketClient(Action<WhiteBitSocketOptions>? optionsDelegate = null)
+            : this(Options.Create(ApplyOptionsDelegate(optionsDelegate)), null)
         {
         }
 
@@ -43,14 +37,12 @@ public WhiteBitSocketClient(Action<WhiteBitSocketOptions> optionsDelegate) : thi
         /// Create a new instance of WhiteBitSocketClient
         /// </summary>
         /// <param name="loggerFactory">The logger factory</param>
-        /// <param name="optionsDelegate">Option configuration delegate</param>
-        public WhiteBitSocketClient(Action<WhiteBitSocketOptions>? optionsDelegate, ILoggerFactory? loggerFactory = null) : base(loggerFactory, "WhiteBit")
+        /// <param name="options">Option configuration</param>
+        public WhiteBitSocketClient(IOptions<WhiteBitSocketOptions> options, ILoggerFactory? loggerFactory = null) : base(loggerFactory, "WhiteBit")
         {
-            var options = WhiteBitSocketOptions.Default.Copy();
-            optionsDelegate?.Invoke(options);
-            Initialize(options);
-                        
-            V4Api = AddApiClient(new WhiteBitSocketClientV4Api(_logger, options));
+            Initialize(options.Value);
+
+            V4Api = AddApiClient(new WhiteBitSocketClientV4Api(_logger, options.Value));
         }
         #endregion
 
@@ -60,9 +52,7 @@ public WhiteBitSocketClient(Action<WhiteBitSocketOptions>? optionsDelegate, ILog
         /// <param name="optionsDelegate">Option configuration delegate</param>
         public static void SetDefaultOptions(Action<WhiteBitSocketOptions> optionsDelegate)
         {
-            var options = WhiteBitSocketOptions.Default.Copy();
-            optionsDelegate(options);
-            WhiteBitSocketOptions.Default = options;
+            WhiteBitSocketOptions.Default = ApplyOptionsDelegate(optionsDelegate);
         }
 
         /// <inheritdoc />
diff --git a/WhiteBit.Net/ExtensionMethods/ServiceCollectionExtensions.cs b/WhiteBit.Net/ExtensionMethods/ServiceCollectionExtensions.cs
index ec5ac30..b6d7557 100644
--- a/WhiteBit.Net/ExtensionMethods/ServiceCollectionExtensions.cs
+++ b/WhiteBit.Net/ExtensionMethods/ServiceCollectionExtensions.cs
@@ -1,6 +1,9 @@
 using CryptoExchange.Net;
 using CryptoExchange.Net.Clients;
 using CryptoExchange.Net.Interfaces;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using System;
 using System.Net;
 using System.Net.Http;
@@ -18,47 +21,115 @@ namespace Microsoft.Extensions.DependencyInjection
     /// </summary>
     public static class ServiceCollectionExtensions
     {
+
+        /// <summary>
+        /// Add services such as the IWhiteBitRestClient and IWhiteBitSocketClient. 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>
+        public static IServiceCollection AddWhiteBit(
+            this IServiceCollection services,
+            IConfiguration configuration)
+        {
+            var options = new WhiteBitOptions();
+            // Reset environment so we know if theyre overriden
+            options.Rest.Environment = null!;
+            options.Socket.Environment = null!;
+            configuration.Bind(options);
+
+            if (options.Rest == null || options.Socket == null)
+                throw new ArgumentException("Options null");
+
+            var restEnvName = options.Rest.Environment?.Name ?? options.Environment?.Name ?? WhiteBitEnvironment.Live.Name;
+            var socketEnvName = options.Socket.Environment?.Name ?? options.Environment?.Name ?? WhiteBitEnvironment.Live.Name;
+            options.Rest.Environment = WhiteBitEnvironment.GetEnvironmentByName(restEnvName) ?? options.Rest.Environment!;
+            options.Rest.ApiCredentials = options.Rest.ApiCredentials ?? options.ApiCredentials;
+            options.Socket.Environment = WhiteBitEnvironment.GetEnvironmentByName(socketEnvName) ?? options.Socket.Environment!;
+            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 AddWhiteBitCore(services, options.SocketClientLifeTime);
+        }
+
         /// <summary>
-        /// Add the IWhiteBitRestClient and IWhiteBitSocketClient to the sevice collection so they can be injected
+        /// Add services such as the IWhiteBitRestClient and IWhiteBitSocketClient. 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 IWhiteBitSocketClient for the service collection. Defaults to Singleton.</param>
+        /// <param name="optionsDelegate">Set options for the WhiteBit services</param>
         /// <returns></returns>
         public static IServiceCollection AddWhiteBit(
             this IServiceCollection services,
-            Action<WhiteBitRestOptions>? defaultRestOptionsDelegate = null,
-            Action<WhiteBitSocketOptions>? defaultSocketOptionsDelegate = null,
+            Action<WhiteBitOptions>? optionsDelegate = null)
+        {
+            var options = new WhiteBitOptions();
+            // 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 ?? WhiteBitEnvironment.Live;
+            options.Rest.ApiCredentials = options.Rest.ApiCredentials ?? options.ApiCredentials;
+            options.Socket.Environment = options.Socket.Environment ?? options.Environment ?? WhiteBitEnvironment.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 AddWhiteBitCore(services, options.SocketClientLifeTime);
+        }
+
+        /// <summary>
+        /// DEPRECATED; use <see cref="AddWhiteBit(IServiceCollection, Action{WhiteBitOptions}?)" /> instead
+        /// </summary>
+        public static IServiceCollection AddWhiteBit(
+            this IServiceCollection services,
+            Action<WhiteBitRestOptions> restDelegate,
+            Action<WhiteBitSocketOptions>? socketDelegate = null,
             ServiceLifetime? socketClientLifeTime = null)
         {
-            var restOptions = WhiteBitRestOptions.Default.Copy();
+            services.Configure<WhiteBitRestOptions>((x) => { restDelegate?.Invoke(x); });
+            services.Configure<WhiteBitSocketOptions>((x) => { socketDelegate?.Invoke(x); });
 
-            if (defaultRestOptionsDelegate != null)
-            {
-                defaultRestOptionsDelegate(restOptions);
-                WhiteBitRestClient.SetDefaultOptions(defaultRestOptionsDelegate);
-            }
+            return AddWhiteBitCore(services, socketClientLifeTime);
+        }
 
-            if (defaultSocketOptionsDelegate != null)
-                WhiteBitSocketClient.SetDefaultOptions(defaultSocketOptionsDelegate);
+        private static IServiceCollection AddWhiteBitCore(
+            this IServiceCollection services,
+            ServiceLifetime? socketClientLifeTime = null)
+        {
 
-            services.AddHttpClient<IWhiteBitRestClient, WhiteBitRestClient>(options =>
-            {
-                options.Timeout = restOptions.RequestTimeout;
-            }).ConfigurePrimaryHttpMessageHandler(() =>
+            services.AddHttpClient<IWhiteBitRestClient, WhiteBitRestClient>((client, serviceProvider) =>
             {
+                var options = serviceProvider.GetRequiredService<IOptions<WhiteBitRestOptions>>().Value;
+                client.Timeout = options.RequestTimeout;
+                return new WhiteBitRestClient(client, serviceProvider.GetRequiredService<ILoggerFactory>(), serviceProvider.GetRequiredService<IOptions<WhiteBitRestOptions>>());
+            }).ConfigurePrimaryHttpMessageHandler((serviceProvider) => {
                 var handler = new HttpClientHandler();
-                if (restOptions.Proxy != null)
+                try
+                {
+                    handler.AutomaticDecompression = DecompressionMethods.GZip | DecompressionMethods.Deflate;
+                }
+                catch (PlatformNotSupportedException)
+                { }
+
+                var options = serviceProvider.GetRequiredService<IOptions<WhiteBitRestOptions>>().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(IWhiteBitSocketClient), x => { return new WhiteBitSocketClient(x.GetRequiredService<IOptions<WhiteBitSocketOptions>>(), x.GetRequiredService<ILoggerFactory>()); }, socketClientLifeTime ?? ServiceLifetime.Singleton));
 
             services.AddTransient<ICryptoRestClient, CryptoRestClient>();
             services.AddSingleton<ICryptoSocketClient, CryptoSocketClient>();
@@ -67,11 +138,6 @@ public static IServiceCollection AddWhiteBit(
 
             services.RegisterSharedRestInterfaces(x => x.GetRequiredService<IWhiteBitRestClient>().V4Api.SharedClient);
             services.RegisterSharedSocketInterfaces(x => x.GetRequiredService<IWhiteBitSocketClient>().V4Api.SharedClient);
-
-            if (socketClientLifeTime == null)
-                services.AddSingleton<IWhiteBitSocketClient, WhiteBitSocketClient>();
-            else
-                services.Add(new ServiceDescriptor(typeof(IWhiteBitSocketClient), typeof(WhiteBitSocketClient), socketClientLifeTime.Value));
             return services;
         }
     }
diff --git a/WhiteBit.Net/Objects/Options/WhiteBitOptions.cs b/WhiteBit.Net/Objects/Options/WhiteBitOptions.cs
new file mode 100644
index 0000000..7d5f67a
--- /dev/null
+++ b/WhiteBit.Net/Objects/Options/WhiteBitOptions.cs
@@ -0,0 +1,39 @@
+using CryptoExchange.Net.Authentication;
+using Microsoft.Extensions.DependencyInjection;
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace WhiteBit.Net.Objects.Options
+{
+    /// <summary>
+    /// WhiteBit options
+    /// </summary>
+    public class WhiteBitOptions
+    {
+        /// <summary>
+        /// Rest client options
+        /// </summary>
+        public WhiteBitRestOptions Rest { get; set; } = new WhiteBitRestOptions();
+
+        /// <summary>
+        /// Socket client options
+        /// </summary>
+        public WhiteBitSocketOptions Socket { get; set; } = new WhiteBitSocketOptions();
+
+        /// <summary>
+        /// Trade environment. Contains info about URL's to use to connect to the API. Use `WhiteBitEnvironment` to swap environment, for example `Environment = WhiteBitEnvironment.Live`
+        /// </summary>
+        public WhiteBitEnvironment? Environment { get; set; }
+
+        /// <summary>
+        /// The api credentials used for signing requests.
+        /// </summary>
+        public ApiCredentials? ApiCredentials { get; set; }
+
+        /// <summary>
+        /// The DI service lifetime for the IWhiteBitSocketClient
+        /// </summary>
+        public ServiceLifetime? SocketClientLifeTime { get; set; }
+    }
+}
diff --git a/WhiteBit.Net/Objects/Options/WhiteBitRestOptions.cs b/WhiteBit.Net/Objects/Options/WhiteBitRestOptions.cs
index 85b5fce..0a749e7 100644
--- a/WhiteBit.Net/Objects/Options/WhiteBitRestOptions.cs
+++ b/WhiteBit.Net/Objects/Options/WhiteBitRestOptions.cs
@@ -10,14 +10,21 @@ public class WhiteBitRestOptions : RestExchangeOptions<WhiteBitEnvironment>
         /// <summary>
         /// Default options for new clients
         /// </summary>
-        public static WhiteBitRestOptions Default { get; set; } = new WhiteBitRestOptions()
+        internal static WhiteBitRestOptions Default { get; set; } = new WhiteBitRestOptions()
         {
             Environment = WhiteBitEnvironment.Live,
             AutoTimestamp = true
         };
 
-        
-         /// <summary>
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public WhiteBitRestOptions()
+        {
+            Default?.Set(this);
+        }
+
+        /// <summary>
         /// V4 API options
         /// </summary>
         public RestApiOptions V4Options { get; private set; } = new RestApiOptions();
@@ -27,13 +34,12 @@ public class WhiteBitRestOptions : RestExchangeOptions<WhiteBitEnvironment>
         /// </summary>
         public bool EnableNonceWindow { get; set; } = false;
 
-        internal WhiteBitRestOptions Copy()
+        internal WhiteBitRestOptions Set(WhiteBitRestOptions targetOptions)
         {
-            var options = Copy<WhiteBitRestOptions>();
-            options.EnableNonceWindow = EnableNonceWindow;
-            options.V4Options = V4Options.Copy<RestApiOptions>();
-
-            return options;
+            targetOptions = base.Set<WhiteBitRestOptions>(targetOptions);
+            targetOptions.EnableNonceWindow = EnableNonceWindow;
+            targetOptions.V4Options = V4Options.Set(targetOptions.V4Options);
+            return targetOptions;
         }
     }
 }
diff --git a/WhiteBit.Net/Objects/Options/WhiteBitSocketOptions.cs b/WhiteBit.Net/Objects/Options/WhiteBitSocketOptions.cs
index 498ad9e..b2ae80d 100644
--- a/WhiteBit.Net/Objects/Options/WhiteBitSocketOptions.cs
+++ b/WhiteBit.Net/Objects/Options/WhiteBitSocketOptions.cs
@@ -10,26 +10,31 @@ public class WhiteBitSocketOptions : SocketExchangeOptions<WhiteBitEnvironment>
         /// <summary>
         /// Default options for new clients
         /// </summary>
-        public static WhiteBitSocketOptions Default { get; set; } = new WhiteBitSocketOptions()
+        internal static WhiteBitSocketOptions Default { get; set; } = new WhiteBitSocketOptions()
         {
             Environment = WhiteBitEnvironment.Live,
             SocketSubscriptionsCombineTarget = 10
         };
 
-        
-         /// <summary>
+        /// <summary>
+        /// ctor
+        /// </summary>
+        public WhiteBitSocketOptions()
+        {
+            Default?.Set(this);
+        }
+
+        /// <summary>
         /// V4 API options
         /// </summary>
         public SocketApiOptions V4Options { get; private set; } = new SocketApiOptions();
 
 
-        internal WhiteBitSocketOptions Copy()
+        internal WhiteBitSocketOptions Set(WhiteBitSocketOptions targetOptions)
         {
-            var options = Copy<WhiteBitSocketOptions>();
-            
-            options.V4Options = V4Options.Copy<SocketApiOptions>();
-
-            return options;
+            targetOptions = base.Set<WhiteBitSocketOptions>(targetOptions);
+            targetOptions.V4Options = V4Options.Set(targetOptions.V4Options);
+            return targetOptions;
         }
     }
 }
diff --git a/WhiteBit.Net/WhiteBit.Net.csproj b/WhiteBit.Net/WhiteBit.Net.csproj
index da33a03..486dce6 100644
--- a/WhiteBit.Net/WhiteBit.Net.csproj
+++ b/WhiteBit.Net/WhiteBit.Net.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
   <PropertyGroup>
     <TargetFrameworks>netstandard2.0;netstandard2.1</TargetFrameworks>
     <LangVersion>12.0</LangVersion>
@@ -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/WhiteBit.Net/WhiteBit.Net.xml b/WhiteBit.Net/WhiteBit.Net.xml
index fcb4319..1c02508 100644
--- a/WhiteBit.Net/WhiteBit.Net.xml
+++ b/WhiteBit.Net/WhiteBit.Net.xml
@@ -377,11 +377,11 @@
             </summary>
             <param name="optionsDelegate">Option configuration delegate</param>
         </member>
-        <member name="M:WhiteBit.Net.Clients.WhiteBitRestClient.#ctor(System.Net.Http.HttpClient,Microsoft.Extensions.Logging.ILoggerFactory,System.Action{WhiteBit.Net.Objects.Options.WhiteBitRestOptions})">
+        <member name="M:WhiteBit.Net.Clients.WhiteBitRestClient.#ctor(System.Net.Http.HttpClient,Microsoft.Extensions.Logging.ILoggerFactory,Microsoft.Extensions.Options.IOptions{WhiteBit.Net.Objects.Options.WhiteBitRestOptions})">
             <summary>
             Create a new instance of the WhiteBitRestClient using provided options
             </summary>
-            <param name="optionsDelegate">Option configuration delegate</param>
+            <param name="options">Option configuration</param>
             <param name="loggerFactory">The logger factory</param>
             <param name="httpClient">Http client for this client</param>
         </member>
@@ -400,24 +400,18 @@
         <member name="P:WhiteBit.Net.Clients.WhiteBitSocketClient.V4Api">
             <inheritdoc />
         </member>
-        <member name="M:WhiteBit.Net.Clients.WhiteBitSocketClient.#ctor(Microsoft.Extensions.Logging.ILoggerFactory)">
-            <summary>
-            Create a new instance of WhiteBitSocketClient
-            </summary>
-            <param name="loggerFactory">The logger factory</param>
-        </member>
         <member name="M:WhiteBit.Net.Clients.WhiteBitSocketClient.#ctor(System.Action{WhiteBit.Net.Objects.Options.WhiteBitSocketOptions})">
             <summary>
             Create a new instance of WhiteBitSocketClient
             </summary>
             <param name="optionsDelegate">Option configuration delegate</param>
         </member>
-        <member name="M:WhiteBit.Net.Clients.WhiteBitSocketClient.#ctor(System.Action{WhiteBit.Net.Objects.Options.WhiteBitSocketOptions},Microsoft.Extensions.Logging.ILoggerFactory)">
+        <member name="M:WhiteBit.Net.Clients.WhiteBitSocketClient.#ctor(Microsoft.Extensions.Options.IOptions{WhiteBit.Net.Objects.Options.WhiteBitSocketOptions},Microsoft.Extensions.Logging.ILoggerFactory)">
             <summary>
             Create a new instance of WhiteBitSocketClient
             </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:WhiteBit.Net.Clients.WhiteBitSocketClient.SetDefaultOptions(System.Action{WhiteBit.Net.Objects.Options.WhiteBitSocketOptions})">
             <summary>
@@ -4543,6 +4537,36 @@
             Side
             </summary>
         </member>
+        <member name="T:WhiteBit.Net.Objects.Options.WhiteBitOptions">
+            <summary>
+            WhiteBit options
+            </summary>
+        </member>
+        <member name="P:WhiteBit.Net.Objects.Options.WhiteBitOptions.Rest">
+            <summary>
+            Rest client options
+            </summary>
+        </member>
+        <member name="P:WhiteBit.Net.Objects.Options.WhiteBitOptions.Socket">
+            <summary>
+            Socket client options
+            </summary>
+        </member>
+        <member name="P:WhiteBit.Net.Objects.Options.WhiteBitOptions.Environment">
+            <summary>
+            Trade environment. Contains info about URL's to use to connect to the API. Use `WhiteBitEnvironment` to swap environment, for example `Environment = WhiteBitEnvironment.Live`
+            </summary>
+        </member>
+        <member name="P:WhiteBit.Net.Objects.Options.WhiteBitOptions.ApiCredentials">
+            <summary>
+            The api credentials used for signing requests.
+            </summary>
+        </member>
+        <member name="P:WhiteBit.Net.Objects.Options.WhiteBitOptions.SocketClientLifeTime">
+            <summary>
+            The DI service lifetime for the IWhiteBitSocketClient
+            </summary>
+        </member>
         <member name="T:WhiteBit.Net.Objects.Options.WhiteBitOrderBookOptions">
             <summary>
             Options for the WhiteBit SymbolOrderBook
@@ -4573,6 +4597,11 @@
             Default options for new clients
             </summary>
         </member>
+        <member name="M:WhiteBit.Net.Objects.Options.WhiteBitRestOptions.#ctor">
+            <summary>
+            ctor
+            </summary>
+        </member>
         <member name="P:WhiteBit.Net.Objects.Options.WhiteBitRestOptions.V4Options">
             <summary>
             V4 API options
@@ -4593,6 +4622,11 @@
             Default options for new clients
             </summary>
         </member>
+        <member name="M:WhiteBit.Net.Objects.Options.WhiteBitSocketOptions.#ctor">
+            <summary>
+            ctor
+            </summary>
+        </member>
         <member name="P:WhiteBit.Net.Objects.Options.WhiteBitSocketOptions.V4Options">
             <summary>
             V4 API options
@@ -4849,6 +4883,16 @@
             Socket API address
             </summary>
         </member>
+        <member name="M:WhiteBit.Net.WhiteBitEnvironment.#ctor">
+            <summary>
+            ctor for DI, use <see cref="M:WhiteBit.Net.WhiteBitEnvironment.CreateCustom(System.String,System.String,System.String)"/> for creating a custom environment
+            </summary>
+        </member>
+        <member name="M:WhiteBit.Net.WhiteBitEnvironment.GetEnvironmentByName(System.String)">
+            <summary>
+            Get the WhiteBit environment by name
+            </summary>
+        </member>
         <member name="P:WhiteBit.Net.WhiteBitEnvironment.Live">
             <summary>
             Live environment
@@ -4873,6 +4917,16 @@
             Exchange name
             </summary>
         </member>
+        <member name="P:WhiteBit.Net.WhiteBitExchange.DisplayName">
+            <summary>
+            Exchange name
+            </summary>
+        </member>
+        <member name="P:WhiteBit.Net.WhiteBitExchange.ImageUrl">
+            <summary>
+            Url to exchange image
+            </summary>
+        </member>
         <member name="P:WhiteBit.Net.WhiteBitExchange.Url">
             <summary>
             Url to the main website
@@ -4949,15 +5003,26 @@
             Extensions for DI
             </summary>
         </member>
-        <member name="M:Microsoft.Extensions.DependencyInjection.ServiceCollectionExtensions.AddWhiteBit(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Action{WhiteBit.Net.Objects.Options.WhiteBitRestOptions},System.Action{WhiteBit.Net.Objects.Options.WhiteBitSocketOptions},System.Nullable{Microsoft.Extensions.DependencyInjection.ServiceLifetime})">
+        <member name="M:Microsoft.Extensions.DependencyInjection.ServiceCollectionExtensions.AddWhiteBit(Microsoft.Extensions.DependencyInjection.IServiceCollection,Microsoft.Extensions.Configuration.IConfiguration)">
+            <summary>
+            Add services such as the IWhiteBitRestClient and IWhiteBitSocketClient. 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.AddWhiteBit(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Action{WhiteBit.Net.Objects.Options.WhiteBitOptions})">
             <summary>
-            Add the IWhiteBitRestClient and IWhiteBitSocketClient to the sevice collection so they can be injected
+            Add services such as the IWhiteBitRestClient and IWhiteBitSocketClient. 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 IWhiteBitSocketClient for the service collection. Defaults to Singleton.</param>
+            <param name="optionsDelegate">Set options for the WhiteBit services</param>
             <returns></returns>
         </member>
+        <member name="M:Microsoft.Extensions.DependencyInjection.ServiceCollectionExtensions.AddWhiteBit(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Action{WhiteBit.Net.Objects.Options.WhiteBitRestOptions},System.Action{WhiteBit.Net.Objects.Options.WhiteBitSocketOptions},System.Nullable{Microsoft.Extensions.DependencyInjection.ServiceLifetime})">
+            <summary>
+            DEPRECATED; use <see cref="M:Microsoft.Extensions.DependencyInjection.ServiceCollectionExtensions.AddWhiteBit(Microsoft.Extensions.DependencyInjection.IServiceCollection,System.Action{WhiteBit.Net.Objects.Options.WhiteBitOptions})" /> instead
+            </summary>
+        </member>
     </members>
 </doc>
diff --git a/WhiteBit.Net/WhiteBitEnvironment.cs b/WhiteBit.Net/WhiteBitEnvironment.cs
index 2f49ac8..84f53bd 100644
--- a/WhiteBit.Net/WhiteBitEnvironment.cs
+++ b/WhiteBit.Net/WhiteBitEnvironment.cs
@@ -28,6 +28,26 @@ internal WhiteBitEnvironment(
             SocketClientAddress = streamAddress;
         }
 
+        /// <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 WhiteBitEnvironment() : 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 WhiteBit environment by name
+        /// </summary>
+        public static WhiteBitEnvironment? GetEnvironmentByName(string? name)
+         => name switch
+         {
+             TradeEnvironmentNames.Live => Live,
+             "" => Live,
+             null => Live,
+             _ => default
+         };
+
         /// <summary>
         /// Live environment
         /// </summary>
diff --git a/WhiteBit.Net/WhiteBitExchange.cs b/WhiteBit.Net/WhiteBitExchange.cs
index 3ca1c78..84e8d92 100644
--- a/WhiteBit.Net/WhiteBitExchange.cs
+++ b/WhiteBit.Net/WhiteBitExchange.cs
@@ -20,6 +20,16 @@ public static class WhiteBitExchange
         /// </summary>
         public static string ExchangeName => "WhiteBit";
 
+        /// <summary>
+        /// Exchange name
+        /// </summary>
+        public static string DisplayName => "WhiteBit";
+
+        /// <summary>
+        /// Url to exchange image
+        /// </summary>
+        public static string ImageUrl { get; } = "https://raw.githubusercontent.com/JKorf/WhiteBit.Net/master/WhiteBit.Net/Icon/icon.png";
+
         /// <summary>
         /// Url to the main website
         /// </summary>
diff --git a/docs/index.html b/docs/index.html
index d188328..99e3144 100644
--- a/docs/index.html
+++ b/docs/index.html
@@ -189,8 +189,14 @@ <h2>API Access</h2>
           
 		  <p>WhiteBit.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.AddWhiteBit(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.AddWhiteBit(builder.Configuration.GetSection("WhiteBit"));
+		  
+// OR
+		  
+ builder.Services.AddWhiteBit(options => {
+  // Configure options in code
   options.ApiCredentials = new ApiCredentials("APIKEY", "APISECRET");
 });</code></pre>