Nuevos métodos de la API de Binance en sgcWebSockets

24 de febrero de 2026 · Características

La biblioteca sgcWebSockets sigue ampliando su integración con Binance con un lote significativo de nuevos métodos que cubren la API REST Spot, la API REST de Futuros y los streams WebSocket. Este artículo ofrece un desglose técnico de cada nuevo método, sus parámetros y ejemplos prácticos de código Delphi para que puedas ponerte en marcha rápidamente.

Índice

Nuevos métodos de la API REST Spot
Datos de mercado Spot: UI KLines, Rolling Window y Trading Day Tickers
Gestión de órdenes Spot: OCO, OTO, OTOCO y órdenes SOR
Cuenta Spot: comisiones, allocations, rate limits y prevented matches
Nuevos métodos de la API REST de Futuros
Datos de mercado de Futuros: Continuous KLines, Premium Index y más
Gestión de órdenes de Futuros: Modify, Batch y Force Orders
Cuenta de Futuros: endpoints V3, configuración y Fee Burn
Nuevos streams WebSocket Spot
Nuevos streams WebSocket de Futuros
Ejemplos completos funcionales

1. Nuevos métodos de la API REST Spot

La clase TsgcHTTP_API_Binance_Rest se ha ampliado con nuevos endpoints de datos de mercado, tipos de órdenes avanzadas y métodos de consulta de cuenta. Se puede acceder a todos los métodos directamente a través del componente REST o mediante la propiedad REST_API de TsgcWS_API_Binance.

Endpoints de datos de mercado

Método	Descripción	Endpoint de Binance
`GetUIKLines`	Datos de klines/velas optimizados para presentación en interfaz. Devuelve datos con el mismo formato que `GetKLines` pero ajustados para renderizado de gráficos.	`/api/v3/uiKlines`
`GetRollingWindowTicker`	Estadísticas de variación de precio en ventana móvil. Admite tamaños de ventana configurables (por ejemplo, 1h, 4h, 1d), a diferencia del ticker fijo de 24 horas.	`/api/v3/ticker`
`GetTradingDayTicker`	Estadísticas de variación de precio calculadas durante el día de trading (de UTC 00:00 al momento actual). Admite uno o varios símbolos.	`/api/v3/ticker/tradingDay`
`GetPriceTickers`	Recupera price tickers de varios símbolos en una sola petición utilizando un array JSON con los nombres de los símbolos.	`/api/v3/ticker/price`

GetUIKLines

function GetUIKLines(const aSymbol: String;
  aInterval: TsgcHTTPBinanceChartIntervals; aStartTime: Int64 = 0;
  aEndTime: Int64 = 0; aLimit: Integer = 500): String;

La diferencia entre GetKLines y GetUIKLines es sutil: la variante UI la optimiza el backend de Binance para el renderizado de gráficos y puede devolver límites de kline ligeramente distintos para mejorar la presentación visual. El formato de respuesta es idéntico, por lo que sirve como sustituto directo en cualquier caso de uso de gráficos.

var
  vJSON: string;
begin
  // Retrieve 1-hour UI-optimized klines for BTCUSDT
  vJSON := sgcBinanceREST.GetUIKLines('BTCUSDT', bcih1h, 0, 0, 100);
  Memo1.Lines.Add(vJSON);
end;

GetRollingWindowTicker

function GetRollingWindowTicker(const aSymbol: String = '';
  const aSymbols: String = ''; const aWindowSize: String = ''): String;

Este método extiende el tradicional Get24hrTicker permitiendo tamaños de ventana personalizados. Los valores admitidos para aWindowSize incluyen '1h', '4h' y '1d'. Si se omite, se utiliza la ventana por defecto.

var
  vJSON: string;
begin
  // Get 4-hour rolling window stats for ETHUSDT
  vJSON := sgcBinanceREST.GetRollingWindowTicker('ETHUSDT', '', '4h');
  Memo1.Lines.Add(vJSON);
  // Get rolling window for multiple symbols
  vJSON := sgcBinanceREST.GetRollingWindowTicker('',
    '["BTCUSDT","ETHUSDT"]', '1h');
  Memo1.Lines.Add(vJSON);
end;

GetTradingDayTicker

function GetTradingDayTicker(const aSymbol: String = '';
  const aSymbols: String = ''; const aType: String = ''): String;

var
  vJSON: string;
begin
  // Get trading day statistics for BTCUSDT (FULL response)
  vJSON := sgcBinanceREST.GetTradingDayTicker('BTCUSDT', '', 'FULL');
  Memo1.Lines.Add(vJSON);
end;

Tipos de órdenes avanzadas

Binance ha introducido varios tipos nuevos de listas de órdenes que van más allá del OCO original. La librería sgcWebSockets los admite ahora todos de forma nativa.

NewOrderListOCO (nuevo formato OCO)

