Deribit API v2.0.0

Overview

Deribit provides three different interfaces to access the API:

JSON-RPC over Websocket
JSON-RPC over HTTP
FIX (Financial Information eXchange)

With the API Console you can use and test the JSON-RPC API, both via HTTP and via Websocket. To visit the API console, go to Account > API tab > API Console tab.

Error Codes (HTTP and Websocket RPC Error codes)

Naming

Deribit tradeable assets or instruments use the following system of naming:

Kind	Examples	Template	Comments
Future	`BTC-25MAR16`, `BTC-5AUG16`	`BTC-DMMMYY`	`BTC` is currency, `DMMMYY` is expiration date, `D` stands for day of month (1 or 2 digits), `MMM` - month (3 first letters in English), `YY` stands for year.
Perpetual	`BTC-PERPETUAL`		Perpetual contract for currency `BTC`.
Option	`BTC-25MAR16-420-C`, `BTC-5AUG16-580-P`	`BTC-DMMMYY-STRIKE-K`	`STRIKE` is option strike price in USD. Template `K` is option kind: `C` for call options or `P` for put options.

Rate Limits

Rate limits are described on separate document.

JSON-RPC

JSON-RPC is a light-weight remote procedure call (RPC) protocol. The JSON-RPC specification defines the data structures that are used for the messages that are exchanged between client and server, as well as the rules around their processing. JSON-RPC uses JSON (RFC 4627) as data format.

JSON-RPC is transport agnostic: it does not specify which transport mechanism must be used. The Deribit API supports both Websocket (preferred) and HTTP (with limitations: subscriptions are not supported over HTTP).

Request messages

An example of a request message:

{
    "jsonrpc": "2.0",
    "id": 8066,
    "method": "public/ticker",
    "params": {
        "instrument": "BTC-24AUG18-6500-P"
    }
}

According to the JSON-RPC sepcification the requests must be JSON objects with the following fields.

Name	Type	Description
jsonrpc	string	The version of the JSON-RPC spec: "2.0"
id	integer or string	An identifier of the request. If it is included, then the response will contain the same identifier
method	string	The method to be invoked
params	object	The parameters values for the method. The field names must match with the expected parameter names. The parameters that are expected are described in the documentation for the methods, below.

Response messages

An example of a response message:

{
    "jsonrpc": "2.0",
    "id": 5239,
    "testnet": false,
    "result": [
        {
            "currency": "BTC",
            "currencyLong": "Bitcoin",
            "minConfirmation": 2,
            "txFee": 0.0006,
            "isActive": true,
            "coinType": "BITCOIN",
            "baseAddress": null
        }
    ],
    "usIn": 1535043730126248,
    "usOut": 1535043730126250,
    "usDiff": 2
}

The JSON-RPC API always responds with a JSON object with the following fields.

Name	Type	Description
id	integer	This is the same id that was sent in the request.
result	any	If successful, the result of the API call. The format for the result is described with each method.
error	error object	Only present if there was an error invoking the method. The error object is described below.
testnet	boolean	Indicates whether the API in use is actually the test API. `false` for production server, `true` for test server.
usIn	integer	The timestamp when the requests was received (microseconds since the Unix epoch)
usOut	integer	The timestamp when the response was sent (microseconds since the Unix epoch)
usDiff	integer	The number of microseconds that was spent handling the request

The fields testnet, usIn, usOut and usDiff are not part of the JSON-RPC standard.

In order not to clutter the examples they will generally be omitted from the example code.

An example of a response with an error:

{
    "jsonrpc": "2.0",
    "id": 8163,
    "error": {
        "code": 11050,
        "message": "bad_request"
    },
    "testnet": false,
    "usIn": 1535037392434763,
    "usOut": 1535037392448119,
    "usDiff": 13356
}

In case of an error the response message will contain the error field, with as value an object with the following with the following fields:

Name	Type	Description
code	integer	A number that indicates the kind of error.
message	string	A short description that indicates the kind of error.
data	any	Additional data about the error. This field may be omitted.

Notifications

An example of a notification:

{
    "jsonrpc": "2.0",
    "method": "subscription",
    "params": {
        "channel": "deribit_price_index.btc_usd",
        "data": {
            "timestamp": 1535098298227,
            "price": 6521.17,
            "index_name": "btc_usd"
        }
    }
}

