Signature Authentication

Request format

Send a POST request to https://www.fmz.com/api/v1 with the parameters as a form (application/x-www-form-urlencoded). The server also accepts the same parameters in the URL query string of a GET request, but then they end up in access logs along the way, so POST is recommended.

The request does not contain the SecretKey.

Signature

Concatenate the string below, where args is the exact JSON string being submitted:

            plaintext
            
            
version + "|" + method + "|" + args + "|" + nonce + "|" + secretKey

Compute the MD5 of the result and use its 32-character lowercase hexadecimal form as sign.

Python example

            python
            
            
import hashlib
import json
import time
import urllib.parse
import urllib.request

ACCESS_KEY = ''   # AccessKey of the API KEY
SECRET_KEY = ''   # SecretKey of the API KEY

def api(method, *args, **kwargs):
    d = {
        'version': '1.0',
        'access_key': ACCESS_KEY,
        'method': method,
        # Positional arguments are sent as an array, keyword arguments as an object (by name)
        'args': json.dumps(kwargs if kwargs else list(args)),
        'nonce': int(time.time() * 1000),
    }
    s = '%s|%s|%s|%d|%s' % (d['version'], d['method'], d['args'], d['nonce'], SECRET_KEY)
    d['sign'] = hashlib.md5(s.encode('utf-8')).hexdigest()
    body = urllib.parse.urlencode(d).encode('utf-8')
    with urllib.request.urlopen('https://www.fmz.com/api/v1', body, timeout=10) as resp:
        return json.loads(resp.read().decode('utf-8'))

print(api('GetNodeList'))                             # Docker list
print(api('GetRobotList', appId='member2'))           # By name: bots labeled member2
print(api('CommandRobot', 123, 'ok'))                 # Send an interactive command to bot 123
print(api('GetRobotDetail', 123))                     # Details of bot 123

Go example

            mylang
            
            
package main

import (
    "crypto/md5"
    "encoding/hex"
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "strconv"
    "time"
)

const (
    accessKey = "" // AccessKey of the API KEY
    secretKey = "" // SecretKey of the API KEY
    baseAPI   = "https://www.fmz.com/api/v1"
)

var client = &http.Client{Timeout: 10 * time.Second}

func api(method string, args ...interface{}) (string, error) {
    if args == nil {
        args = []interface{}{}
    }
    b, err := json.Marshal(args)
    if err != nil {
        return "", err
    }
    nonce := strconv.FormatInt(time.Now().UnixMilli(), 10)
    sum := md5.Sum([]byte("1.0|" + method + "|" + string(b) + "|" + nonce + "|" + secretKey))
    form := url.Values{
        "version":    {"1.0"},
        "access_key": {accessKey},
        "method":     {method},
        "args":       {string(b)},
        "nonce":      {nonce},
        "sign":       {hex.EncodeToString(sum[:])},
    }
    resp, err := client.PostForm(baseAPI, form)
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    body, err := io.ReadAll(resp.Body)
    return string(body), err
}

func main() {
    ret, err := api("GetNodeList")
    fmt.Println(ret, err)

    // Restart bot 123 with a new configuration; settings fields: see the bot configuration section in Extended API Interface Details
    settings := map[string]interface{}{
        "name":     "hedge test",
        "strategy": 456,
        "period":   60,
        "node":     789,
        "exchanges": []interface{}{
            map[string]interface{}{"pid": 1001, "pair": "BTC_USDT"},
        },
    }
    ret, err = api("RestartRobot", 123, settings)
    fmt.Println(ret, err)
}

Direct Verification

Direct verification computes no signature; the secret_key is put into the request parameters instead. This produces a fixed URL that can be entered into webhooks such as TradingView that accept only a single URL.

Security note: a secret_key in a URL ends up in browser history, proxy and server access logs, and the webhook provider's configuration; anyone who obtains the URL can call the API with this key's permissions. Use direct verification only for CommandRobot webhooks, and create a dedicated API KEY for it that is granted CommandRobot only (see Create ApiKey). If it leaks, delete that API KEY immediately.