El nuevo formato OCO sustituye al antiguo NewOCO e introduce configuraciones de precio above/below más flexibles. Cada pata del OCO puede configurarse de forma independiente con su propio tipo de orden, stop price, trailing delta y time-in-force.

function NewOrderListOCO(const aSymbol, aSide: String;
  aQuantity: Double; const aAboveType: String;
  const aBelowType: String;
  aAboveClientOrderId: String = '';
  aAboveIcebergQty: Double = 0; aAbovePrice: Double = 0;
  aAboveStopPrice: Double = 0; aAboveTrailingDelta: Int64 = 0;
  aAboveTimeInForce: String = '';
  aBelowClientOrderId: String = '';
  aBelowIcebergQty: Double = 0; aBelowPrice: Double = 0;
  aBelowStopPrice: Double = 0; aBelowTrailingDelta: Int64 = 0;
  aBelowTimeInForce: String = '';
  aListClientOrderId: String = '';
  aNewOrderRespType: String = '';
  aSelfTradePreventionMode: String = ''): String;

var
  vJSON: string;
begin
  // Place a new-format OCO: take-profit above + stop-loss below
  vJSON := sgcBinanceREST.NewOrderListOCO(
    'BTCUSDT',          // symbol
    'SELL',              // side
    0.001,              // quantity
    'LIMIT_MAKER',      // above type (take-profit)
    'STOP_LOSS_LIMIT',  // below type (stop-loss)
    '',                 // aboveClientOrderId
    0,                  // aboveIcebergQty
    72000.0,            // abovePrice (take-profit price)
    0,                  // aboveStopPrice
    0,                  // aboveTrailingDelta
    '',                 // aboveTimeInForce
    '',                 // belowClientOrderId
    0,                  // belowIcebergQty
    62000.0,            // belowPrice (limit price for stop)
    62500.0,            // belowStopPrice (trigger price)
    0,                  // belowTrailingDelta
    'GTC'               // belowTimeInForce
  );
  Memo1.Lines.Add(vJSON);
end;

NewOrderListOTO (One-Triggers-the-Other)

Una lista de órdenes OTO consta de una orden working y una orden pending. Cuando se ejecuta la orden working, la orden pending se coloca automáticamente. Es útil para configurar órdenes de entrada con órdenes de seguimiento automáticas.

function NewOrderListOTO(const aSymbol: String;
  const aWorkingType, aWorkingSide: String;
  aWorkingQuantity: Double; aWorkingPrice: Double;
  const aPendingType, aPendingSide: String;
  aPendingQuantity: Double;
  { ... additional optional parameters ... }
  ): String;

var
  vJSON: string;
begin
  // Buy BTCUSDT at limit, then automatically place a stop-loss sell
  vJSON := sgcBinanceREST.NewOrderListOTO(
    'BTCUSDT',
    'LIMIT', 'BUY',       // working order: limit buy
    0.001, 65000.0,        // working quantity and price
    'STOP_LOSS_LIMIT', 'SELL',  // pending: stop-loss sell
    0.001,                 // pending quantity
    '',                    // workingClientOrderId
    'GTC',                 // workingTimeInForce
    0,                     // workingIcebergQty
    '',                    // pendingClientOrderId
    62000.0,               // pendingPrice (limit)
    62500.0                // pendingStopPrice (trigger)
  );
  Memo1.Lines.Add(vJSON);
end;

NewOrderListOTOCO (One-Triggers-an-OCO)

Combina la lógica OTO y OCO: una orden working dispara una pareja OCO (take-profit + stop-loss) cuando se ejecuta. Esto permite estrategias completamente automatizadas de entrada con plan de salida en una sola llamada a la API.

var
  vJSON: string;
begin
  // Entry: limit buy at 65000
  // On fill: places OCO with take-profit at 72000 and stop-loss at 62000
  vJSON := sgcBinanceREST.NewOrderListOTOCO(
    'BTCUSDT',
    'LIMIT', 'BUY',          // working order
    0.001, 65000.0,           // working qty & price
    'SELL',                   // pending side
    'LIMIT_MAKER',            // pending above type
    'STOP_LOSS_LIMIT',        // pending below type
    0.001,                   // pending quantity
    '',                      // workingClientOrderId
    'GTC',                   // workingTimeInForce
    0,                       // workingIcebergQty
    '',                      // pendingAboveClientOrderId
    72000.0,                 // pendingAbovePrice (take-profit)
    0,                       // pendingAboveStopPrice
    0,                       // pendingAboveTrailingDelta
    '',                      // pendingAboveTimeInForce
    0,                       // pendingAboveIcebergQty
    '',                      // pendingBelowClientOrderId
    62000.0,                 // pendingBelowPrice
    62500.0                  // pendingBelowStopPrice
  );
  Memo1.Lines.Add(vJSON);