API users can subscribe to certain types of notifications. This means that they will receive JSON-RPC notification-messages from the server when certain events occur, such as changes to the index price or changes to the order book for a certain instrument.

The API methods public/subscribe and private/subscribe are used to set up a subscription. Since HTTP does not support the sending of messages from server to client, these methods are only availble when using the Websocket transport mechanism.

At the moment of subscription a "channel" must be specified. The channel determines the type of events that will be received. See Subscriptions for more details about the channels.

In accordance with the JSON-RPC specification, the format of a notification is that of a request message without an id field. The value of the method field will always be "subscription". The params field will always be an object with 2 members: channel and data. The value of the channel member is the name of the channel (a string). The value of the data member is an object that contains data that is specific for the channel.

Authentication

An example of a JSON request with token:

{
    "id": 5647,
    "method": "private/get_subaccounts",
    "params": {
        "access_token": "1582628593469.1MbQ-J_4.CBP-OqOwm_FBdMYj4cRK2dMXyHPfBtXGpzLxhWg31nHu3H_Q60FpE5_vqUBEQGSiMrIGzw3nC37NMb9d1tpBNqBOM_Ql9pXOmgtV9Yj3Pq1c6BqC6dU6eTxHMFO67x8GpJxqw_QcKP5IepwGBD-gfKSHfAv9AEnLJkNu3JkMJBdLToY1lrBnuedF3dU_uARm"
    }
}

The API consists of public and private methods. The public methods do not require authentication. The private methods use OAuth 2.0 authentication. This means that a valid OAuth access token must be included in the request, which can be achived by calling method public/auth.

When the token was assigned to the user, it should be passed along, with other request parameters, back to the server:

Connection type	Access token placement
Websocket	Inside request JSON parameters, as an `access_token` field
HTTP (REST)	Header `Authorization: bearerToken` value

Additional authorization method - basic user credentials

! Not recommended - however, it could be useful for quick testing API

Every private method could be accessed by providing, inside HTTP Authorization: Basic XXX header, values with user ClientId and assigned ClientSecret (both values can be found on the API page on the Deribit website) encoded with Base64:

Authorization: Basic BASE64(ClientId + : + ClientSecret)

Additional authorization method - Deribit signature credentials

The Derbit service provides dedicated authorization method, which harness user generated signature to increase security level for passing request data. Generated value is passed inside Authorization header, coded as:

Authorization: deri-hmac-sha256 id=ClientId,ts=Timestamp,sig=Signature,nonce=Nonce

where:

Deribit credential	Description
ClientId	Can be found on the API page on the Deribit website (the user can configure up to 8 different `IDs` - with different privileges)
Timestamp	Time when the request was generated - given as miliseconds. It's valid for 60 seconds since generation, after that time any request with an old timestamp will be rejected.
Signature	Value for signature calculated as described below
Nonce	Single usage, user generated initialization vector for the server token

The signature is generated by the following formula:

RequestData = UPPERCASE(HTTP_METHOD()) + "\n" + URI() + "\n" + RequestBody + "\n";
StringToSign = Timestamp + "\n" + Nonce + "\n" + RequestData;
Signature = HEX_STRING( HMAC-SHA256( ClientSecret, StringToSign ) );

Note the newline characters in RequestData and StringToSign variables. If RequestBody is ommitted in RequestData, it's treated as an empty string, so these three newline characters must always be present.

Example using shell with openssl tool:

    ClientId=AMANDA
    ClientSecret=AMANDASECRECT
    Timestamp=$( date +%s000 )
    Nonce=$( cat /dev/urandom | tr -dc 'a-z0-9' | head -c8 )
    URI="/api/v2/private/get_account_summary?currency=BTC"
    HttpMethod=GET
    Body=""

    Signature=$( echo -ne "${Timestamp}\n${Nonce}\n${HttpMethod}\n${URI}\n${Body}\n" | openssl sha256 -r -hmac "$ClientSecret" | cut -f1 -d' ' )

    echo $Signature

    shell output> 9bfbc51a2bc372d72cc396cf1a213dc78d42eb74cb7dc272351833ad0de276ab (WARNING: Exact value depends on current timestamp and client credentials)

    curl -s -X ${HttpMethod} -H "Authorization: deri-hmac-sha256 id=${ClientId},ts=${Timestamp},nonce=${Nonce},sig=${Signature}" "https://www.deribit.com${URI}"

