Quick Start

Fubon Market WebSocket API provides real-time stock market data services for Taiwan. Through the WebSocket API, you can fulfill your need for receiving real-time market data.

Using SDK

Fubon Market WebSocket API provides Python 、 Node.js and C# SDKs. You can access the WebSocket API through the following methods：

And subscribe webSocket callback method to receive the callback messages below.

info

WebSocket api provides Low Latency Speed Mode and Multi-Information Normal Mode.

Python

from fubon_neo.sdk import FubonSDK, Mode

def handle_message(message):
    print(message)

sdk = FubonSDK()
accounts = sdk.login("Your ID", "Your password", "Your cert path", "Your cert password") 

sdk.init_realtime()
# Offer MarketData Mode ， Default : Speed 
# sdk.init_realtime(Mode.Speed) or sdk.init_realtime(Mode.Normal)

futopt = sdk.marketdata.websocket_client.futopt
futopt.on('message', handle_message)
futopt.connect()

Node.js

const { FubonSDK, Mode } = require('fubon-neo');

const sdk = new FubonSDK();

const accounts = sdk.login("Your ID", "Your password", "Your cert path", "Your cert password");

sdk.initRealtime(); 
// Offer MarketData Mode ， Default : Speed 
// sdk.initRealtime(Mode.Speed) or sdk.initRealtime(Mode.Normal)

const futopt = sdk.marketdata.webSocketClient.futopt;

futopt.connect()

futopt.on("message", (message) => {
  const data = JSON.parse(message);
  console.log(data);
});

C#

using FubonNeo.Sdk;
using FugleMarketData.WebsocketModels;

var sdk = new FubonSDK();

var result = sdk.Login("Your ID", "Your password", "Your cert path", "Your cert password");

sdk.InitRealtime(); 
// Offer MarketData Mode ， Default : Speed 
// sdk.InitRealtime(Mode.Speed) or sdk.InitRealtime(Mode.Normal)

var futopt = sdk.MarketData.WebSocketClient.FutureOption;

futopt.OnMessage += (msg) => Console.WriteLine($"receive: {msg}");

await futopt.Connect();

Authenticated

When the verification is successful, you will receive the following message：

{
  "event": "authenticated",
  "data": {
    "message": "Authenticated successfully"
  }
}

When the verification is failed, you will receive the following message：

{
  "event": "error",
  "data": {
    "message": "Invalid authentication credentials"
  }
}

Heartbeat

Every 30 seconds, the WebSocket server will send out a heartbeat message：

{
  "event": "heartbeat",
  "data": {
    "time": "<Timestamp>"
  }
}

Ping/Pong

Every 30 seconds, sdk will send the following JSON-formatted message to the WebSocket Server, or follow the below example (where state is optional)：

Python

futopt.ping({
  'state' : '<ANY>'
})

Node.js

futopt.ping({state:'<ANY>'});

C#

futopt.ping("<ANY>");

The WebSocket Server will respond with the following message (if ping was sent, the state field will not be present):

{
  "event": "pong",
  "data": {
    "time": "<TIMESTAMP>",
    "state": "<ANY>"
  }
}

Channels

The Fubon Market WebSocket API currently provides the following subscribable channels：

• trades - Subscribe to the latest future trade information
• books - Subscribe to the latest top five bid and ask information for stocks

Subscribe Channel

Subscribe to a channel, send following example to the WebSocket Server：

Python

futopt.subscribe({
  "channel" : "<CHANNEL_NAME>",
  "symbol" : "<SYMBOL_ID>"
  #"afterHours" : True   Subscribe after-hours 
})

Node.js

futopt.subscribe({ 
  channel: '<CHANNEL_NAME>', 
  symbol: '<SYMBOL_ID>',
  //afterHours : true  Subscribe after-hours 
});

C#

futopt.Subscribe(FutureOptionChannel.<CHANNEL_NAME>,"<SYMBOL_ID>");
//futopt.Subscribe(FutureOptionChannel.Trades,new FutureOptionParams{Symbol="<SYMBOL_ID>", AfterHours = true});   Subscribe after-hours 

After a successful subscription, you will receive the following event response：

{
  "event": "subscribed",
  "data": {
    "id": "<CHANNEL_ID>",
    "channel": "<CHANNEL_NAME>",
    "symbol": "<SYMBOL_ID>"
  }
}

Supports the subscription of multiple stocks within the same channel：

Python

futopt.subscribe({
  "channel" : "<CHANNEL_NAME>",
  "symbols" : ["<SYMBOL_ID>","<SYMBOL_ID>"]
  #"afterHours" : True  Subscribe after-hours 
})

Node.js

futopt.subscribe({ 
  channel: '<CHANNEL_NAME>', 
  symbols: ['<SYMBOL_ID>','<SYMBOL_ID>']
  //afterHours : true  Subscribe after-hours 
});

