dotnet add package JK.BingX.Net

dotnet add package Bitfinex.Net

dotnet add package JK.Bitget.Net

dotnet add package Bybit.Net

dotnet add package CoinGecko.Net

dotnet add package CoinEx.Net

dotnet add package Huobi.Net

dotnet add package KrakenExchange.Net

dotnet add package Kucoin.Net

dotnet add package JK.Mexc.Net

dotnet add package JK.OKX.Net

builder.Services.AddBingX();

builder.Services.AddBitfinex();

builder.Services.AddBitget();

builder.Services.AddBybit();

builder.Services.AddCoinGecko();

builder.Services.AddCoinEx();

builder.Services.AddHuobi();

builder.Services.AddKraken();

builder.Services.AddKucoin();

builder.Services.AddMexc();

builder.Services.AddOKX();

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 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 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 HuobiRestClient();
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 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 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 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 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 HuobiSocketClient();
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 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

builder.Services.AddBingX(
  restOptions => {
    restOptions.RequestTimeout = TimeSpan.FromSeconds(30);
  },
  socketOptions => {
    socketOptions.RequestTimeout = TimeSpan.FromSeconds(10);
  });

builder.Services.AddBitfinex(
  restOptions => {
    restOptions.RequestTimeout = TimeSpan.FromSeconds(30);
  },
  socketOptions => {
    socketOptions.RequestTimeout = TimeSpan.FromSeconds(10);
  });

builder.Services.AddBitget(
  restOptions => {
    restOptions.RequestTimeout = TimeSpan.FromSeconds(30);
  },
  socketOptions => {
    socketOptions.RequestTimeout = TimeSpan.FromSeconds(10);
  });

builder.Services.AddBybit(
  restOptions => {
    restOptions.RequestTimeout = TimeSpan.FromSeconds(30);
  },
  socketOptions => {
    socketOptions.RequestTimeout = TimeSpan.FromSeconds(10);
  });

builder.Services.AddCoinGecko(
  restOptions => {
    restOptions.RequestTimeout = TimeSpan.FromSeconds(30);
  });

builder.Services.AddCoinEx(
  restOptions => {
    restOptions.RequestTimeout = TimeSpan.FromSeconds(30);
  },
  socketOptions => {
    socketOptions.RequestTimeout = TimeSpan.FromSeconds(10);
  });

builder.Services.AddHuobi(
  restOptions => {
    restOptions.RequestTimeout = TimeSpan.FromSeconds(30);
  },
  socketOptions => {
    socketOptions.RequestTimeout = TimeSpan.FromSeconds(10);
  });

builder.Services.AddKraken(
  restOptions => {
    restOptions.RequestTimeout = TimeSpan.FromSeconds(30);
  },
  socketOptions => {
    socketOptions.RequestTimeout = TimeSpan.FromSeconds(10);
  });

builder.Services.AddKucoin(
  restOptions => {
    restOptions.RequestTimeout = TimeSpan.FromSeconds(30);
  },
  socketOptions => {
    socketOptions.RequestTimeout = TimeSpan.FromSeconds(10);
  });

builder.Services.AddMexc(
  restOptions => {
    restOptions.RequestTimeout = TimeSpan.FromSeconds(30);
  },
  socketOptions => {
    socketOptions.RequestTimeout = TimeSpan.FromSeconds(10);
  });

builder.Services.AddOKX(
  restOptions => {
    restOptions.RequestTimeout = TimeSpan.FromSeconds(30);
  },
  socketOptions => {
    socketOptions.RequestTimeout = TimeSpan.FromSeconds(10);
  });

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 BybitRestClient(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 HuobiRestClient(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);
});

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();

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

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

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

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

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();

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 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 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 HuobiSpotSymbolOrderBook("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 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();

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);