Additional authorization method - signature credentials (WebSocket API)

Example of authorization using client_signature:

# see javascript or python example

// using CryptoJS library
var clientId = "AMANDA";
var clientSecret = "AMANDASECRECT";
var timestamp = Date.now();
var nonce = "abcd";
var data = "";
var signature = CryptoJS.HmacSHA256(`${timestamp}\n${nonce}\n${data}`, accessSecret).toString();

var msg = {
    "jsonrpc" : "2.0",
    "id" : 4316,
    "method" : "public/auth",
    "params" : {
        "grant_type": "client_signature",
        "client_id": clientId,
        "timestamp": timestamp,
        "signature": signature,
        "nonce": nonce,
        "data": data
    }
};
var ws = new WebSocket('wss://test.deribit.com/ws/api/v2');
ws.onmessage = function (e) {
    // do something with the response...
    console.log('received from server : ', e.data);
};
ws.onopen = function () {
    ws.send(JSON.stringify(msg));
};

import asyncio
import websockets
import json
import hmac
import hashlib
from datetime import datetime

clientId = "AMANDA"
clientSecret = "AMANDASECRECT"
timestamp = round(datetime.now().timestamp() * 1000)
nonce = "abcd"
data = ""
signature = hmac.new(
    bytes(clientSecret, "latin-1"),
    msg=bytes('{}\n{}\n{}'.format(timestamp, nonce, data), "latin-1"),
    digestmod=hashlib.sha256
).hexdigest().lower()

msg = {
    "jsonrpc": "2.0",
    "id": 8748,
    "method": "public/auth",
    "params": {
        "grant_type": "client_signature",
        "client_id": clientId,
        "timestamp": timestamp,
        "signature": signature,
        "nonce": nonce,
        "data": data
    }
}

print(msg)

async def call_api(msg):
    async with websockets.connect('wss://test.deribit.com/ws/api/v2') as websocket:
        await websocket.send(msg)
        while websocket.open:
            response = await websocket.recv()
            print(response)

asyncio.get_event_loop().run_until_complete(call_api(json.dumps(msg)))

When connecting through Websocket, user can request for authorization using client_signature method, which requires providing following parameters (as a part of JSON request):

JSON parameter	Description
grant_type	Must be client_signature
client_id	Can be found on the API page on the Deribit website (the user can configure up to 8 different `IDs` - with different privileges)
timestamp	Time when the request was generated - given as miliseconds. It's valid for 60 seconds since generation, after that time any request with an old timestamp will be rejected.
signature	Value for signature calculated as described below
nonce	Single usage, user generated initialization vector for the server token
data	Optional field, which contains any user specific value

The signature is generated by the following formula:

StringToSign = Timestamp + "\n" + Nonce + "\n" + Data;
Signature = HEX_STRING( HMAC-SHA256( ClientSecret, StringToSign ) );

Note the newline characters separating parts of the StringToSign variable. If Data is ommitted, it's treated as an empty string, so these two newline characters must always be present.

Example using shell with openssl tool:

    ClientId=AMANDA
    ClientSecret=AMANDASECRECT
    Timestamp=$( date +%s000 ) # e.g. 1576074319000
    Nonce=$( cat /dev/urandom | tr -dc 'a-z0-9' | head -c8 ) # e.g. 1iqt2wls
    Data=""

    Signature=$( echo -ne "${Timestamp}\n${Nonce}\n${Data}" | openssl sha256 -r -hmac "$ClientSecret" | cut -f1 -d' ' )

    echo $Signature

    shell output> 56590594f97921b09b18f166befe0d1319b198bbcdad7ca73382de2f88fe9aa1 (WARNING: Exact value depends on current timestamp and client credentials)

You can also check the signature value using some online tools like, e.g: https://codebeautify.org/hmac-generator (remember that you should use it only with your test credentials).

Here's a sample JSON request created using the values from the example above:

{ "jsonrpc" : "2.0", "id" : 9929, "method" : "public/auth", "params" : { "grant_type" : "client_signature", "client_id" : "AMANDA", "timestamp": "1576074319000", "nonce": "1iqt2wls", "data": "", "signature" : "56590594f97921b09b18f166befe0d1319b198bbcdad7ca73382de2f88fe9aa1" } }