The request parameters are access_key, secret_key, method and args (a JSON array, URL-encoded); version, nonce and sign are not needed. CommandRobot skips the nonce check; other methods are still checked: without a nonce the server uses the current time (to the second), so a second call within the same second returns a nonce error (code 3).

For example, with an API KEY whose AccessKey is xxx and SecretKey is yyy, opening the URL below sends the interactive command ok12345 to the live trading bot with ID 186515:

            plaintext
            
            
https://www.fmz.com/api/v1?access_key=xxx&secret_key=yyy&method=CommandRobot&args=%5B186515%2C%22ok12345%22%5D

Receiving a webhook body

When the command argument of CommandRobot is an empty string and the request is a POST, the server sends the request body to the bot as the interactive command. For example, set the TradingView webhook URL to:

            plaintext
            
            
https://www.fmz.com/api/v1?access_key=xxx&secret_key=yyy&method=CommandRobot&args=%5B186515%2C+%22%22%5D

The args value %5B186515%2C+%22%22%5D decodes to [186515, ""] (+ is a URL-encoded space): 186515 is the bot ID and the command is an empty string.

Simulating a TradingView webhook alert:

            javascript
            
            
function main() {
    var options = {
        method: "POST",
        body: `{"test": 123}`,
        headers: {"Content-Type": "application/json"}
    }

    // A webhook alert sends a POST request with the required headers automatically
    return HttpQuery("https://www.fmz.com/api/v1?access_key=xxx&secret_key=yyy&method=CommandRobot&args=%5B186515%2C+%22%22%5D", options)
}

The content of the TradingView alert message box is the request body:

• JSON format:

  

  
              plaintext
              
              
  {"close": {{close}}, "name": "aaa"}
  

  The bot with ID 186515 receives the interactive command {"close": 39773.75, "name": "aaa"}.

• Text format:

  

  
              plaintext
              
              
  BTCUSDTPERP Crossing 39700.00 close: {{close}}
  

  The bot with ID 186515 receives the interactive command BTCUSDTPERP Crossing 39700.00 close: 39739.4.

Python and Go examples

            python
            
            
import json
import urllib.parse
import urllib.request

ACCESS_KEY = ''   # AccessKey of an API KEY granted CommandRobot only
SECRET_KEY = ''   # SecretKey

def api(method, *args):
    query = urllib.parse.urlencode({
        'access_key': ACCESS_KEY,
        'secret_key': SECRET_KEY,
        'method': method,
        'args': json.dumps(list(args)),
    })
    with urllib.request.urlopen('https://www.fmz.com/api/v1?' + query, timeout=10) as resp:
        return json.loads(resp.read().decode('utf-8'))

# Without permission for the method the result is {'code': 4, 'data': None}
print(api('CommandRobot', 186515, 'ok12345'))

            mylang
            
            
package main

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "time"
)

const (
    accessKey = "" // AccessKey of an API KEY granted CommandRobot only
    secretKey = "" // SecretKey
    baseAPI   = "https://www.fmz.com/api/v1"
)

var client = &http.Client{Timeout: 10 * time.Second}

func api(method string, args ...interface{}) (string, error) {
    if args == nil {
        args = []interface{}{}
    }
    b, err := json.Marshal(args)
    if err != nil {
        return "", err
    }
    q := url.Values{
        "access_key": {accessKey},
        "secret_key": {secretKey},
        "method":     {method},
        "args":       {string(b)},
    }
    resp, err := client.Get(baseAPI + "?" + q.Encode())
    if err != nil {
        return "", err
    }
    defer resp.Body.Close()
    body, err := io.ReadAll(resp.Body)
    return string(body), err
}

func main() {
    ret, err := api("CommandRobot", 186515, "ok12345")
    fmt.Println(ret, err)
}

References:

• Trading on TradingView alert signals with the FMZ extended API
• Trading on TradingView alert signals with the FMZ extended API (video, Bilibili)

GetAccount

The GetAccount method is used to retrieve account information for the FMZ Quant Trading Platform account corresponding to the API KEY in the request.

Returns

            json
            
            
{
    "code":0,
    "data":{
        "result":{
            "balance":22944702436,
            "concurrent":0,
            "consumed":211092719653,
            "email":"[email protected]",
            "openai":false,
            "settings":null,
            "sns":{"wechat":true},
            "uid":"105ea6e51bcc177926a10fdbb7e2a1d6",
            "username":"abc"
        },
        "error":null
    }
}

