dotnet add package JK.BingX.Net

dotnet add package Bitfinex.Net

dotnet add package JK.Bitget.Net

dotnet add package BitMart.Net

dotnet add package Bybit.Net

dotnet add package CoinGecko.Net

dotnet add package JKorf.Coinbase.Net

dotnet add package CoinEx.Net

dotnet add package CryptoCom.Net

dotnet add package GateIo.Net

dotnet add package JKorf.HTX.Net

dotnet add package HyperLiquid.Net

dotnet add package KrakenExchange.Net

dotnet add package Kucoin.Net

dotnet add package JK.Mexc.Net

dotnet add package JK.OKX.Net

dotnet add package WhiteBit.Net

dotnet add package XT.Net

builder.Services.AddBinance();

builder.Services.AddBingX();

builder.Services.AddBitfinex();

builder.Services.AddBitget();

builder.Services.AddBitMart();

builder.Services.AddBybit();

builder.Services.AddCoinbase();

builder.Services.AddCoinGecko();

builder.Services.AddCoinEx();

builder.Services.AddCryptoCom();

builder.Services.AddGateIo();

builder.Services.AddHTX();

builder.Services.AddHyperLiquid();

builder.Services.AddKraken();

builder.Services.AddKucoin();

builder.Services.AddMexc();

builder.Services.AddOKX();

builder.Services.AddWhiteBit();

builder.Services.AddXT();

var client = new BinanceRestClient();
var tickersResult = await client.SpotApi.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new BingXRestClient();
var tickersResult = await client.SpotApi.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new BitfinexRestClient();
var tickersResult = await client.SpotApi.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new BitgetRestClient();
var tickersResult = await client.SpotApi.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new BitMartRestClient();
var tickersResult = await client.SpotApi.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new BybitRestClient();
var tickersResult = await client.V5Api.ExchangeData.GetSpotTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new CoinbaseRestClient();
var tickersResult = await client.AdvancedTradeApi.ExchangeData.GetSymbolsAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new CoinGeckoRestClient();
var assetsResult = await client.Api.GetAssetsAsync();
if (!assetsResult.Success)
{
  // Handle error, assetsResult.Error contains more information
}
else
{
  // Handle data, assetsResult.Data will contain the actual data
}

var client = new CoinExRestClient();
var tickersResult = await client.SpotApiV2.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new CryptoComRestClient();
var tickersResult = await client.ExchangeApi.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new GateIoRestClient();
var tickersResult = await client.SpotApi.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new HTXRestClient();
var tickersResult = await client.SpotApi.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new HyperLiquidRestClient();
var tickersResult = await client.SpotApi.ExchangeData.GetExchangeInfoAndTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new KrakenRestClient();
var tickersResult = await client.SpotApi.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new KucoinRestClient();
var tickersResult = await client.SpotApi.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new MexcRestClient();
var tickersResult = await client.SpotApi.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new OKXRestClient();
var tickersResult = await client.UnifiedApi.ExchangeData.GetTickersAsync(OKXInstrumentType.Spot);
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new WhiteBitRestClient();
var tickersResult = await client.V4Api.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new XTRestClient();
var tickersResult = await client.SpotApi.ExchangeData.GetTickersAsync();
if (!tickersResult.Success)
{
  // Handle error, tickersResult.Error contains more information
}
else
{
  // Handle data, tickersResult.Data will contain the actual data
}