Access scope

When asking for access token user can provide the required access level (called scope) which defines what type of functionality he/she wants to use, and whether requests are only going to check for some data or also to update them. Scopes are required and checked for private methods, so if you plan to use only public information you can stay with values assigned by default.

Scope	Description
mainaccount	It is set automatically by the server when currently connecting user (his/her credentials) is the main user, otherwise it's not included in the final scope.
connection	Access with requested parameters is granted when connection is open (or till expiration time). When the connection is closed user need to repeat the authentication request to get new tokens. It is set and used automatically by the server when neither connection nor session scope is provided within the request.
session:name	The server creates a new session with name provided by the user, then generates tokens and binds them with the session. Access is granted during session lifetime. It allows to reconnect to the server and reuse assigned tokens (before their expiration time). Note that only 16 sessions are allowed per user - when limit is reached session with the shortest lifetime is removed. When using WebSocket it also allows (due to the fact that tokens are bound to the created session) skipping providing `access_token` with every subsequent request.
account:read	Access to account methods - read only data.
account:read_write	Access to account methods - allows to manage account settings, add subaccounts, etc.
trade:read	Access to trade methods - read only data.
trade:read_write	Access to trade methods - required to create and modify orders.
wallet:read	Access to wallet methods - read only data.
wallet:read_write	Access to wallet methods - allows to withdraw, generate new deposit address, etc.
wallet:none, account:none, trade:none	Blocked access to specified functionality.
expires:NUMBER	Access token will expire after `NUMBER` of seconds.
ip:ADDR	Token will work with connection from `ADDR` IPv4 address, when `*` is provided as `ADDR` token will work from all IP addresses.
block_trade:read	Access to block_trade methods - reading info about block trades - read only data.
block_trade:read_write	Access to block_trade methods - required to create block trades.

NOTICE: Depending on choosing an authentication method (grant type) some scopes could be narrowed by the server or limited by user API key configured scope, e.g. when grant_type = client_credentials and scope = wallet:read_write could be modified by the server as scope = wallet:read.

The user shouldn't assume that requested values are blindly accepted and should verify assigned scoped.

JSON-RPC over websocket

Websocket is the prefered transport mechanism for the JSON-RPC API, because it is faster and because it can support subscriptions and cancel on disconnect. The code examples that can be found next to each of the methods show how websockets can be used from Python or Javascript/node.js.

JSON-RPC over HTTP

Besides websockets it is also possible to use the API via HTTP. The code examples for 'shell' show how this can be done using curl. Note that subscriptions and cancel on disconnect are not supported via HTTP.

Methods

Authentication

/public/auth

curl -X GET "https://test.deribit.com/api/v2/public/auth?client_id=fo7WAPRm4P&client_secret=W0H6FJW4IRPZ1MOQ8FP6KMC5RZDUUKXS&grant_type=client_credentials" \
-H "Content-Type: application/json"

var msg = 
{
  "jsonrpc" : "2.0",
  "id" : 9929,
  "method" : "public/auth",
  "params" : {
    "grant_type" : "client_credentials",
    "client_id" : "fo7WAPRm4P",
    "client_secret" : "W0H6FJW4IRPZ1MOQ8FP6KMC5RZDUUKXS"
  }
};
var ws = new WebSocket('wss://test.deribit.com/ws/api/v2');
ws.onmessage = function (e) {
    // do something with the response...
    console.log('received from server : ', e.data);
};
ws.onopen = function () {
    ws.send(JSON.stringify(msg));
};

import asyncio
import websockets
import json

msg = \
{
  "jsonrpc" : "2.0",
  "id" : 9929,
  "method" : "public/auth",
  "params" : {
    "grant_type" : "client_credentials",
    "client_id" : "fo7WAPRm4P",
    "client_secret" : "W0H6FJW4IRPZ1MOQ8FP6KMC5RZDUUKXS"
  }
}

async def call_api(msg):
   async with websockets.connect('wss://test.deribit.com/ws/api/v2') as websocket:
       await websocket.send(msg)
       while websocket.open:
           response = await websocket.recv()
           # do something with the response...
           print(response)

asyncio.get_event_loop().run_until_complete(call_api(json.dumps(msg)))

The above command returns JSON structured like this (real example):