end;

Smart Order Routing (SOR)

Las órdenes SOR permiten a Binance optimizar la ejecución enrutando entre múltiples pools de liquidez. Se ofrecen dos nuevos métodos: NewSOROrder para ejecución en vivo y TestSOROrder para validar sin llegar a colocar la orden.

function NewSOROrder(const aSymbol, aSide, aType: String;
  aQuantity: Double; aTimeInForce: String = '';
  aPrice: Double = 0; aNewClientOrderId: String = '';
  aNewOrderRespType: String = '';
  aIcebergQty: Double = 0;
  aSelfTradePreventionMode: String = '';
  aStrategyId: Int64 = 0; aStrategyType: Integer = 0): String;

var
  vJSON: string;
begin
  // Place a SOR limit order
  vJSON := sgcBinanceREST.NewSOROrder(
    'BTCUSDT', 'BUY', 'LIMIT',
    0.001,             // quantity
    'GTC',             // timeInForce
    65000.0            // price
  );
  Memo1.Lines.Add(vJSON);
  // Test a SOR order without execution
  vJSON := sgcBinanceREST.TestSOROrder('BTCUSDT', 'BUY', 'LIMIT',
    0.001, 'GTC', 65000.0);
  Memo1.Lines.Add(vJSON);
end;

CancelReplaceOrder

Cancela atómicamente una orden existente y coloca una nueva. Es crítico para estrategias que necesitan modificar órdenes sin el riesgo de quedarse sin posición en el hueco entre dos llamadas separadas de cancelar y crear.

var
  vJSON: string;
begin
  // Cancel order 123456 and replace it with a new limit buy
  vJSON := sgcBinanceREST.CancelReplaceOrder(
    'BTCUSDT', 'BUY', 'LIMIT',
    'STOP_ON_FAILURE',   // mode: only place new if cancel succeeds
    'GTC',               // timeInForce
    0.001,               // quantity
    0,                   // quoteOrderQty
    64500.0,             // new price
    '',                  // cancelNewClientOrderId
    '',                  // cancelOrigClientOrderId
    123456               // cancelOrderId
  );
  Memo1.Lines.Add(vJSON);
end;

Endpoints de cuenta y consulta

Método	Descripción
`GetAccountInformation(aOmitZeroBalances)`	Ampliado con el parámetro `aOmitZeroBalances`. Cuando se establece a `True`, los activos con balance cero se excluyen de la respuesta.
`GetOrderRateLimitUsage`	Devuelve el recuento actual de órdenes y el uso de los rate limits, imprescindible para mantenerse dentro de los límites de la API en escenarios de alta frecuencia.
`GetPreventedMatches`	Consulta los matches de self-trade evitados. Admite filtrado por símbolo, order ID o prevented match ID con paginación.
`GetAllocations`	Recupera las allocations de órdenes SOR, mostrando cómo se distribuyó la orden entre los distintos pools.
`GetAccountCommission`	Devuelve la tasa de comisión maker/taker para un símbolo concreto.

var
  vJSON: string;
begin
  // Get account info, omitting zero balances
  vJSON := sgcBinanceREST.GetAccountInformation(True);
  Memo1.Lines.Add(vJSON);
  // Check order rate limit usage
  vJSON := sgcBinanceREST.GetOrderRateLimitUsage;
  Memo1.Lines.Add(vJSON);
  // Get commission rates for BTCUSDT
  vJSON := sgcBinanceREST.GetAccountCommission('BTCUSDT');
  Memo1.Lines.Add(vJSON);
  // Get prevented matches for a symbol
  vJSON := sgcBinanceREST.GetPreventedMatches('BTCUSDT');
  Memo1.Lines.Add(vJSON);
  // Get SOR allocations for a symbol
  vJSON := sgcBinanceREST.GetAllocations('BTCUSDT');
  Memo1.Lines.Add(vJSON);
end;

Nota: Los métodos NewOrder y TestNewOrder también se han ampliado con nuevos parámetros opcionales: aSelfTradePreventionMode, aStrategyId y aStrategyType. El método CancelOrder ahora admite un parámetro aCancelRestrictions para cancelación condicional. Estas incorporaciones son compatibles hacia atrás — el código existente seguirá funcionando sin cambios.

2. Nuevos métodos de la API REST de Futuros

La clase TsgcHTTP_API_Binance_Futures_Rest ha recibido el mayor lote de nuevos métodos, abarcando datos de mercado, gestión de órdenes, configuración de cuenta y gestión de streams. Todos los métodos funcionan tanto con futuros USDT-M como COIN-M, controlados mediante la propiedad FuturesContracts.

Datos de mercado de Futuros