• balance: Account balance in USD, stored as an integer for precision; divide by 1e8 (10 to the power of 8) to get the actual value, 229.44702436 in this example.
• consumed: Total amount spent, same unit and conversion as balance.

Arguments

No parameters

GetNodeList

The GetNodeList method returns the dockers available to the platform account of the API KEY in the request, including your own dockers and the platform's public dockers.

Returns

            json
            
            
{
    "code": 0,
    "data": {
        "result": {
            "all": 1,
            "nodes": [{
                "build": "3.7",
                "city": "...",
                "created": "2024-11-08 09:21:08",
                "date": "2024-11-08 16:37:16",
                "forward": "...",
                "guid": "...",
                "host": "node.fmz.com:9902",
                "id": 123,
                "ip": "...",
                "is_owner": true,
                "loaded": 0,
                "name": "MacBook-Pro-2.local",
                "online": true,
                "os": "darwin/amd64",
                "peer": "...",
                "public": 0,
                "region": "...",
                "tunnel": false,
                "version": "...",
                "wd": 0
            }]
        },
        "error": null
    }
}

Return value field descriptions (fields with obvious literal meanings are not elaborated):

• all: Total number of dockers (public dockers included).
• nodes: List of detailed information for docker nodes.
  • build: Version number.
  • city: City location.
  • is_owner: true indicates private docker, false indicates public docker.
  • loaded: Load amount, i.e., the number of currently running strategy instances.
  • public: 0 indicates private docker, 1 indicates public docker.
  • region: Geographic location.
  • version: Detailed version information of the docker.
  • wd: Offline alarm switch, 0 indicates not enabled.

One-click deployed dockers contain additional information, with related fields prefixed by ecs_ and unit_, recording information about the one-click deployed docker server (operator name, configuration, status, etc.), billing cycle, price, and other information, which will not be detailed here.

Arguments

DeleteNode

The DeleteNode method is used to delete a docker node under the FMZ Quant Trading Platform account corresponding to the API KEY in the request. The docker node ID to be deleted is specified by the nid parameter.

Returns

            json
            
            
{
    "code":0,
    "data":{
        "result":true,
        "error":null
    }
}

• result: Whether the associated docker program was successfully deleted.

Arguments

GetExchangeList

The GetExchangeList method is used to get the list of exchanges supported by the FMZ quantitative trading platform and their configuration information.

Returns

When the isSummary parameter is false, the returned data:

            json
            
            
{
    "code": 0,
    "data": {
        "result": {
            "exchanges": [{
                "category": "加密货币||Crypto",
                "eid": "Futures_Binance",
                "id": 74,
                "logo": "/upload/asset/d8d84b23e573e9326b99.svg",
                "meta": "[{\"desc\": \"Access Key\", \"qr\":\"apiKey\",\"required\": true, \"type\": \"string\", \"name\": \"AccessKey\", \"label\": \"Access Key\"}, {\"encrypt\": true, \"qr\":\"secretKey\",\"name\": \"SecretKey\", \"required\": true, \"label\": \"Secret Key\", \"type\": \"password\", \"desc\": \"Secret Key\"}]",
                "name": "币安期货|Futures_Binance",
                "priority": 200,
                "stocks": "BTC_USDT,ETH_USDT,ETH_USD",
                "website": "https://accounts.binance.com/zh-TC/register?ref=45110270"
            }]
        },
        "error": null
    }
}

When the isSummary parameter is true, the returned data:

            json
            
            
{
    "code": 0,
    "data": {
        "result": {
            "exchanges": [{
                "category": "加密货币||Crypto",
                "eid": "Futures_Binance",
                "id": 74,
                "logo": "/upload/asset/d8d84b23e573e9326b99.svg",
                "name": "币安期货|Futures_Binance",
                "priority": 200,
                "website": "https://accounts.binance.com/zh-TC/register?ref=45110270"
            }]
        },
        "error": null
    }
}

• meta: Exchange configuration metadata.

Arguments

GetPlatformList