{
  "jsonrpc": "2.0",
  "id": 9929,
  "result": {
      "access_token": "1582628593469.1MbQ-J_4.CBP-OqOwm_FBdMYj4cRK2dMXyHPfBtXGpzLxhWg31nHu3H_Q60FpE5_vqUBEQGSiMrIGzw3nC37NMb9d1tpBNqBOM_Ql9pXOmgtV9Yj3Pq1c6BqC6dU6eTxHMFO67x8GpJxqw_QcKP5IepwGBD-gfKSHfAv9AEnLJkNu3JkMJBdLToY1lrBnuedF3dU_uARm",
      "expires_in": 31536000,
      "refresh_token": "1582628593469.1GP4rQd0.A9Wa78o5kFRIUP49mScaD1CqHgiK50HOl2VA6kCtWa8BQZU5Dr03BhcbXPNvEh3I_MVixKZXnyoBeKJwLl8LXnfo180ckAiPj3zOclcUu4zkXuF3NNP3sTPcDf1B3C1CwMKkJ1NOcf1yPmRbsrd7hbgQ-hLa40tfx6Oa-85ymm_3Z65LZcnCeLrqlj_A9jM",
      "scope": "connection mainaccount",
      "token_type": "bearer"
  }
}

Retrieve an Oauth access token, to be used for authentication of 'private' requests.

Three methods of authentication are supported:

client_credentials - using the access key and access secret that can be found on the API page on the website
client_signature - using the access key that can be found on the API page on the website and user generated signature. The signature is calculated using some fields provided in the request, using formula described here Deribit signature credentials
refresh_token - using a refresh token that was received from an earlier invocation

The response will contain an access token, expiration period (number of seconds that the token is valid) and a refresh token that can be used to get a new set of tokens.

Parameter	Required	Type	Enum	Description
grant_type	true	string	`client_credentials` `client_signature` `refresh_token`	Method of authentication
client_id	true	string		Required for grant type `client_credentials` and `client_signature`
client_secret	true	string		Required for grant type `client_credentials`
refresh_token	true	string		Required for grant type `refresh_token`
timestamp	true	integer		Required for grant type `client_signature`, provides time when request has been generated
signature	true	string		Required for grant type `client_signature`; it's a cryptographic signature calculated over provided fields using user secret key. The signature should be calculated as an HMAC (Hash-based Message Authentication Code) with `SHA256` hash algorithm
nonce	false	string		Optional for grant type `client_signature`; delivers user generated initialization vector for the server token
data	false	string		Optional for grant type `client_signature`; contains any user specific value
state	false	string		Will be passed back in the response
scope	false	string		Describes type of the access for assigned token, possible values: `connection`, `session:name`, `trade:[read, read_write, none]`, `wallet:[read, read_write, none]`, `account:[read, read_write, none]`, `expires:NUMBER`, `ip:ADDR`. Details are elucidated in Access scope

Name	Type	Description
id	integer	The id that was sent in the request
jsonrpc	string	The JSON-RPC version (2.0)
result	object
› acccess_token	string
› expires_in	integer	Token lifetime in seconds
› refresh_token	string	Can be used to request a new token (with a new lifetime)
› scope	string	Type of the access for assigned token
› state	string	Copied from the input (if applicable)
› token_type	string	Authorization type, allowed value - `bearer`

Parameter	Required	Type	Enum	Description
client_name	true	string		Client software name
client_version	true	string		Client software version

Parameter	Required	Type	Enum	Description
start_timestamp	false	integer		Timestamp from which we want to retrieve announcements
count	false	integer		Maximum count of returned announcements

Parameter	Required	Type	Enum	Description
id	true	integer		Id of key
name	true	string		Name of key (only letters, numbers and underscores allowed; maximum length - 16 characters)

Parameter	Required	Type	Enum	Description
sid	true	integer		The user id for the subaccount
name	true	string		The new user name

Parameter	Required	Type	Description
max_scope	true	string
default	false	boolean	If `true`, new key is marked as default
name	false	string	Name of key (only letters, numbers and underscores allowed; maximum length - 16 characters)

Parameter	Required	Type	Enum	Description
currency	true	string	`BTC` `ETH`	The currency symbol
extended	false	boolean		Include additional fields