Método	Descripción
`GetContinuousKLines`	Datos de klines/velas para un contrato continuo. Requiere el par, el tipo de contrato (por ejemplo `'PERPETUAL'`, `'CURRENT_QUARTER'`) y el intervalo.
`GetIndexPriceKLines`	Datos de klines basados en el precio de índice de un par de trading.
`GetMarkPriceKLines`	Datos de klines basados en el mark price de un símbolo.
`GetPremiumIndexKLines`	Datos de klines del premium index para el cálculo del basis y el análisis del funding rate.
`GetFundingInfo`	Devuelve información del funding rate de todos los símbolos, incluyendo el intervalo de funding y los cap/floor rates.
`GetPriceTickerV2`	Price ticker V2 con un formato de respuesta mejorado.
`GetIndexInfo`	Devuelve el precio de índice y los datos de los componentes para un símbolo de índice compuesto.
`GetAssetIndex`	Precios de asset index para los cálculos de margen en modo multi-activo.
`GetConstituents`	Consulta los componentes y sus pesos para un índice compuesto dado.
`GetDeliveryPrice`	Precios históricos de entrega para contratos trimestrales/bi-trimestrales.
`GetBasis`	Datos de basis (diferencial entre el precio de futuros y spot) para un par y tipo de contrato dados.

var
  vJSON: string;
begin
  // Continuous klines for BTCUSDT perpetual, 1h interval
  vJSON := sgcBinanceFutREST.GetContinuousKLines(
    'BTCUSDT', 'PERPETUAL', bcih1h, 0, 0, 100);
  Memo1.Lines.Add(vJSON);
  // Mark price klines for ETHUSDT, 15m interval
  vJSON := sgcBinanceFutREST.GetMarkPriceKLines('ETHUSDT', bcih15m);
  Memo1.Lines.Add(vJSON);
  // Index price klines
  vJSON := sgcBinanceFutREST.GetIndexPriceKLines('BTCUSDT', bcih4h);
  Memo1.Lines.Add(vJSON);
  // Premium index klines for funding analysis
  vJSON := sgcBinanceFutREST.GetPremiumIndexKLines('BTCUSDT', bcih1h);
  Memo1.Lines.Add(vJSON);
  // Get funding info for all symbols
  vJSON := sgcBinanceFutREST.GetFundingInfo;
  Memo1.Lines.Add(vJSON);
  // V2 price ticker
  vJSON := sgcBinanceFutREST.GetPriceTickerV2('BTCUSDT');
  Memo1.Lines.Add(vJSON);
  // Basis data
  vJSON := sgcBinanceFutREST.GetBasis('BTCUSDT', 'PERPETUAL', oip1h, 30);
  Memo1.Lines.Add(vJSON);
  // Delivery price history
  vJSON := sgcBinanceFutREST.GetDeliveryPrice('BTCUSD');
  Memo1.Lines.Add(vJSON);
end;

Gestión de órdenes de Futuros

Los nuevos métodos de órdenes de Futuros ofrecen test de órdenes, modificación de órdenes, procesamiento por lotes y consultas de liquidación.

Método	Descripción
`TestNewOrder`	Valida una nueva orden de futuros sin colocarla. Refleja la firma de `NewOrder`.
`ModifyOrder`	Modifica el precio, la cantidad o el modo de price matching de una orden abierta existente.
`NewBatchOrders`	Coloca hasta 5 órdenes en una sola petición mediante un array JSON de objetos de orden.
`ModifyBatchOrders`	Modifica hasta 5 órdenes existentes en una sola petición.
`CancelBatchOrders`	Cancela varias órdenes mediante una lista de order IDs o de client order IDs.
`GetOrderAmendment`	Recupera el historial de modificaciones de una orden.
`CountdownCancelAll`	Establece un temporizador (en milisegundos) tras el cual se cancelan todas las órdenes abiertas de un símbolo.
`GetForceOrders`	Consulta órdenes de liquidación forzosa con filtrado opcional.
`GetADLQuantile`	Recupera la estimación de cuantil ADL (Auto-Deleveraging) de las posiciones.

La firma de NewOrder para Futuros también se ha ampliado con nuevos parámetros: aPriceMatch, aSelfTradePreventionMode, aGoodTillDate y aPriceProtect.

var
  vJSON: string;