The GetPlatformList method is used to get the list of configured exchanges under the FMZ Quant Trading Platform account corresponding to the API KEY in the request.

Returns

            json
            
            
{
    "code": 0,
    "data": {
        "result": {
            "all": 2,
            "platforms": [{
                "category": "加密货币||Crypto",
                "date": "2023-12-07 13:44:52",
                "eid": "Binance",
                "id": 123,
                "label": "币安",
                "logo": "...",
                "name": "币安现货|Binance",
                "stocks": ["BTC_USDT", "LTC_USDT", "ETH_USDT", "ETC_USDT", "BTC_TUSD", "ETH_TUSD", "BNB_TUSD"],
                "website": "..."
            }, {
                "category": "通用协议|Custom Protocol",
                "date": "2020-11-09 11:23:48",
                "eid": "Exchange",
                "id": 123,
                "label": "XX交易所REST协议",
                "logo": "...",
                "name": "通用协议|Custom Protocol",
                "stocks": ["BTC_USDT", "ETH_USDT"],
                "website": ""
            }]
        },
        "error": null
    }
}

• all: Total number of configured exchange objects.
• platforms: Exchange related information.
  • eid: Exchange identifier on the FMZ Quant Trading Platform, eid is required in certain configurations and parameters.

Arguments

GetStrategyList

The GetStrategyList method is used to retrieve platform strategy information.

Returns

            json
            
            
{
    "code": 0,
    "data": {
        "result": {
            "all": 123,
            "strategies": [{
                "category": 9,
                "date": "2024-11-10 20:40:04",
                "description": "",
                "forked": 0,
                "hits": 0,
                "id": 123,
                "is_buy": false,
                "is_owner": false,
                "language": 0,
                "last_modified": "2024-11-11 17:23:52",
                "name": "HedgeGridStrategy",
                "profile": {
                    "avatar": "...",
                    "nickname": "abc",
                    "uid": "4ed225440db1eda23fe05ed10184113e"
                },
                "public": 0,
                "tags": "",
                "uid": "4ed225440db1eda23fe05ed10184113e",
                "username": "abc"
            }]
        },
        "error": null
    }
}

• all: Total number of strategies matching the filter criteria.
• strategies: Detailed information of the strategies found; category and language take the values described in the parameters above.

Arguments

Remarks

There is no needArgs parameter. Passing an extra parameter after category, as older documentation did, shifts all following parameters; pass them in the order above, or by name:

            plaintext
            
            
api('GetStrategyList', 0, 10, -3, -1, -1, '')           # first 10 of your own strategies
api('GetStrategyList', strategyType=-3, language=7)     # all of your own Rust strategies

GetRobotGroupList

The GetRobotGroupList method is used to get the list of live trading groups under the FMZ Quant Trading Platform account corresponding to the API KEY in the request.

Returns

            json
            
            
{
    "code": 0,
    "data": {
        "result": {
            "items": [{
                "id": 3417,
                "name": "Test"
            }, {
                "id": 3608,
                "name": "Live Trading Demo"
            }]
        },
        "error": null
    }
}

• items: Live trading group information.
  • id: Live trading group ID.
  • name: Live trading group name.

The items field only records newly created groups, the "Default" group is not included in items.

Arguments

No parameters

GetRobotList

The GetRobotList method returns the live trading bots of the platform account of the API KEY in the request. All parameters are optional.

Returns

            json
            
            
{
    "code": 0,
    "data": {
        "result": {
            "all": 1,
            "concurrent": 0,
            "robots": [{
                "charge_time": 1731654846,
                "date": "2024-11-12 14:05:29",
                "end_time": "2024-11-15 14:56:32",
                "fixed_id": 4509153,
                "id": 591026,
                "is_sandbox": 0,
                "name": "Test",
                "node_guid": "45891bcf3d57f99b08a43dff76ee1ea1",
                "node_id": 4519153,
                "node_public": 0,
                "profit": 0,
                "public": 0,
                "refresh": 1731651257000,
                "start_time": "2024-11-15 14:56:30",
                "status": 3,
                "strategy_id": 411670,
                "strategy_isowner": true,
                "strategy_language": 0,
                "strategy_name": "Test",
                "strategy_public": 0,
                "uid": "105ed6e511cc977921610fdbb7e2a1d6",
                "wd": 0
            }]
        },
        "error": null
    }
}