Parameter	Required	Type	Enum	Description
instrument_name	true	string		Instrument name
amount	true	number		It represents the requested order size. For perpetual and futures the amount is in USD units, for options it is amount of corresponding cryptocurrency contracts, e.g., BTC or ETH
type	false	string	`limit` `stop_limit` `market` `stop_market`	The order type, default: `"limit"`
label	false	string		user defined label for the order (maximum 64 characters)
price	false	number		The order price in base currency (Only for limit and stop_limit orders) When adding order with advanced=usd, the field price should be the option price value in USD. When adding order with advanced=implv, the field price should be a value of implied volatility in percentages. For example, price=100, means implied volatility of 100%
time_in_force	false	string	`good_til_cancelled` `fill_or_kill` `immediate_or_cancel`	Specifies how long the order remains in effect. Default `"good_til_cancelled"` `"good_til_cancelled"` - unfilled order remains in order book until cancelled `"fill_or_kill"` - execute a transaction immediately and completely or not at all `"immediate_or_cancel"` - execute a transaction immediately, and any portion of the order that cannot be immediately filled is cancelled
max_show	false	number		Maximum amount within an order to be shown to other customers, `0` for invisible order
post_only	false	boolean		If true, the order is considered post-only. If the new price would cause the order to be filled immediately (as taker), the price will be changed to be just below the spread. Only valid in combination with time_in_force=`"good_til_cancelled"`
reject_post_only	false	boolean		If order is considered post-only and this field is set to true than order is put to order book unmodified or request is rejected. Only valid in combination with `"post_only"` set to true
reduce_only	false	boolean		If `true`, the order is considered reduce-only which is intended to only reduce a current position
stop_price	false	number		Stop price, required for stop limit orders (Only for stop orders)
trigger	false	string	`index_price` `mark_price` `last_price`	Defines trigger type, required for `"stop_limit"` order type
advanced	false	string	`usd` `implv`	Advanced option order type. (Only for options)

Parameter	Required	Type	Enum	Description
order_id	true	string		The order id
amount	true	number		It represents the requested order size. For perpetual and futures the amount is in USD units, for options it is amount of corresponding cryptocurrency contracts, e.g., BTC or ETH
price	true	number		The order price in base currency. When editing an option order with advanced=usd, the field price should be the option price value in USD. When editing an option order with advanced=implv, the field price should be a value of implied volatility in percentages. For example, price=100, means implied volatility of 100%
post_only	false	boolean		If true, the order is considered post-only. If the new price would cause the order to be filled immediately (as taker), the price will be changed to be just below or above the spread (accordingly to the original order type). Only valid in combination with time_in_force=`"good_til_cancelled"`
reduce_only	false	boolean		If `true`, the order is considered reduce-only which is intended to only reduce a current position
reject_post_only	false	boolean		If order is considered post-only and this field is set to true than order is put to order book unmodified or request is rejected. Only valid in combination with `"post_only"` set to true
advanced	false	string	`usd` `implv`	Advanced option order type. If you have posted an advanced option order, it is necessary to re-supply this parameter when editing it (Only for options)
stop_price	false	number		Stop price, required for stop limit orders (Only for stop orders)

Deribit API v2.0.0

Overview

Naming

Rate Limits

JSON-RPC

Request messages

Response messages

Notifications

Authentication

Additional authorization method - basic user credentials

Additional authorization method - Deribit signature credentials

Additional authorization method - signature credentials (WebSocket API)

Access scope

JSON-RPC over websocket

JSON-RPC over HTTP

Methods

Authentication

/public/auth

Parameters

Response

/public/exchange_token

Parameters

Response

/public/fork_token

Parameters

Response

/private/logout

Parameters

Response

Session management

/public/set_heartbeat

Parameters

Response

/public/disable_heartbeat

Parameters

Response

/private/enable_cancel_on_disconnect

Parameters

Response

/private/disable_cancel_on_disconnect

Parameters

Response

/private/get_cancel_on_disconnect

Parameters

Response

Supporting

/public/get_time

Parameters

Response

/public/hello

Parameters

Response

/public/test

Parameters

Response

Subscription management

/public/subscribe

Parameters

Response

/public/unsubscribe

Parameters

Response

/private/subscribe

Parameters

Response

/private/unsubscribe

Parameters

Response

Account management

/public/get_announcements

Parameters

Response

/private/change_api_key_name

Parameters

Response

/private/change_scope_in_api_key

Parameters

Response

/private/change_subaccount_name

Parameters