C#

futopt.Subscribe(FutureOptionChannel.<CHANNEL_NAME>,"<SYMBOL_ID>","<SYMBOL_ID>");
//futopt.Subscribe(FutureOptionChannel.Trades, new FutureOptionParams{Symbols = new List<string>{"<SYMBOL_ID>", "<SYMBOL_ID>"}, AfterHours = true});    Subscribe after-hours 

After a successful subscription, you will receive the following event response：

{
  "event": "subscribed",
  "data": [
    {
      "id": "<CHANNEL_ID>",
      "channel": "<CHANNEL_NAME>",
      "symbol": "<SYMBOL_ID_1>"
    },
    {
      "id": "<CHANNEL_ID>",
      "channel": "<CHANNEL_NAME>",
      "symbol": "<SYMBOL_ID_2>"
    }
  ]
}

Unsubscribe

Unsubscribe from a subscribed channel, please send the following example to WebSocket Server：

Python

futopt.unsubscribe({
    'id':'<CHANNEL_ID>'
})

Node.js

futopt.unsubscribe({ 
  id : '<CHANNEL_ID>'
});

C#

futopt.Unsubscribe("<CHANNEL_ID>");

After a successful unsubscription, you will receive the following event response：

{
  "event": "unsubscribed",
  "data": {
    "id": "<CHANNEL_ID>",
    "channel" : "<CHANNEL_NAME>",
    "symbol" : "<SYMBOL_ID>"
  }
}

Supports the unsubscription from multiple channels：

Python

futopt.unsubscribe({
    'ids':['<CHANNEL_ID>','<CHANNEL_ID>']
})

Node.js

futopt.unsubscribe({ 
  ids : ['<CHANNEL_ID>','<CHANNEL_ID>']
});

C#

futopt.Unsubscribe("<CHANNEL_ID>","<CHANNEL_ID>");

After a successful unsubscription, you will receive the following event response：

{
  "event": "unsubscribed",
  "data": [
    {
      "id": "<CHANNEL_ID_1>",
      "channel" : "<CHANNEL_NAME>",
      "symbol" : "<SYMBOL_ID>"
    },
    {
      "id": "<CHANNEL_ID_2>",
      "channel" : "<CHANNEL_NAME>",
      "symbol" : "<SYMBOL_ID>"
    }
  ]
}

Error Handle

When there is an anomaly in the WebSocket callback you subscribed to or processed, you can handle error messages as follows：

Python

def handle_connect():
    print('market data connected')


def handle_disconnect(code, message):
    print(f'market data disconnect: {code}, {message}')


def handle_error(error):
    print(f'market data error: {error}')

futopt.on("connect", handle_connect)
futopt.on("disconnect", handle_disconnect)
futopt.on("error", handle_error)

Node.js

futopt.on("connect", (message) => {
  const connect_msg = JSON.parse(message);
  console.log(connect_msg);
});

futopt.on("disconnect", (message) => {
  console.log(message);
});

futopt.on("error", (message) => {
  const err_msg = JSON.parse(message);
  console.log(err_msg);
});

C#

futopt.OnError += (errmsg) => Console.WriteLine($"handle error: {errmsg}");
futopt.OnConnected += (connmsg) => Console.WriteLine($"Connect: {connmsg}");
futopt.OnDisconnected += (disconmsg) => Console.WriteLine($"Disconnect: {disconmsg}");

Reconnection

The following is a simple demonstration that automatically reconnects the websocket when a disconnection event is detected using a callback:

Python

def handle_disconnect(code, message):
    print(f'market data disconnect: {code}, {message}')
    futopt.connect()
    print("Reconnected Succuess")
    print("Resubscribe")
    futopt.subscribe({    # 重新訂閱您已訂閱過的Channel與Symbol
        'channel': '<CHANNEL_NAME>', 
        'symbol': '<SYMBOL_ID>'
    })

Node.js

futopt.on("disconnect", (message) => {
  console.log(message);
  futopt.connect()
  console.log("Reconnected Succuess");
  futopt.subscribe({ channel: '<CHANNEL_NAME>', symbol: '<SYMBOL_ID>' });  //重新訂閱您已訂閱過的Channel與Symbol
});

C#

futopt.OnDisconnected += async (msg) =>
{
    Console.WriteLine($"disconnected at {DateTime.Now}");
    await Task.Delay(10);
    Console.WriteLine("Try Reconnected");
    await futopt.Connect();
    Console.WriteLine("Reconnected Success");
    Console.WriteLine("Resubscribe...");
    await futopt.Subscribe(FutureOptionChannel.<CHANNEL_NAME>, "<SYMBOL_ID>"); //重新訂閱您已訂閱過的Channel與Symbol
    Console.WriteLine("Resubscribe Success");
};