• all: Total number of bots matching the filters.
• robots: Live trading bot information; status is the live trading status code.
  • group_id: Live trading bot group ID; if the live trading bot is in the default group, the group_id field is not included.

Arguments

Remarks

Using api() from the Python example on the signature authentication page:

• api('GetRobotList'): all live trading bots.
• api('GetRobotList', 'member2'): a single string is taken as the label; all bots labeled member2.
• api('GetRobotList', 0, 100, -1, 'member2', ''): positional parameters; up to 100 bots labeled member2, starting at offset 0.
• api('GetRobotList', appId='member2', length=100): the same by parameter name.

GetRobotDetail

The GetRobotDetail method is used to get detailed information of a live trading bot under the FMZ Quant Trading Platform account corresponding to the API KEY in the request. The detailed information of the live trading bot to be retrieved is specified by the robotId parameter.

Returns

            json
            
            
{
    "code": 0,
    "data": {
        "result": {
            "robot": {
                "charge_time": 1732246539,
                "charged": 5850000,
                "consumed": 5375000000,
                "date": "2018-12-28 14:34:51",
                "favorite": {
                    "added": false,
                    "type": "R"
                },
                "fixed_id": 123,
                "hits": 1,
                "id": 123,
                "is_deleted": 0,
                "is_manager": true,
                "is_sandbox": 0,
                "name": "Test",
                "node_id": 123,
                "pexchanges": {
                    "123": "Futures_OKX"
                },
                "phash": {
                    "123": "ca1aca74b9cf7d8624f2af2dac01e36d"
                },
                "plabels": {
                    "123": "OKX Futures"
                },
                "priority": 0,
                "profit": 0,
                "public": 0,
                "refresh": 1732244453000,
                "robot_args": "[]",
                "start_time": "2024-11-22 11:00:48",
                "status": 1,
                "strategy_args": "[]",
                "strategy_exchange_pairs": "[60,[123],[\"ETH_USDT\"]]",
                "strategy_id": 123,
                "strategy_last_modified": "2024-11-21 16:49:25",
                "strategy_name": "Test",
                "strategy_public": "0",
                "uid": "105ed6e51bcc17792a610fdbb7e2a1d6",
                "username": "abc",
                "wd": 0
            }
        },
        "error": null
    }
}

• charge_time: Next billing time (Unix timestamp in seconds), i.e. the end of the period already paid for.
• charged: Total billed time in seconds.
• consumed: Total amount charged in USD, stored as an integer scaled by 1e8; 5375000000 in the example is 53.75 USD.
• date: Creation date.
• fixed_id: Docker ID assigned during live trading. If auto-assigned, this value is -1.
• is_manager: Whether has permission to manage this live trading bot.
• is_sandbox: Whether it is a simulated trading bot.
• name: Live trading bot name.
• node_id: Docker ID.
• pexchanges: Exchange objects configured for the live trading bot, where 123 is the pid and "Futures_OKX" is the exchange ID (eid).
• plabels: Label information for the exchange objects configured for the live trading bot.
• profit: Live trading bot profit data.
• public: Whether the live trading bot is public.
• refresh: Last active time.
• strategy_exchange_pairs: Configured exchange objects and their trading pair information.
• wd: Whether offline alert is enabled.

Arguments

Remarks

Explanation of the strategy_exchange_pairs attribute, using the following data as an example:

            plaintext
            
            
"[60,[44314,42960,15445,14703],[\"BTC_USDT\",\"BTC_USDT\",\"ETH_USDT\",\"ETH_USDT\"]]"

The first data 60 indicates that the default K-line period set for the live trading bot is 1 minute, i.e., 60 seconds.

[44314,42960,15445,14703] are the pid values of the exchange objects configured for the live trading bot (arranged in the order they were added).