begin
  // Test a futures order without execution
  vJSON := sgcBinanceFutREST.TestNewOrder(
    'BTCUSDT', 'BUY', '', 'LIMIT',
    'GTC', 0.001, 'false', 65000.0);
  Memo1.Lines.Add('TestNewOrder: ' + vJSON);
  // Modify an existing order's price
  vJSON := sgcBinanceFutREST.ModifyOrder('BTCUSDT', 123456, '',
    'BUY', 0.001, 64800.0);
  Memo1.Lines.Add('ModifyOrder: ' + vJSON);
  // Cancel multiple orders at once
  vJSON := sgcBinanceFutREST.CancelBatchOrders('BTCUSDT',
    '[123456,123457,123458]');
  Memo1.Lines.Add('CancelBatch: ' + vJSON);
  // Set countdown cancel: cancel all BTCUSDT orders in 30 seconds
  vJSON := sgcBinanceFutREST.CountdownCancelAll('BTCUSDT', 30000);
  Memo1.Lines.Add('Countdown: ' + vJSON);
  // Query forced liquidation orders
  vJSON := sgcBinanceFutREST.GetForceOrders('BTCUSDT');
  Memo1.Lines.Add('ForceOrders: ' + vJSON);
  // ADL quantile estimation
  vJSON := sgcBinanceFutREST.GetADLQuantile('BTCUSDT');
  Memo1.Lines.Add('ADL: ' + vJSON);
end;

Cuenta y configuración de Futuros

Se han añadido varios endpoints V3 de cuenta junto con métodos de configuración y gestión de comisiones.

Método	Descripción
`GetAccountBalanceV3`	Balance de cuenta V3 con soporte mejorado de margen multi-activo.
`GetAccountInformationV3`	Detalles de cuenta V3, incluyendo el modo de margen multi-activo y los nuevos fee tiers.
`GetPositionInformationV3`	Datos de posición V3 con campos de precisión adicionales.
`GetCommissionRate`	Devuelve la tasa de comisión maker/taker actual para un símbolo de futuros concreto.
`GetAccountConfig`	Configuración a nivel de cuenta: fee tier, position mode, modo de margen multi-activo.
`GetSymbolConfig`	Configuración por símbolo: apalancamiento, tipo de margen y position mode.
`GetOrderRateLimit`	Estado actual del rate limit de órdenes por símbolo.
`GetApiTradingStatus`	Estado de trading de la API y cualquier indicador que pudiera disparar restricciones de trading.
`ChangeMultiAssetsMode`	Activa o desactiva el modo de margen multi-activo para futuros USDT-M.
`GetMultiAssetsMode`	Consulta el ajuste actual del modo de margen multi-activo.
`SetFeeBurn`	Activa o desactiva el fee burn con BNB (pagar comisiones en BNB con descuento).
`GetFeeBurn`	Consulta el ajuste actual de fee burn.

Gestión de Listen Key

Tres métodos dedicados gestionan ahora el ciclo de vida del listen key del user data stream de Futuros directamente vía REST, de forma independiente al componente WebSocket:

Método	Descripción
`CreateListenKey`	Genera un nuevo listen key para el user data stream (POST).
`KeepAliveListenKey`	Extiende la validez de un listen key (PUT). Debe llamarse cada 60 minutos.
`CloseListenKey`	Invalida y cierra un listen key (DELETE).

var
  vJSON: string;
begin
  // V3 balance and account info
  vJSON := sgcBinanceFutREST.GetAccountBalanceV3;
  Memo1.Lines.Add('V3 Balance: ' + vJSON);
  vJSON := sgcBinanceFutREST.GetAccountInformationV3;
  Memo1.Lines.Add('V3 Account: ' + vJSON);
  vJSON := sgcBinanceFutREST.GetPositionInformationV3('BTCUSDT');
  Memo1.Lines.Add('V3 Position: ' + vJSON);
  // Commission rate
  vJSON := sgcBinanceFutREST.GetCommissionRate('BTCUSDT');
  Memo1.Lines.Add('Commission: ' + vJSON);
  // Account and symbol configuration
  vJSON := sgcBinanceFutREST.GetAccountConfig;
  Memo1.Lines.Add('AccountConfig: ' + vJSON);
  vJSON := sgcBinanceFutREST.GetSymbolConfig('BTCUSDT');
  Memo1.Lines.Add('SymbolConfig: ' + vJSON);
  // Enable multi-asset margin mode
  vJSON := sgcBinanceFutREST.ChangeMultiAssetsMode(True);
  Memo1.Lines.Add('MultiAssets: ' + vJSON);
  // Enable BNB fee burn
  vJSON := sgcBinanceFutREST.SetFeeBurn(True);
  Memo1.Lines.Add('FeeBurn: ' + vJSON);
  // Check API trading status
  vJSON := sgcBinanceFutREST.GetApiTradingStatus('BTCUSDT');
  Memo1.Lines.Add('TradingStatus: ' + vJSON);
  // Listen key lifecycle (REST-only approach)
  vJSON := sgcBinanceFutREST.CreateListenKey;
  Memo1.Lines.Add('ListenKey: ' + vJSON);
end;

3. Nuevos streams WebSocket Spot

La clase TsgcWS_API_Binance se ha ampliado con tres nuevos tipos de stream, cada uno con sus métodos de subscribe y unsubscribe.