var client = new BinanceSocketClient();
var subscribeResult = await client.SpotApi.ExchangeData.SubscribeToAllTickerUpdatesAsync(update => {
  // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new BingXSocketClient();
var subscribeResult = await client.SpotApi.SubscribeToTickerUpdatesAsync("ETH-USDT", update => {
  // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new BitfinexSocketClient();
var subscribeResult = await client.SpotApi.SubscribeToTickerUpdatesAsync("tETHUST", update => {
  // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new BitgetSocketClient();
var subscribeResult = await client.SpotApi.SubscribeToTickerUpdatesAsync("ETHUSDT", update => {
  // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new BitMartSocketClient();
var subscribeResult = await client.SpotApi.SubscribeToTickerUpdatesAsync("ETH_USDT", update => {
  // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new BybitSocketClient();
var subscribeResult = await client.V5SpotApi.SubscribeToTickerUpdatesAsync("ETHUSDT", update => {
    // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new CoinbaseSocketClient();
var subscribeResult = await sclient.AdvancedTradeApi.SubscribeToTickerUpdatesAsync("ETH-USDT", update => {
    // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
    // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new CoinExSocketClient();
var subscribeResult = await sclient.SpotApiV2.SubscribeToTickerUpdatesAsync(new[] { "ETHUSDT" }, update => {
    // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
    // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new CryptoComSocketClient();
var subscribeResult = await client.ExchangeApi.SubscribeToTickerUpdatesAsync("ETH_USD", update => {
  // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new GateIoSocketClient();
var subscribeResult = await client.SpotApi.SubscribeToTickerUpdatesAsync("ETH_USDT", update => {
  // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new HTXSocketClient();
var subscribeResult = await client.SpotApi.SubscribeToTickerUpdatesAsync(update => {
  // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new HyperLiquidSocketClient();
var subscribeResult = await client.SpotApi.SubscribeToSymbolUpdatesAsync("HYPE/USDC", update => {
  // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new KrakenSocketClient();
var subscribeResult = await client.SpotApi.SubscribeToTickerUpdatesAsync("ETH/USD", update => {
  // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new KucoinSocketClient();
var subscribeResult = await client.SpotApi.SubscribeToAllTickerUpdatesAsync(update => {
  // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new MexcSocketClient();
var subscribeResult = await client.SpotApi.SubscribeToMiniTickerUpdatesAsync(update => {
  // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new OKXSocketClient();
var subscribeResult = await client.UnifiedApi.ExchangeData.SubscribeToTickerUpdatesAsync("ETH-USDT", update => {
    // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new WhiteBitSocketClient();
var subscribeResult = await client.V4Api.ExchangeData.SubscribeToTickerUpdatesAsync("ETH_USDT", update => {
    // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

var client = new XTSocketClient();
var subscribeResult = await client.SpotApi.ExchangeData.SubscribeToTickerUpdatesAsync("eth_usdt", update => {
    // Handle the data update, update.Data will contain the actual data
});
if (!subscribeResult.Success)
{
  // Handle error, subscribeResult.Error contains more information on why the subscription failed
}
// Subscribing was successfull, the data will now be streamed into the data handler

// Spot API common functionality rest client
var spotSharedRestClients = bingXRestClient.SpotApi.SharedClient; 

// Spot API common functionality socket client
var spotSharedSocketClient = bingXSocketClient.SpotApi.SharedClient; 

// Perpetual Futures API common functionality rest client
var usdFuturesSharedRestClient = bingXRestClient.PerpetualFuturesApi.SharedClient;

// Perpetual Futures API common functionality socket client
var usdFuturesSharedSocketClient = bingXSocketClient.PerpetualFuturesApi.SharedClient;

// Spot API common functionality rest client
var spotSharedRestClients = bitfinexRestClient.SpotApi.SharedClient; 

// Spot API common functionality socket client
var spotSharedSocketClient = bitfinexSocketClient.SpotApi.SharedClient; 

// Spot API common functionality rest client
var spotSharedRestClients = bitgetRestClient.SpotApiV2.SharedClient;
 
// Spot API common functionality socket client
var spotSharedSocketClient = bitgetSocketClient.SpotApiV2.SharedClient; 

// Perpetual Futures API common functionality rest client
var usdFuturesSharedRestClient = bitgetRestClient.FuturesApiV2.SharedClient;

// Perpetual Futures API common functionality socket client
var usdFuturesSharedSocketClient = bitgetSocketClient.FuturesApiV2.SharedClient;

// Spot API common functionality rest client
var spotSharedRestClients = bitMartRestClient.SpotApi.SharedClient;

// Spot API common functionality socket client
var spotSharedSocketClient = bitMartSocketClient.SpotApi.SharedClient;

// USD Futures API common functionality rest client
var usdFuturesSharedRestClient = bitMartRestClient.UsdFuturesApi.SharedClient;

// USD Futures API common functionality socket client
var usdFuturesSharedSocketClient = bitMartSocketClient.UsdFuturesApi.SharedClient;

// Spot and Futures API common functionality rest client
var spotSharedRestClients = bybitRestClient.V5Api.SharedClient;

// Spot and Futures API common functionality socket client
var spotSharedSocketClient = bybitSocketClient.V5SpotApi.SharedClient;

// Linear Futures API common functionality socket client
var linearFuturesSharedSocketClient = bybitSocketClient.V5LinearApi.SharedClient;

// Inverse Futures API common functionality socket client
var inverseFuturesspotSharedSocketClient = bybitSocketClient.V5InverseApi.SharedClient;

// Private Futures API common functionality socket client
var privateFuturesSharedSocketClient = bybitSocketClient.V5PrivateApi.SharedClient;

// Advanced Trade API common functionality rest client
var spotSharedRestClients = coinbaseRestClient.AdvancedTradeApi.SharedClient;

// Advanced Trade API common functionality socket client
var spotSharedSocketClient = coinbaseSocketClient.AdvancedTradeApi.SharedClient;

// Spot API common functionality rest client
var spotSharedRestClients = coinExRestClient.SpotApiV2.SharedClient;

// Spot API common functionality socket client
var spotSharedSocketClient = coinExSocketClient.SpotApiV2.SharedClient;

// Futures API common functionality rest client
var usdFuturesSharedRestClient = coinExRestClient.FuturesApi.SharedClient;

// Futures API common functionality socket client
var usdFuturesSharedSocketClient = coinExSocketClient.FuturesApi.SharedClient;

// Spot/Futures API common functionality rest client
var sharedRestClients = cryptoComRestClient.ExchangeApi.SharedClient;

// Spot/Futures API common functionality socket client
var sharedSocketClient = cryptoComSocketClient.ExchangeApi.SharedClient;

// Spot API common functionality rest client
var spotSharedRestClients = gateioRestClient.SpotApi.SharedClient;

// Spot API common functionality socket client
var spotSharedSocketClient = gateioSocketClient.SpotApi.SharedClient;

// Perpetual Futures API common functionality rest client
var perpFuturesSharedRestClient = gateioRestClient.PerpetualFuturesApi.SharedClient;

// Perpetual Futures API common functionality socket client
var perpFuturesSharedSocketClient = gateioSocketClient.PerpetualFuturesApi.SharedClient;

// Spot API common functionality rest client
var spotSharedRestClients = htxRestClient.SpotApi.SharedClient;

// Spot API common functionality socket client
var spotSharedSocketClient = htxSocketClient.SpotApi.SharedClient;

// USDT Futures API common functionality rest client
var usdFuturesSharedRestClient = htxRestClient.UsdtFuturesApi.SharedClient;

// USDT Futures API common functionality socket client
var usdFuturesSharedSocketClient = htxSocketClient.UsdtFuturesApi.SharedClient;

// Spot API common functionality rest client
var spotSharedRestClients = hyperliquidRestClient.SpotApi.SharedClient;

// Spot API common functionality socket client
var spotSharedSocketClient = hyperliquidSocketClient.SpotApi.SharedClient;

// Perpetual Futures API common functionality rest client
var futuresSharedRestClient = hyperliquidRestClient.FuturesApi.SharedClient;

// Perpetual Futures API common functionality socket client
var futuresSharedSocketClient = hyperliquidSocketClient.FuturesApi.SharedClient;

// Spot API common functionality rest client
var spotSharedRestClients = krakenRestClient.SpotApi.SharedClient;

// Spot API common functionality socket client
var spotSharedSocketClient = krakenSocketClient.SpotApi.SharedClient;

// Futures API common functionality rest client
var usdFuturesSharedRestClient = krakenRestClient.FuturesApi.SharedClient;

// Futures API common functionality socket client
var usdFuturesSharedSocketClient = krakenSocketClient.FuturesApi.SharedClient;

// Spot API common functionality rest client
var spotSharedRestClients = kucoinRestClient.SpotApi.SharedClient;

// Spot API common functionality socket client
var spotSharedSocketClient = kucoinSocketClient.SpotApi.SharedClient;

// Futures API common functionality rest client
var usdFuturesSharedRestClient = kucoinRestClient.FuturesApi.SharedClient;

// Futures API common functionality socket client
var usdFuturesSharedSocketClient = kucoinSocketClient.FuturesApi.SharedClient;

// Spot API common functionality rest client
var spotSharedRestClients = mexcRestClient.SpotApi.SharedClient;

// Spot API common functionality socket client
var spotSharedSocketClient = mexcSocketClient.SpotApi.SharedClient;

// Futures and Spot API common functionality rest client
var spotSharedRestClients = okxRestClient.UnifiedApi.SharedClient;

// Futures and Spot API common functionality socket client
var spotSharedSocketClient = okxSocketClient.UnifiedApi.SharedClient;

// Futures and Spot API common functionality rest client
var spotSharedRestClients = whitebitRestClient.V4Api.SharedClient;

// Futures and Spot API common functionality socket client
var spotSharedSocketClient = whitebitSocketClient.V4Api.SharedClient;

// Spot API common functionality rest client
var spotSharedRestClients = xtRestClient.SpotApi.SharedClient;

// Futures API common functionality rest client
var futuresSharedRestClients = xtRestClient.UsdtFuturesApi.SharedClient;

// Spot API common functionality socket client
var spotSharedSocketClient = xtSocketClient.SpotApi.SharedClient;

// Futures API common functionality socket client
var futuresSharedSocketClient = xtSocketClient.FuturesApi.SharedClient;

builder.Services.AddBinance(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddBinance(builder.Configuration.GetSection("Binance"));

builder.Services.AddBingX(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddBingX(builder.Configuration.GetSection("BingX"));

builder.Services.AddBitfinex(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddBitfinex(builder.Configuration.GetSection("Bitfinex"));

builder.Services.AddBitget(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddBitget(builder.Configuration.GetSection("Bitget"));

builder.Services.AddBitMart(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddBitMart(builder.Configuration.GetSection("BitMart"));

builder.Services.AddBybit(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddBybit(builder.Configuration.GetSection("Bybit"));

builder.Services.AddCoinbase(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddCoinbase(builder.Configuration.GetSection("Coinbase"));

builder.Services.AddCoinGecko(
  options => {
    options.RequestTimeout = TimeSpan.FromSeconds(30);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddCoinGecko(builder.Configuration.GetSection("CoinGecko"));

builder.Services.AddCoinEx(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddCoinEx(builder.Configuration.GetSection("CoinEx"));

builder.Services.AddCryptoCom(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddCryptoCom(builder.Configuration.GetSection("CryptoCom"));

builder.Services.AddGateIo(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddGateIo(builder.Configuration.GetSection("GateIo"));

builder.Services.AddHTX(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddHTX(builder.Configuration.GetSection("HTX"));

builder.Services.AddHyperLiquid(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddHyperLiquid(builder.Configuration.GetSection("HyperLiquid"));

builder.Services.AddKraken(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddKraken(builder.Configuration.GetSection("Kraken"));

builder.Services.AddKucoin(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddKucoin(builder.Configuration.GetSection("Kucoin"));

builder.Services.AddMexc(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddMexc(builder.Configuration.GetSection("Mexc"));

builder.Services.AddOKX(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddOKX(builder.Configuration.GetSection("OKX"));

builder.Services.AddWhiteBit(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddWhiteBit(builder.Configuration.GetSection("WhiteBit"));

builder.Services.AddXT(
  options => {
    options.Rest.RequestTimeout = TimeSpan.FromSeconds(30);
    options.Socket.RequestTimeout = TimeSpan.FromSeconds(5);
  });
  
// OR
  
// see https://github.com/JKorf/CryptoExchange.Net/tree/master/Examples/example-config.json for an example configuration
builder.Services.AddXT(builder.Configuration.GetSection("XT"));

var binanceRestClient = new BinanceRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new BingXRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new BitfinexRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new BitgetRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new BitMartRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new BybitRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new CoinbaseRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new CoinGeckoRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new CoinExRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new CryptoComRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new GateIoRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new HTXRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new HyperLiquidRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new KrakenRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new KucoinRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new MexcRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new OKXRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new WhiteBitRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

var client = new XTRestClient(opts =>
{
    opts.RequestTimeout = TimeSpan.FromSeconds(30);
});

BingXRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new BingXRestClient();

BitfinexRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new BitfinexRestClient();

BitgetRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new BitgetRestClient();

BitMartRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new BitMartRestClient();

BybitRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new BybitRestClient();

CoinbaseClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new CoinbaseRestClient();

CoinGeckoRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new CoinGeckoRestClient();

CoinExRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new CoinExRestClient();

CryptoComRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new CryptoComRestClient();

GateIoRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new GateIoRestClient();

HTXRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new HTXRestClient();

HyperLiquidRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new HyperLiquidRestClient();

KrakenRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new KrakenRestClient();

KucoinRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new KucoinRestClient();

MexcRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new MexcRestClient();

OKXRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new OKXRestClient();

WhiteBitRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new WhiteBitRestClient();

XTRestClient.SetDefaultOptions(options =>
{
    options.RequestTimeout = TimeSpan.FromSeconds(30);
});
var client = new XTRestClient();

var book = new BinanceSpotSymbolOrderBook("ETHUSDT");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new BingXSpotSymbolOrderBook("ETH-USDT");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new BitfinexSymbolOrderBook("tETHUSD");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new BitgetSpotSymbolOrderBook("ETHUSDT");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new BitMartSymbolOrderBook("ETH_USDT", Category.Spot);
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new BybitSymbolOrderBook("ETHUSDT", Category.Spot);
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new CoinbaseSymbolOrderBook("ETH-USDT");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new CoinExSpotSymbolOrderBook("ETHUSDT");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new GateIoSpotSymbolOrderBook("ETH_USDT");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new CryptoComSpotSymbolOrderBook("ETH_USDT");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new HTXSpotSymbolOrderBook("ethusdt");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new HyperLiquidSymbolOrderBook("HYPE/USDC");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new KrakenSpotSymbolOrderBook("ETH/USD");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new KucoinSpotSymbolOrderBook("ETH-USDT");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new MexcSpotSymbolOrderBook("ETHUSDT");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new OKXSymbolOrderBook("ETH-USDT");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new WhiteBitSymbolOrderBook("ETH_USDT");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

var book = new XTSymbolOrderBook("eth_usdt");
var startResult = await book.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Book has successfully started and synchronized

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await book.StopAsync();

// Either create a new factory or inject the IBinanceTrackerFactory interface
var factory = new BinanceTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IBingXTrackerFactory interface
var factory = new BingXTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IBitfinexTrackerFactory interface
var factory = new BitfinexTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IBitgetTrackerFactory interface
var factory = new BitgetTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IBitMartTrackerFactory interface
var factory = new BitMartTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IBybitTrackerFactory interface
var factory = new BybitTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the ICoinbaseTrackerFactory interface
var factory = new CoinbaseTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the ICoinExTrackerFactory interface
var factory = new CoinExTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IGateIoTrackerFactory interface
var factory = new GateIoTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the ICryptoComTrackerFactory interface
var factory = new CryptoComTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IHTXTrackerFactory interface
var factory = new HTXTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IHyperLiquidTrackerFactory interface
var factory = new HyperLiquidTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "HYPE", "USDC");

// Create a tracker for HYPE/USDC keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IKrakenTrackerFactory interface
var factory = new KrakenTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USD");

// Create a tracker for ETH/USD keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IKucoinTrackerFactory interface
var factory = new KucoinTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IMexcTrackerFactory interface
var factory = new MexcTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IOKXTrackerFactory interface
var factory = new OKXTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IWhiteBitTrackerFactory interface
var factory = new WhiteBitTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

// Either create a new factory or inject the IXTTrackerFactory interface
var factory = new XTTrackerFactory();

var symbol = new SharedSymbol(TradingMode.Spot, "ETH", "USDT");

// Create a tracker for ETH/USDT keeping track of trades in the last 5 minutes
var tracker = factory.CreateTradeTracker(symbol, period: TimeSpan.FromMinutes(5));
var startResult = await tracker.StartAsync();
if (!startResult.Success)
{
  // Handle error, error info available in startResult.Error
}
// Tracker has successfully started
// Note that it might not be fully synced yet, check tracker.Status for this.

// Once no longer needed you can stop the live sync functionality by calling StopAsync()
await tracker.StopAsync();

services.AddBinance(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static BinanceExchange.RateLimiter exposes an event which triggers when a rate limit is reached

BinanceExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

// Output: Limit triggered: RateLimitEvent { ApiLimit = Spot Socket, LimitDescription = Limit of 6000 per 00:01:00, RequestDefinition = GET 1, Host = wss://ws-api.binance.com, Current = 5752, RequestWeight = 250, Limit = 6000, TimePeriod = 00:01:00, DelayTime = 00:00:38.7784145, Behaviour = Wait }

services.AddBingX(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static BingXExchange.RateLimiter exposes an event which triggers when a rate limit is reached

BingXExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

services.AddBitget(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static BitgetExchange.RateLimiter exposes an event which triggers when a rate limit is reached

BitgetExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

services.AddBitMart(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static BitMartExchange.RateLimiter exposes an event which triggers when a rate limit is reached

BitMartExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

services.AddCoinbase(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static CoinbaseExchange.RateLimiter exposes an event which triggers when a rate limit is reached

CoinbaseExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

services.AddCryptoCom(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static CryptoComExchange.RateLimiter exposes an event which triggers when a rate limit is reached

CryptoComExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

services.AddGateIo(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static GateIoExchange.RateLimiter exposes an event which triggers when a rate limit is reached

GateIoExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

services.AddHTX(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static HTXExchange.RateLimiter exposes an event which triggers when a rate limit is reached

HTXExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

services.AddHyperLiquid(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static HyperLiquidExchange.RateLimiter exposes an event which triggers when a rate limit is reached

HyperLiquidExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

services.AddKraken(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static KrakenExchange.RateLimiter exposes an event which triggers when a rate limit is reached

KrakenExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

// Output: Limit triggered: RateLimitEvent { ApiLimit = Spot Rest, LimitDescription = Limit of 15 with a decay rate of 0,33, RequestDefinition = POST 0/private/TradesHistory authenticated, Host = api.kraken.com, Current = 14, RequestWeight = 2, Limit = 15, TimePeriod = 00:00:01, DelayTime = 00:00:04, Behaviour = Wait }

Kraken applies different rate limits based on the account verification tier. By default the rate limit is set to the most conservative Starter tier. To change the rate limit tier call the Configure method

KrakenExchange.RateLimiter.Configure(Kraken.Net.Enums.RateLimitTier.Pro);

services.AddKucoin(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static KucoinExchange.RateLimiter exposes an event which triggers when a rate limit is reached

KucoinExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

// Output: Limit triggered: RateLimitEvent { ApiLimit = Public Rest, LimitDescription = Limit of 2000 per 00:00:30, RequestDefinition = GET api/v1/market/stats, Host = https://api.kucoin.com/, Current = 1995, RequestWeight = 15, Limit = 2000, TimePeriod = 00:00:30, DelayTime = 00:00:19.8111238, Behaviour = Wait }

Kucoin applies different rate limits based on the account VIP level. By default the rate limit is set to the most conservative VIP0 tier. To change the rate limit tier call the Configure method

KucoinExchange.RateLimiter.Configure(Kucoin.Net.Enums.VipLevel.Vip5);

services.AddMexc(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static MexcExchange.RateLimiter exposes an event which triggers when a rate limit is reached

MexcExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

services.AddOKX(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static OKXExchange.RateLimiter exposes an event which triggers when a rate limit is reached

OKXExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

services.AddWhiteBit(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static WhiteBitExchange.RateLimiter exposes an event which triggers when a rate limit is reached

WhiteBitExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);

services.AddXT(x =>
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
}, x =>
{
    x.RatelimiterEnabled = true;
    x.RateLimitingBehaviour = RateLimitingBehaviour.Wait;
});

To be notified of when a rate limit is hit the static XTExchange.RateLimiter exposes an event which triggers when a rate limit is reached

XTExchange.RateLimiter.RateLimitTriggered += (rateLimitEvent) => Console.WriteLine("Limit triggered: " + rateLimitEvent);