[\"BTC_USDT\",\"BTC_USDT\",\"ETH_USDT\",\"ETH_USDT\"] are the trading pairs set for the exchange objects configured for the live trading bot (corresponding one-to-one with the pid values in the order they were added).

GetRobotLogs

The GetRobotLogs method is used to get the live trading log information under the FMZ Quant Trading Platform account corresponding to the API KEY in the request. The live trading ID for which to get log information is specified by the robotId parameter.

Returns

            json
            
            
{
    "code": 0,
    "data": {
        "result": {
            "chart": "",
            "chartTime": 0,
            "logs": [{
                "Total": 20,
                "Max": 20,
                "Min": 1,
                "Arr": []
            }, {
                "Total": 0,
                "Max": 0,
                "Min": 0,
                "Arr": []
            }, {
                "Total": 0,
                "Max": 0,
                "Min": 0,
                "Arr": []
            }],
            "node_id": 123,
            "online": true,
            "refresh": 1732201544000,
            "status": 4,
            "summary": "...",
            "updateTime": 1732201532636,
            "wd": 0
        },
        "error": null
    }
}

• logs: Log information; the queried log data entries are stored in the Arr field.
  The first data structure in logs contains log records from the strategy log table in the live trading database.
  The second data structure in logs contains log records from the profit log table in the live trading database.
  The third data structure in logs contains log records from the chart log table in the live trading database.
• summary: Live trading status bar data.

Arguments

Remarks

• Strategy log table in database
  The description of the Arr attribute value in the first element (log data) of the logs attribute value (array structure) in the returned data is as follows:

  
              plaintext
              
              
  "Arr": [
      [3977, 3, "Futures_OKX", "", 0, 0, "Sell(688.9, 2): 20016", 1526954372591, "", ""],
      [3976, 5, "", "", 0, 0, "this_week Position too large, long: 2", 1526954372410, "", ""]
  ],
  

  id	logType	eid	orderId	price	amount	extra	date	contractType	direction
  3977	3	"Futures_OKX"	""	0	0	"Sell(688.9, 2): 20016"	1526954372591	""	""
  3976	5	""	""	0	0	"this_week Position too large, long: 2"	1526954372410	""	""

  extra is the additional information for the printed log.

  The log type descriptions corresponding to logType values are as follows:

  logType:	0	1	2	3	4	5	6
  logType meaning:	BUY	SALE	RETRACT	ERROR	PROFIT	MESSAGE	RESTART
  English meaning	Buy order log	Sell order log	Cancel order	Error	Profit	Message	Restart

• Profit chart log table in database
  The data in this chart log table is consistent with the profit logs in the strategy log table.

  
              plaintext
              
              
  "Arr": [
      [202, 2515.44, 1575896700315],
      [201, 1415.44, 1575896341568]
  ]
  

  Taking one log data as an example:

  
              plaintext
              
              
  [202, 2515.44, 1575896700315]
  

  202 is the log ID, 2515.44 is the profit value, 1575896700315 is the timestamp.

• Chart log table in database

  
              plaintext
              
              
  "Arr": [
      [23637, 0, "{\"close\":648,\"high\":650.5,\"low\":647,\"open\":650,\"x\":1575960300000}"],
      [23636, 5, "{\"x\":1575960300000,\"y\":3.0735}"]
  ]
  

  Taking one log data as an example:

  
              plaintext
              
              
  [23637, 0, "{\"close\":648,\"high\":650.5,\"low\":647,\"open\":650,\"x\":1575960300000}"],
  

  23637 is the log ID, 0 is the chart data series index, and the final data "{\"close\":648,\"high\":650.5,\"low\":647,\"open\":650,\"x\":1575960300000}" is the log data, which is the K-line data on the chart.

NewRobot

The NewRobot method creates a live trading bot under the platform account of the API KEY in the request and starts it; like creating a bot on the website, this charges fees.

Returns

            json
            
            
{
    "code":0,
    "data":{
        "result":591988,
        "error":null
    }
}

• result: The ID of the new bot on success; a negative number on failure, with the meaning of the abnormal codes in Live Trading Status Codes (e.g. -2 no docker found, -5 insufficient balance).

Arguments

            json
            
            
{
    "name": "test",
    "strategy": 123,
    "args": [],
    "exchanges": [
        {"pid": 123, "pair": "SOL_USDT"}
    ],
    "period": 60,
    "node": 123,
    "group": 123,
    "appid": "test"
}

Remarks

When the exchange configuration is passed directly with eid, the platform does not store the keys in meta, so every later RestartRobot of this bot must pass settings again.

RestartRobot

The RestartRobot method starts (restarts) a live trading bot of the platform account of the API KEY in the request; the bot is given by robotId. Starting a bot charges fees.

Returns

            json
            
            
{
    "code":0,
    "data":{
        "result":1,
        "error":null
    }
}

• result: Live trading status code, 1 indicates running.

Arguments

Remarks

A bot created on the website with exchange accounts referenced by pid can be started with robotId alone, using its current configuration. A bot whose exchanges were passed directly with eid (usually created through the extended API) has no stored keys, so settings must be passed on every restart.

StopRobot

The StopRobot method is used to stop a live trading bot under the FMZ Quant Trading Platform account corresponding to the API KEY in the request. The bot Id to be stopped is specified by the robotId parameter.

Returns

            json
            
            
{
    "code":0,
    "data":{
        "result":2,
        "error":null
    }
}

• result: Bot status code, 2 indicates stopping.

Arguments

CommandRobot

The CommandRobot method is used to send interactive commands to a live trading bot under the FMZ Quant Trading Platform account corresponding to the API KEY in the request. The bot Id that receives the interactive command is specified by the robotId parameter, and the interactive command is captured and returned by the GetCommand() function called in the strategy.

Returns

            json
            
            
{
    "code":0,
    "data":{
        "result":true,
        "error":null
    }
}

• result: Whether the interactive command was sent successfully. When sending a command to a bot that is not running, the result in the returned data will be false.

Arguments

Remarks

Example of bot strategy (assuming this strategy bot is running with bot Id 123):

            javascript
            
            
function main() {
    while (true) {
        var cmd = GetCommand()
        if (cmd) {
            Log(cmd)
        }
        Sleep(2000)
    }
}

Calling api("CommandRobot", 123, "test command") with api() from the Python example on the signature authentication page, the bot with Id 123 will receive the interactive command: test command, and output it through the Log function.

DeleteRobot

The DeleteRobot method deletes a live trading bot of the platform account of the API KEY in the request; the bot is given by robotId. A running bot must be stopped first. Deletion cannot be undone.

Returns

            json
            
            
{
    "code":0,
    "data":{
        "result":0,
        "error":null
    }
}

• result: Result of the deletion.
  • 0: deleted.
  • -1: not deleted: the bot does not exist, or it is still running, starting or stopping.
  • -2: the bot was deleted, but its docker could not be reached, so the log data was not removed; delete it manually under logs/storage/<bot ID>/ in the docker's directory (e.g. 123.db3).

Arguments

PluginRun

The PluginRun method runs a piece of JavaScript code on a docker and returns the result. It uses the same execution mechanism as the "Debug Tool" among the development tools and trading terminal plugins (see Integrations → Trading Terminal → Plugin Principle and Development). No live trading bot is created and nothing is charged; one run lasts at most 5 minutes.

Returns

            json
            
            
{
    "code": 0,
    "data": {
        "result": "{\"logs\":[{\"PlatformId\":\"\",\"OrderId\":\"0\",\"LogType\":5,\"Price\":0,\"Amount\":0,\"Extra\":\"Hello FMZ\",\"Currency\":\"\",\"Instrument\":\"\",\"Direction\":\"\",\"Time\":1732267473108}],\"result\":\"\"}",
        "error": null
    }
}

• result: The result as a JSON string: logs holds the logs written with Log(), result the JSON text of the value returned by main().

Arguments

            json
            
            
{
    "source": "function main() {Log(\"Hello FMZ\")}",
    "node": 123,
    "period": 60,
    "exchanges": [{"pid": 123, "pair": "SOL_USDT"}]
}

Remarks

exchanges can also pass the exchange configuration directly instead of referencing an exchange account on the platform, for example:

            plaintext
            
            
{"eid": "Binance", "pair": "ETH_BTC", "meta": {"AccessKey": "...", "SecretKey": "..."}}

The field names of meta are given by the meta returned by GetExchangeList. Usually only one exchange object is set in exchanges (the debug tool page also supports only one); setting two causes no error, but accessing the second exchange object in the code does.