Método	Stream	Descripción
`SubscribeAvgPrice / UnSubscribeAvgPrice`	`<symbol>@avgPrice`	Stream de precio medio en tiempo real para un símbolo.
`SubscribeRollingWindowTicker`	`<symbol>@ticker_<window>`	Estadísticas en ventana móvil con tamaño de ventana configurable (1h, 4h, 1d).
`SubscribeAllRollingWindowTickers`	`!ticker_<window>@arr`	Estadísticas en ventana móvil para todos los símbolos negociados con un tamaño de ventana concreto.

Se ofrece un nuevo tipo enumerado TsgcWSBinanceRollingWindowSize para especificar el tamaño de la ventana con seguridad de tipos:

TsgcWSBinanceRollingWindowSize = (brw1h, brw4h, brw1d);

procedure TForm1.btnSubscribeClick(Sender: TObject);
begin
  if not sgcWebSocketClient1.Active then
    sgcWebSocketClient1.Active := True;
  // Subscribe to average price updates for BTCUSDT
  sgcBinance.SubscribeAvgPrice('btcusdt');
  // Subscribe to 1-hour rolling window ticker for ETHUSDT
  sgcBinance.SubscribeRollingWindowTicker('ethusdt', brw1h);
  // Subscribe to all tickers with a 4-hour rolling window
  sgcBinance.SubscribeAllRollingWindowTickers(brw4h);
end;
procedure TForm1.btnUnsubscribeClick(Sender: TObject);
begin
  sgcBinance.UnSubscribeAvgPrice('btcusdt');
  sgcBinance.UnSubscribeRollingWindowTicker('ethusdt', brw1h);
  sgcBinance.UnSubscribeAllRollingWindowTickers(brw4h);
end;

4. Nuevos streams WebSocket de Futuros

La clase TsgcWS_API_Binance_Futures recibe el mayor conjunto de nuevas suscripciones a streams WebSocket. Cubren contratos continuos, índices compuestos, asset indices, precios de índice y klines de mark price.

Método	Stream	Descripción
`SubscribeContinuousKLine`	`<pair>_<contract>@continuousKline_<interval>`	Stream de klines para contratos continuos. Requiere par, tipo de contrato e intervalo.
`SubscribeCompositeIndex`	`<symbol>@compositeIndex`	Stream del precio de un índice compuesto con desglose por componente.
`SubscribeContractInfo`	`!contractInfo`	Stream de información de contratos. Envía actualizaciones sobre listado, deslistado y cambios de brackets.
`SubscribeAssetIndex / SubscribeAllAssetIndex`	`<symbol>@assetIndex` / `!assetIndex@arr`	Precios de asset index para cálculos de margen multi-activo. Por símbolo o para todo el mercado.
`SubscribeIndexPrice`	`<pair>@indexPrice`	Stream de precio de índice para un par de trading. Admite un parámetro opcional de velocidad de actualización.
`SubscribeIndexPriceKLine`	`<pair>@indexPriceKline_<interval>`	Stream de klines/velas del precio de índice con intervalos configurables.
`SubscribeMarkPriceKLine`	`<symbol>@markPriceKline_<interval>`	Stream de klines del mark price para seguir el precio usado en los cálculos de liquidación.

procedure TForm1.SubscribeFuturesStreams;
begin
  if not sgcWebSocketClient1.Active then
    sgcWebSocketClient1.Active := True;
  // Continuous kline for BTCUSDT perpetual contract, 1h interval
  sgcBinanceFutures.SubscribeContinuousKLine('btcusdt',
    'perpetual', bci1h);
  // Composite index stream
  sgcBinanceFutures.SubscribeCompositeIndex('defiusdt');
  // Contract info updates (no symbol needed)
  sgcBinanceFutures.SubscribeContractInfo;
  // Asset index for a single symbol
  sgcBinanceFutures.SubscribeAssetIndex('btcusd');
  // All asset index prices
  sgcBinanceFutures.SubscribeAllAssetIndex;
  // Index price with default update speed
  sgcBinanceFutures.SubscribeIndexPrice('btcusdt');
  // Index price kline, 15m interval
  sgcBinanceFutures.SubscribeIndexPriceKLine('btcusdt', bci15m);
  // Mark price kline, 5m interval
  sgcBinanceFutures.SubscribeMarkPriceKLine('btcusdt', bci5m);
end;

5. Ejemplos completos funcionales

Ejemplo 1: combinación Spot REST + WebSocket (aplicación VCL)

Un patrón típico consiste en usar la API REST para colocar órdenes y la API WebSocket para datos de mercado en tiempo real. El siguiente ejemplo muestra cómo configurar ambos a través del componente TsgcWS_API_Binance.

unit MainForm;
interface
uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
  StdCtrls, sgcWebSocket_Classes, sgcWebSocket_API_Binance,
  sgcWebSocket_APIs, sgcBase_Classes, sgcWebSocket_Client, sgcWebSocket;
type
  TForm1 = class(TForm)
    sgcWebSocketClient1: TsgcWebSocketClient;
    sgcBinance: TsgcWSAPI_Binance;
    btnConnect: TButton;
    btnGetTicker: TButton;
    btnPlaceSOROrder: TButton;
    Memo1: TMemo;
    procedure FormCreate(Sender: TObject);
    procedure btnConnectClick(Sender: TObject);
    procedure btnGetTickerClick(Sender: TObject);
    procedure btnPlaceSOROrderClick(Sender: TObject);
    procedure sgcWebSocketClient1Message(Connection: TsgcWSConnection;
      const Text: string);
  end;
implementation
{$R *.dfm}
procedure TForm1.FormCreate(Sender: TObject);
begin
  // Configure API credentials
  sgcBinance.Binance.ApiKey := 'your-api-key';
  sgcBinance.Binance.ApiSecret := 'your-api-secret';
  sgcBinance.Binance.TestNet := True;  // use testnet during development
  sgcBinance.Binance.UserStream := False;
end;
procedure TForm1.btnConnectClick(Sender: TObject);
begin
  sgcWebSocketClient1.Active := True;
  // Subscribe to new streams
  sgcBinance.SubscribeAvgPrice('btcusdt');
  sgcBinance.SubscribeRollingWindowTicker('btcusdt', brw1h);
end;
procedure TForm1.btnGetTickerClick(Sender: TObject);
begin
  // Use new REST endpoints via the integrated REST_API property
  Memo1.Lines.Add(sgcBinance.REST_API.GetTradingDayTicker('BTCUSDT'));
  Memo1.Lines.Add(sgcBinance.REST_API.GetRollingWindowTicker('BTCUSDT',
    '', '4h'));
  Memo1.Lines.Add(sgcBinance.REST_API.GetAccountCommission('BTCUSDT'));
end;
procedure TForm1.btnPlaceSOROrderClick(Sender: TObject);
begin
  // Test a Smart Order Routing order
  Memo1.Lines.Add(sgcBinance.REST_API.TestSOROrder(
    'BTCUSDT', 'BUY', 'LIMIT', 0.001, 'GTC', 65000.0));
end;
procedure TForm1.sgcWebSocketClient1Message(Connection: TsgcWSConnection;
  const Text: string);
begin
  Memo1.Lines.Add(Text);
end;
end.

Ejemplo 2: Futuros REST + WebSocket (aplicación de consola)

Las aplicaciones de consola son ideales para bots headless y servicios en segundo plano. El siguiente ejemplo muestra cómo usar los nuevos métodos de Futuros en un contexto de consola.

program BinanceFuturesConsole;
{$APPTYPE CONSOLE}
{$R *.res}
uses
  Classes, SysUtils,
  sgcWebSocket, sgcWebSocket_APIs, sgcWebSocket_Types,
  sgcWebSocket_Classes, sgcHTTP_API_Binance;
var
  FutREST: TsgcHTTP_API_Binance_Futures_Rest;
  vJSON: string;
begin
  try
    FutREST := TsgcHTTP_API_Binance_Futures_Rest.Create(nil);
    try
      FutREST.BinanceOptions.ApiKey := 'your-api-key';
      FutREST.BinanceOptions.ApiSecret := 'your-api-secret';
      FutREST.BinanceOptions.TestNet := True;
      FutREST.FuturesContracts := bfchUSDT;
      // New market data methods
      vJSON := FutREST.GetFundingInfo;
      WriteLn('Funding Info: ', Copy(vJSON, 1, 200), '...');
      vJSON := FutREST.GetPriceTickerV2('BTCUSDT');
      WriteLn('PriceV2: ', vJSON);
      vJSON := FutREST.GetContinuousKLines('BTCUSDT',
        'PERPETUAL', bcih1h, 0, 0, 5);
      WriteLn('ContinuousKLines: ', Copy(vJSON, 1, 200), '...');
      // V3 account endpoints
      vJSON := FutREST.GetAccountBalanceV3;
      WriteLn('V3 Balance: ', Copy(vJSON, 1, 200), '...');
      // Account configuration
      vJSON := FutREST.GetAccountConfig;
      WriteLn('Config: ', vJSON);
      vJSON := FutREST.GetSymbolConfig('BTCUSDT');
      WriteLn('SymbolConfig: ', vJSON);
      // Commission and fee management
      vJSON := FutREST.GetCommissionRate('BTCUSDT');
      WriteLn('Commission: ', vJSON);
      vJSON := FutREST.GetFeeBurn;
      WriteLn('FeeBurn: ', vJSON);
      // Listen key management
      vJSON := FutREST.CreateListenKey;
      WriteLn('ListenKey: ', vJSON);
    finally
      FutREST.Free;
    end;
  except
    on E: Exception do
      WriteLn(E.ClassName, ': ', E.Message);
  end;
end.

Ejemplo 3: estrategia con orden OTOCO

El tipo de orden OTOCO representa el ciclo de vida de trade automatizado más completo: una sola llamada coloca una orden de entrada que, una vez ejecutada, configura automáticamente tanto un take-profit como un stop-loss.

procedure TForm1.PlaceOTOCOStrategy;
var
  vResult: string;
begin
  // Strategy: buy ETHUSDT at 3400, take profit at 3600, stop-loss at 3300
  vResult := sgcBinance.REST_API.NewOrderListOTOCO(
    'ETHUSDT',
    // Working order: limit buy entry
    'LIMIT',              // workingType
    'BUY',                // workingSide
    0.1,                  // workingQuantity
    3400.0,               // workingPrice
    // Pending OCO (triggered after entry fills)
    'SELL',                // pendingSide
    'LIMIT_MAKER',         // pendingAboveType (take-profit)
    'STOP_LOSS_LIMIT',     // pendingBelowType (stop-loss)
    0.1,                  // pendingQuantity
    '',                   // workingClientOrderId
    'GTC',                // workingTimeInForce
    0,                    // workingIcebergQty
    '',                   // pendingAboveClientOrderId
    3600.0,               // pendingAbovePrice (take-profit target)
    0,                    // pendingAboveStopPrice
    0,                    // pendingAboveTrailingDelta
    '',                   // pendingAboveTimeInForce
    0,                    // pendingAboveIcebergQty
    '',                   // pendingBelowClientOrderId
    3250.0,               // pendingBelowPrice (stop-loss limit)
    3300.0                // pendingBelowStopPrice (trigger)
  );
  if Pos('"orderListId"', vResult) > 0 then
    Memo1.Lines.Add('OTOCO placed successfully')
  else
    Memo1.Lines.Add('OTOCO error: ' + vResult);
end;

Resumen

La siguiente tabla resume el número de nuevos métodos añadidos a cada clase:

Componente	Clase	Nuevos métodos
API REST Spot	`TsgcHTTP_API_Binance_Rest`	GetUIKLines, GetRollingWindowTicker, GetTradingDayTicker, NewOrderListOCO, NewOrderListOTO, NewOrderListOTOCO, NewSOROrder, TestSOROrder, CancelReplaceOrder, GetOrderRateLimitUsage, GetPreventedMatches, GetAllocations, GetAccountCommission
API REST de Futuros	`TsgcHTTP_API_Binance_Futures_Rest`	TestNewOrder, ModifyOrder, NewBatchOrders, ModifyBatchOrders, CancelBatchOrders, GetOrderAmendment, CountdownCancelAll, GetForceOrders, GetADLQuantile, GetAccountBalanceV3, GetAccountInformationV3, GetPositionInformationV3, GetCommissionRate, GetAccountConfig, GetSymbolConfig, GetOrderRateLimit, GetApiTradingStatus, ChangeMultiAssetsMode, GetMultiAssetsMode, SetFeeBurn, GetFeeBurn, GetContinuousKLines, GetIndexPriceKLines, GetMarkPriceKLines, GetPremiumIndexKLines, GetFundingInfo, GetPriceTickerV2, GetIndexInfo, GetAssetIndex, GetConstituents, GetDeliveryPrice, GetBasis, CreateListenKey, KeepAliveListenKey, CloseListenKey
WebSocket Spot	`TsgcWS_API_Binance`	SubscribeAvgPrice, SubscribeRollingWindowTicker, SubscribeAllRollingWindowTickers (+ los correspondientes métodos UnSubscribe)
WebSocket de Futuros	`TsgcWS_API_Binance_Futures`	SubscribeContinuousKLine, SubscribeCompositeIndex, SubscribeContractInfo, SubscribeAssetIndex, SubscribeAllAssetIndex, SubscribeIndexPrice, SubscribeIndexPriceKLine, SubscribeMarkPriceKLine (+ los correspondientes métodos UnSubscribe)

Importante: Todos los métodos de trading que crean, modifican o cancelan órdenes requieren credenciales ApiKey y ApiSecret válidas. Se recomienda encarecidamente desarrollar y probar contra el TestNet de Binance estableciendo TestNet := True antes de pasar a producción. Además, asegúrate de que los permisos de la API key (trading, margin, futures) coinciden con las operaciones que pretendes realizar. Compatibilidad hacia atrás: Todas las incorporaciones son compatibles hacia atrás. Las firmas de método existentes se han ampliado con valores por defecto, por lo que el código previamente compilado sigue funcionando sin modificaciones. Los nuevos parámetros (aSelfTradePreventionMode, aStrategyId, aPriceMatch, etc.) toman por defecto valores vacíos o cero que hacen que la API utilice su comportamiento estándar.