///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // cTrader OpenAPI 9.3 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// syntax="proto2"; package ctrader_open_api; ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// ENUMS ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// enum ProtoPayloadType { PROTO_MESSAGE = 5; ERROR_RES = 50; HEARTBEAT_EVENT = 51; } // COMMON error codes, 1 - 99 enum ProtoErrorCode { UNKNOWN_ERROR = 1; // Generic error. UNSUPPORTED_MESSAGE = 2; // Message is not supported. Wrong message. INVALID_REQUEST = 3; // Generic error. Usually used when input value is not correct. TIMEOUT_ERROR = 5; // Deal execution has reached timeout and rejected. ENTITY_NOT_FOUND = 6; // Generic error for requests by id. CANT_ROUTE_REQUEST = 7; // Connection to Server is lost or not supported. FRAME_TOO_LONG = 8; // Message is too large. MARKET_CLOSED = 9; // Market is closed. CONCURRENT_MODIFICATION = 10; // Order is blocked (e.g. under execution) and change cannot be applied. BLOCKED_PAYLOAD_TYPE = 11; // Message is blocked by server or rate limit is reached. } enum ProtoOAPayloadType { PROTO_OA_APPLICATION_AUTH_REQ = 2100; PROTO_OA_APPLICATION_AUTH_RES = 2101; PROTO_OA_ACCOUNT_AUTH_REQ = 2102; PROTO_OA_ACCOUNT_AUTH_RES = 2103; PROTO_OA_VERSION_REQ = 2104; PROTO_OA_VERSION_RES = 2105; PROTO_OA_NEW_ORDER_REQ = 2106; PROTO_OA_CANCEL_ORDER_REQ = 2108; PROTO_OA_AMEND_ORDER_REQ = 2109; PROTO_OA_AMEND_POSITION_SLTP_REQ = 2110; PROTO_OA_CLOSE_POSITION_REQ = 2111; PROTO_OA_TRADER_REQ = 2121; PROTO_OA_TRADER_RES = 2122; PROTO_OA_RECONCILE_REQ = 2124; PROTO_OA_RECONCILE_RES = 2125; PROTO_OA_EXECUTION_EVENT = 2126; PROTO_OA_SUBSCRIBE_SPOTS_REQ = 2127; PROTO_OA_SUBSCRIBE_SPOTS_RES = 2128; PROTO_OA_UNSUBSCRIBE_SPOTS_REQ = 2129; PROTO_OA_UNSUBSCRIBE_SPOTS_RES = 2130; PROTO_OA_SPOT_EVENT = 2131; PROTO_OA_ORDER_ERROR_EVENT = 2132; PROTO_OA_ERROR_RES = 2142; PROTO_OA_ACCOUNTS_TOKEN_INVALIDATED_EVENT = 2147; PROTO_OA_CLIENT_DISCONNECT_EVENT = 2148; PROTO_OA_GET_ACCOUNTS_BY_ACCESS_TOKEN_REQ = 2149; PROTO_OA_GET_ACCOUNTS_BY_ACCESS_TOKEN_RES = 2150; PROTO_OA_ACCOUNT_DISCONNECT_EVENT = 2164; PROTO_OA_REFRESH_TOKEN_REQ = 2173; PROTO_OA_REFRESH_TOKEN_RES = 2174; } // Enum for specifying symbol trading mode enum ProtoOATradingMode { ENABLED = 0; DISABLED_WITHOUT_PENDINGS_EXECUTION = 1; DISABLED_WITH_PENDINGS_EXECUTION = 2; CLOSE_ONLY_MODE = 3; } // Enum for specifying SWAP calculation type for symbol. enum ProtoOASwapCalculationType { PIPS = 0; // Specifies type of SWAP computation as PIPS (0) PERCENTAGE = 1; // Specifies type of SWAP computation as PERCENTAGE (1, annual, in percent) POINTS = 2; // Specifies type of SWAP computation as POINTS (2) } // Enum for specifying access right for a trader enum ProtoOAAccessRights { FULL_ACCESS = 0; // Enable all trading. CLOSE_ONLY = 1; // Only closing trading request are enabled. NO_TRADING = 2; // View only access. NO_LOGIN = 3; // No access. } // Enum for specifying margin calculation type for an account enum ProtoOATotalMarginCalculationType { MAX = 0; SUM = 1; NET = 2; } // Enum for specifying type of an account enum ProtoOAAccountType { HEDGED = 0; // Allows multiple positions on a trading account for a symbol. NETTED = 1; // Only one position per symbol is allowed on a trading account. SPREAD_BETTING = 2; // Spread betting type account. } // Error code ENUM enum ProtoOAErrorCode { OA_AUTH_TOKEN_EXPIRED = 1; // When token used for account authorization is expired. ACCOUNT_NOT_AUTHORIZED = 2; // When account is not authorized. RET_NO_SUCH_LOGIN = 12; // When such account no longer exists. ALREADY_LOGGED_IN = 14; // When client tries to authorize after it was already authorized. INCORRECT_BOUNDARIES = 35; // When requested period (from,to) is too large or invalid values are set to from/to. RET_ACCOUNT_DISABLED = 64; // When account is disabled. CONNECTIONS_LIMIT_EXCEEDED = 67; // Limit of connections is reached for this Open API client. WORSE_GSL_NOT_ALLOWED = 68; // Not allowed to increase risk for Positions with Guaranteed Stop Loss. SYMBOL_HAS_HOLIDAY = 69; // Trading disabled because symbol has holiday. CH_CLIENT_AUTH_FAILURE = 101; // Open API client is not activated or wrong client credentials. CH_CLIENT_NOT_AUTHENTICATED = 102; // When a command is sent for not authorized Open API client. CH_CLIENT_ALREADY_AUTHENTICATED = 103; // Client is trying to authenticate twice. CH_ACCESS_TOKEN_INVALID = 104; // Access token is invalid. CH_SERVER_NOT_REACHABLE = 105; // Trading service is not available. CH_CTID_TRADER_ACCOUNT_NOT_FOUND = 106; // Trading account is not found. CH_OA_CLIENT_NOT_FOUND = 107; // Could not find this client id. REQUEST_FREQUENCY_EXCEEDED = 108; // Request frequency is reached. SERVER_IS_UNDER_MAINTENANCE = 109; // Server is under maintenance. CHANNEL_IS_BLOCKED = 110; // Operations are not allowed for this account. NOT_SUBSCRIBED_TO_SPOTS = 112; // When trying to subscribe to depth, trendbars, etc. without spot subscription. ALREADY_SUBSCRIBED = 113; // When subscription is requested for an active. SYMBOL_NOT_FOUND = 114; // Symbol not found. UNKNOWN_SYMBOL = 115; // Note: to be merged with SYMBOL_NOT_FOUND. NO_QUOTES = 117; // Trading cannot be done as not quotes are available. Applicable for Book B. NOT_ENOUGH_MONEY = 118; // Not enough funds to allocate margin. MAX_EXPOSURE_REACHED = 119; // Max exposure limit is reached for a {trader, symbol, side}. POSITION_NOT_FOUND = 120; // Position not found. ORDER_NOT_FOUND = 121; // Order not found. POSITION_NOT_OPEN = 122; // When trying to close a position that is not open. POSITION_LOCKED = 123; // Position in the state that does not allow to perform an operation. TOO_MANY_POSITIONS = 124; // Trading account reached its limit for max number of open positions and orders. TRADING_BAD_VOLUME = 125; // Invalid volume. TRADING_BAD_STOPS = 126; // Invalid stop price. TRADING_BAD_PRICES = 127; // Invalid price (e.g. negative). TRADING_BAD_STAKE = 128; // Invalid stake volume (e.g. negative). PROTECTION_IS_TOO_CLOSE_TO_MARKET = 129; // Invalid protection prices. TRADING_BAD_EXPIRATION_DATE = 130; // Invalid expiration. PENDING_EXECUTION = 131; // Unable to apply changes as position has an order under execution. TRADING_DISABLED = 132; // Trading is blocked for the symbol. TRADING_NOT_ALLOWED = 133; // Trading account is in read only mode. UNABLE_TO_CANCEL_ORDER = 134; // Unable to cancel order. UNABLE_TO_AMEND_ORDER = 135; // Unable to amend order. SHORT_SELLING_NOT_ALLOWED = 136; // Short selling is not allowed. NOT_SUBSCRIBED_TO_PNL = 137; // This session is not subscribed via ProtoOAv1PnLChangeSubscribeReq } enum ProtoOALimitedRiskMarginCalculationStrategy { ACCORDING_TO_LEVERAGE = 0; ACCORDING_TO_GSL = 1; ACCORDING_TO_GSL_AND_LEVERAGE = 2; } // Price quote type enum ProtoOAQuoteType { BID = 1; ASK = 2; } // Open API application permission in regards to token ENUM enum ProtoOAClientPermissionScope { SCOPE_VIEW = 0; // Allows to use only view commands. Trade is prohibited. SCOPE_TRADE = 1; // Allows to use all commands. } // Trendbar period ENUM enum ProtoOATrendbarPeriod { M1 = 1; M2 = 2; M3 = 3; M4 = 4; M5 = 5; M10 = 6; M15 = 7; M30 = 8; H1 = 9; H4 = 10; H12 = 11; D1 = 12; W1 = 13; MN1 = 14; } // Position status ENUM enum ProtoOAPositionStatus { POSITION_STATUS_OPEN = 1; POSITION_STATUS_CLOSED = 2; POSITION_STATUS_CREATED = 3; // Empty position is created for pending order. POSITION_STATUS_ERROR = 4; } // Trade side ENUM. Used for order, position, deal enum ProtoOATradeSide { BUY = 1; SELL = 2; } // Order type ENUM enum ProtoOAOrderType { MARKET = 1; LIMIT = 2; STOP = 3; STOP_LOSS_TAKE_PROFIT = 4; MARKET_RANGE = 5; STOP_LIMIT = 6; } // Order time in force ENUM enum ProtoOATimeInForce { GOOD_TILL_DATE = 1; GOOD_TILL_CANCEL = 2; IMMEDIATE_OR_CANCEL = 3; FILL_OR_KILL = 4; MARKET_ON_OPEN = 5; } // Order status ENUM enum ProtoOAOrderStatus { ORDER_STATUS_ACCEPTED = 1; // Order request validated and accepted for execution. ORDER_STATUS_FILLED = 2; // Order is fully filled. ORDER_STATUS_REJECTED = 3; // Order is rejected due to validation. ORDER_STATUS_EXPIRED = 4; // Order expired. Might be valid for orders with partially filled volume that were expired on LP. ORDER_STATUS_CANCELLED = 5; // Order is cancelled. Might be valid for orders with partially filled volume that were cancelled by LP. } // Stop Order and Stop Lost triggering method ENUM enum ProtoOAOrderTriggerMethod { TRADE = 1; // Stop Order: buy is triggered by ask, sell by bid; Stop Loss Order: for buy position is triggered by bid and for sell position by ask. OPPOSITE = 2; // Stop Order: buy is triggered by bid, sell by ask; Stop Loss Order: for buy position is triggered by ask and for sell position by bid. DOUBLE_TRADE = 3; // The same as TRADE, but trigger is checked after the second consecutive tick. DOUBLE_OPPOSITE = 4; // The same as OPPOSITE, but trigger is checked after the second consecutive tick. } // Execution event type ENUM enum ProtoOAExecutionType { ORDER_ACCEPTED = 2; // Order passed validation. ORDER_FILLED = 3; // Order filled. ORDER_REPLACED = 4; // Pending order is changed with a new one. ORDER_CANCELLED = 5; // Order cancelled. ORDER_EXPIRED = 6; // Order with GTD time in force is expired. ORDER_REJECTED = 7; // Order is rejected due to validations. ORDER_CANCEL_REJECTED = 8; // Cancel order request is rejected. SWAP = 9; // Type related to SWAP execution events. DEPOSIT_WITHDRAW = 10; // Type related to event of deposit or withdrawal cash flow operation. ORDER_PARTIAL_FILL = 11; // Order is partially filled. BONUS_DEPOSIT_WITHDRAW = 12; // Type related to event of bonus deposit or bonus withdrawal. } // Balance operation entity. Covers all cash movement operations related to account, trading, IB operations, mirroring, etc. enum ProtoOAChangeBalanceType { BALANCE_DEPOSIT = 0; // Cash deposit. BALANCE_WITHDRAW = 1; // Cash withdrawal. BALANCE_DEPOSIT_STRATEGY_COMMISSION_INNER = 3; // Received mirroring commission. BALANCE_WITHDRAW_STRATEGY_COMMISSION_INNER = 4; // Paid mirroring commission. BALANCE_DEPOSIT_IB_COMMISSIONS = 5; // For IB account. Commissions paid by trader. BALANCE_WITHDRAW_IB_SHARED_PERCENTAGE = 6; // For IB account. Withdrawal of commissions shared with broker. BALANCE_DEPOSIT_IB_SHARED_PERCENTAGE_FROM_SUB_IB = 7; // For IB account. Commissions paid by sub-ibs. BALANCE_DEPOSIT_IB_SHARED_PERCENTAGE_FROM_BROKER = 8; // For IB account. Commissions paid by broker. BALANCE_DEPOSIT_REBATE = 9; // Deposit rebate for trading volume for period. BALANCE_WITHDRAW_REBATE = 10; // Withdrawal of rebate. BALANCE_DEPOSIT_STRATEGY_COMMISSION_OUTER = 11; // Mirroring commission. BALANCE_WITHDRAW_STRATEGY_COMMISSION_OUTER = 12; // Mirroring commission. BALANCE_WITHDRAW_BONUS_COMPENSATION = 13; // For IB account. Share commission with the Broker. BALANCE_WITHDRAW_IB_SHARED_PERCENTAGE_TO_BROKER = 14; // IB commissions. BALANCE_DEPOSIT_DIVIDENDS = 15; // Deposit dividends payments. BALANCE_WITHDRAW_DIVIDENDS = 16; // Negative dividend charge for short position. BALANCE_WITHDRAW_GSL_CHARGE = 17; // Charge for guaranteedStopLoss. BALANCE_WITHDRAW_ROLLOVER = 18; // Charge of rollover fee for Shariah compliant accounts. BALANCE_DEPOSIT_NONWITHDRAWABLE_BONUS = 19; // Broker operation to deposit bonus. BALANCE_WITHDRAW_NONWITHDRAWABLE_BONUS = 20; // Broker operation to withdrawal bonus. BALANCE_DEPOSIT_SWAP = 21; // Deposits of negative SWAP. BALANCE_WITHDRAW_SWAP = 22; // SWAP charges. BALANCE_DEPOSIT_MANAGEMENT_FEE = 27; // Mirroring commission. BALANCE_DEPOSIT_PERFORMANCE_FEE = 29; // Mirroring commission. BALANCE_WITHDRAW_FOR_SUBACCOUNT = 30; // Withdraw for subaccount creation (cTrader Copy). BALANCE_DEPOSIT_TO_SUBACCOUNT = 31; // Deposit to subaccount on creation (cTrader Copy). BALANCE_WITHDRAW_FROM_SUBACCOUNT = 32; // Manual user's withdraw from subaccount (cTrader Copy), to parent account. BALANCE_DEPOSIT_FROM_SUBACCOUNT = 33; // Manual user's deposit to subaccount (cTrader Copy), from parent account. BALANCE_WITHDRAW_COPY_FEE = 34; // Withdrawal fees to Strategy Provider. BALANCE_WITHDRAW_INACTIVITY_FEE = 35; // Withdraw of inactivity fee from the balance. BALANCE_DEPOSIT_TRANSFER = 36; // Deposit within the same server (from another account). BALANCE_WITHDRAW_TRANSFER = 37; // Withdraw within the same server (to another account). BALANCE_DEPOSIT_CONVERTED_BONUS = 38; // Bonus being converted from virtual bonus to real deposit. BALANCE_DEPOSIT_NEGATIVE_BALANCE_PROTECTION = 39; // Applies if negative balance protection is configured by broker, should make balance = 0. } // Deal status ENUM enum ProtoOADealStatus { FILLED = 2; // Deal filled. PARTIALLY_FILLED = 3; // Deal is partially filled. REJECTED = 4; // Deal is correct but was rejected by liquidity provider (e.g. no liquidity). INTERNALLY_REJECTED = 5; // Deal rejected by server (e.g. no price quotes). ERROR = 6; // Deal is rejected by LP due to error (e.g. symbol is unknown). MISSED = 7; // Liquidity provider did not sent response on the deal during specified execution time period. } // Bonus operation type ENUM enum ProtoOAChangeBonusType { BONUS_DEPOSIT = 0; BONUS_WITHDRAW = 1; } // The strategy for choosing which Position to close during a Stop Out enum ProtoOAStopOutStrategy { MOST_MARGIN_USED_FIRST = 0; // A Stop Out strategy that closes a Position with the largest Used Margin MOST_LOSING_FIRST = 1; // A Stop Out strategy that closes a Position with the least PnL } ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// /// MESSAGES ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Base message that is used for all messages that are sent to/from Open API proxy of cTrader platform. message ProtoMessage { required uint32 payloadType = 1; // Contains id of ProtoPayloadType or other custom PayloadTypes (e.g. ProtoOAPayloadType). optional bytes payload = 2; // Serialized protobuf message that corresponds to payloadType. optional string clientMsgId = 3; // Request message id, assigned by the client that will be returned in the response. } message ProtoErrorRes { optional ProtoPayloadType payloadType = 1 [default = ERROR_RES]; required string errorCode = 2; // Contains name of ProtoErrorCode or other custom ErrorCodes (e.g. ProtoCHErrorCode). optional string description = 3; // Error description. optional uint64 maintenanceEndTimestamp = 4; // The Unix time in milliseconds of the end of the maintenance. } // Event that is sent from Open API proxy and can be used as criteria that connection is healthy when no other messages are sent by cTrader platform // Open API client can send this message when it needs to keep the connection open for a period longer than 30 seconds without other messages. message ProtoHeartbeatEvent { optional ProtoPayloadType payloadType = 1 [default = HEARTBEAT_EVENT]; } // Trading account entity message ProtoOATrader { required int64 ctidTraderAccountId = 1; // The unique Trader's Account ID used to match the responses to the Trader's Account. required int64 balance = 2; // Current account balance in cents (e.g. If USD 100.00 then value = 10000). optional int64 balanceVersion = 3; // Balance version used to identify the final balance. Increments each time when the trading account balance is changed. optional int64 managerBonus = 4; // Amount of broker bonus allocated to the account in cents. optional int64 ibBonus = 5; // Amount of introducing broker bonus allocated to the account in cents. optional int64 nonWithdrawableBonus = 6; // Broker bonus that cannot be withdrew from the account as cash. optional ProtoOAAccessRights accessRights = 7 [default = FULL_ACCESS]; // Access rights that an owner has to the account in cTrader platform. See ProtoOAAccessRights for details. required int64 depositAssetId = 8; // Deposit currency of the account. optional bool swapFree = 9; // If TRUE then account is Shariah compliant. optional uint32 leverageInCents = 10; // Account leverage (e.g. If leverage = 1:50 then value = 5000). optional ProtoOATotalMarginCalculationType totalMarginCalculationType = 11; // Margin computation type for the account (MAX, SUM, NET). optional uint32 maxLeverage = 12; // Maximum allowed leverage for the account. Used as validation when a Trader can change leverage value. optional int64 traderLogin = 14; // ID of the account that is unique per server (Broker). optional ProtoOAAccountType accountType = 15 [default = HEDGED]; // Account type: HEDGED, NETTED, etc. optional string brokerName = 16; // Some whitelabel assigned to trader by broker at the moment of account creation. optional int64 registrationTimestamp = 17; // The Unix timestamp in milliseconds of the account registration. Should be used as minimal date in historical data requests. optional bool isLimitedRisk = 18; // If TRUE then account is compliant to use specific margin calculation strategy. Such accounts are require to have guaranteed stop loss on all positions. optional ProtoOALimitedRiskMarginCalculationStrategy limitedRiskMarginCalculationStrategy = 19 [default = ACCORDING_TO_LEVERAGE]; // Special strategy used in margin calculations for this account (if account isLimitedRisk). optional uint32 moneyDigits = 20; // Specifies the exponent of the monetary values. E.g. moneyDigits = 8 must be interpret as business value multiplied by 10^8, then real balance would be 10053099944 / 10^8 = 100.53099944. Affects balance, managerBonus, ibBonus, nonWithdrawableBonus. optional bool fairStopOut = 21; // If TRUE - Position is fully closed on Stop Out, if FALSE - smart (partial closing) Stop Out is applied, if unspecified - Stop Out format is determined by Broker. optional ProtoOAStopOutStrategy stopOutStrategy = 22 [default = MOST_MARGIN_USED_FIRST]; //The Stop Out strategy that is used for this Trader. The Trader can change the value in the cTrader UI if this option is not disabled by the Broker } // Position/order trading details entity message ProtoOATradeData { required int64 symbolId = 1; // The unique identifier of the symbol in specific server environment within cTrader platform. Different brokers might have different IDs. required int64 volume = 2; // Volume in cents (e.g. 1000 in protocol means 10.00 units). required ProtoOATradeSide tradeSide = 3; // Buy, Sell. optional int64 openTimestamp = 4; // The Unix time in milliseconds when position was opened or order was created. optional string label = 5; // Text label specified during order request. optional bool guaranteedStopLoss = 6; // If TRUE then position/order stop loss is guaranteedStopLoss. optional string comment = 7; // User-specified comment. optional string measurementUnits = 8; // Specifies the units in which the Symbol is denominated. optional uint64 closeTimestamp = 9; // The Unix time in milliseconds when a Position was closed } // Trade position entity message ProtoOAPosition { required int64 positionId = 1; // The unique ID of the position. Note: trader might have two positions with the same id if positions are taken from accounts from different brokers. required ProtoOATradeData tradeData = 2; // Position details. See ProtoOATradeData for details. required ProtoOAPositionStatus positionStatus = 3; // Current status of the position. required int64 swap = 4; // Total amount of charged swap on open position. optional double price = 5; // VWAP price of the position based on all executions (orders) linked to the position. optional double stopLoss = 6; // Current stop loss price. optional double takeProfit = 7; // Current take profit price. optional int64 utcLastUpdateTimestamp = 8; // The Unix time in milliseconds of the last change of the position, including amend SL/TP of the position, execution of related order, cancel or related order, etc. optional int64 commission = 9; // Current unrealized commission related to the position. optional double marginRate = 10; // Rate for used margin computation. Represented as Base/Deposit. optional int64 mirroringCommission = 11; // Amount of unrealized commission related to following of strategy provider. optional bool guaranteedStopLoss = 12; // If TRUE then position stop loss is guaranteedStopLoss. optional uint64 usedMargin = 13; // Amount of margin used for the position in deposit currency. optional ProtoOAOrderTriggerMethod stopLossTriggerMethod = 14 [default = TRADE]; // Stop trigger method for SL/TP of the position. optional uint32 moneyDigits = 15; // Specifies the exponent of the monetary values. E.g. moneyDigits = 8 must be interpret as business value multiplied by 10^8, then real balance would be 10053099944 / 10^8 = 100.53099944. Affects usedMargin. optional bool trailingStopLoss = 16; // If TRUE then the Trailing Stop Loss is applied. } // Trade order entity message ProtoOAOrder { required int64 orderId = 1; // The unique ID of the order. Note: trader might have two orders with the same id if orders are taken from accounts from different brokers. required ProtoOATradeData tradeData = 2; // Detailed trade data. required ProtoOAOrderType orderType = 3; // Order type. required ProtoOAOrderStatus orderStatus = 4; // Order status. optional int64 expirationTimestamp = 6; // The Unix time in milliseconds of expiration if the order has time in force GTD. optional double executionPrice = 7; // Price at which an order was executed. For order with FILLED status. optional int64 executedVolume = 8; // Part of the volume that was filled in cents (e.g. 1000 in protocol means 10.00 units). optional int64 utcLastUpdateTimestamp = 9; // The Unix time in milliseconds of the last update of the order. optional double baseSlippagePrice = 10; // Used for Market Range order with combination of slippageInPoints to specify price range were order can be executed. optional int64 slippageInPoints = 11; // Used for Market Range and STOP_LIMIT orders to to specify price range were order can be executed. optional bool closingOrder = 12; // If TRUE then the order is closing part of whole position. Must have specified positionId. optional double limitPrice = 13; // Valid only for LIMIT orders. optional double stopPrice = 14; // Valid only for STOP and STOP_LIMIT orders. optional double stopLoss = 15; // Absolute stopLoss price. optional double takeProfit = 16; // Absolute takeProfit price. optional string clientOrderId = 17; // Optional ClientOrderId. Max Length = 50 chars. optional ProtoOATimeInForce timeInForce = 18 [default = IMMEDIATE_OR_CANCEL]; // Order time in force. Depends on order type. optional int64 positionId = 19; // ID of the position linked to the order (e.g. closing order, order that increase volume of a specific position, etc.). optional int64 relativeStopLoss = 20; // Relative stopLoss that can be specified instead of absolute as one. Specified in 1/100_000 of unit of a price (e.g. 123000 in protocol means 1.23, 53423782 means 534.23782). For BUY stopLoss = entryPrice - relativeStopLoss, for SELL stopLoss = entryPrice + relativeStopLoss. optional int64 relativeTakeProfit = 21; // Relative takeProfit that can be specified instead of absolute one. Specified in 1/100_000 of unit of a price (e.g. 123000 in protocol means 1.23, 53423782 means 534.23782). For BUY takeProfit = entryPrice + relativeTakeProfit, for SELL takeProfit = entryPrice - relativeTakeProfit. optional bool isStopOut = 22; // If TRUE then order was stopped out from server side. optional bool trailingStopLoss = 23; // If TRUE then order is trailingStopLoss. Valid for STOP_LOSS_TAKE_PROFIT order. optional ProtoOAOrderTriggerMethod stopTriggerMethod = 24 [default = TRADE]; // Trigger method for the order. Valid only for STOP and STOP_LIMIT orders. } // Bonus deposit/withdrawal entity message ProtoOABonusDepositWithdraw { required ProtoOAChangeBonusType operationType = 1; // Type of the operation. Deposit/Withdrawal. required int64 bonusHistoryId = 2; // The unique ID of the bonus deposit/withdrawal operation. required int64 managerBonus = 3; // Total amount of broker bonus after the operation. required int64 managerDelta = 4; // Amount of bonus deposited/withdrew by manager. required int64 ibBonus = 5; // Total amount of introducing broker bonus after the operation. required int64 ibDelta = 6; // Amount of bonus deposited/withdrew by introducing broker. required int64 changeBonusTimestamp = 7; // The Unix time in milliseconds when the bonus operation was executed. optional string externalNote = 8; // Note added to operation. Visible to the trader. optional int64 introducingBrokerId = 9; // ID of introducing broker who deposited/withdrew bonus. optional uint32 moneyDigits = 10; // Specifies the exponent of the monetary values. E.g. moneyDigits = 8 must be interpret as business value multiplied by 10^8, then real balance would be 10053099944 / 10^8 = 100.53099944. Affects managerBonus, managerDelta, ibBonus, ibDelta. } // Account deposit/withdrawal operation entity message ProtoOADepositWithdraw { required ProtoOAChangeBalanceType operationType = 1; // Type of the operation. Deposit/Withdrawal. required int64 balanceHistoryId = 2; // The unique ID of the deposit/withdrawal operation. required int64 balance = 3; // Account balance after the operation was executed. required int64 delta = 4; // Amount of deposit/withdrawal operation. required int64 changeBalanceTimestamp = 5; // The Unix time in milliseconds when deposit/withdrawal operation was executed. optional string externalNote = 6; // Note added to operation. Visible to the trader. optional int64 balanceVersion = 7; // Balance version used to identify the final balance. Increments each time when the trading account balance is changed. optional int64 equity = 8; // Total account equity after balance operation was executed. optional uint32 moneyDigits = 9; // Specifies the exponent of the monetary values. E.g. moneyDigits = 8 must be interpret as business value multiplied by 10^8, then real balance would be 10053099944 / 10^8 = 100.53099944. Affects usedMargin. } // Execution entity message ProtoOADeal { required int64 dealId = 1; // The unique ID of the execution deal. required int64 orderId = 2; // Source order of the deal. required int64 positionId = 3; // Source position of the deal. required int64 volume = 4; // Volume sent for execution, in cents. required int64 filledVolume = 5; // Filled volume, in cents. required int64 symbolId = 6; // The unique identifier of the symbol in specific server environment within cTrader platform. Different servers have different IDs. required int64 createTimestamp = 7; // The Unix time in milliseconds when the deal was sent for execution. required int64 executionTimestamp = 8; // The Unix time in milliseconds when the deal was executed. optional int64 utcLastUpdateTimestamp = 9; // The Unix time in milliseconds when the deal was created, executed or rejected. optional double executionPrice = 10; // Execution price. required ProtoOATradeSide tradeSide = 11; // Buy/Sell. required ProtoOADealStatus dealStatus = 12; // Status of the deal. optional double marginRate = 13; // Rate for used margin computation. Represented as Base/Deposit. optional int64 commission = 14; // Amount of trading commission associated with the deal. optional double baseToUsdConversionRate = 15; // Base to USD conversion rate on the time of deal execution. optional ProtoOAClosePositionDetail closePositionDetail = 16; // Closing position detail. Valid only for closing deal. optional uint32 moneyDigits = 17; // Specifies the exponent of the monetary values. E.g. moneyDigits = 8 must be interpret as business value multiplied by 10^8, then real balance would be 10053099944 / 10^8 = 100.53099944. Affects managerBonus, managerDelta, ibBonus, ibDelta. } // Trading details for closing deal message ProtoOAClosePositionDetail { required double entryPrice = 1; // Position price at the moment of filling the closing order. required int64 grossProfit = 2; // Amount of realized gross profit after closing deal execution. required int64 swap = 3; // Amount of realized swap in cents related to closed volume. required int64 commission = 4; // Amount of realized commission in cents related to closed volume. required int64 balance = 5; // Account balance after closing deal execution. optional double quoteToDepositConversionRate = 6; // Quote/Deposit currency conversion rate on the time of closing deal execution. optional int64 closedVolume = 7; // Closed volume in cents. optional int64 balanceVersion = 8; // Balance version of the account related to closing deal operation. optional uint32 moneyDigits = 9; // Specifies the exponent of the monetary values. E.g. moneyDigits = 8 must be interpret as business value multiplied by 10^8, then real balance would be 10053099944 / 10^8 = 100.53099944. Affects grossProfit, swap, commission, balance, pnlConversionFee. optional int64 pnlConversionFee = 10; // Fee for conversion applied to the Deal in account's ccy when trader symbol's quote asset id <> ProtoOATrader.depositAssetId.} } // Historical Trendbar entity message ProtoOATrendbar { required int64 volume = 3; // Bar volume in cents. optional ProtoOATrendbarPeriod period = 4 [default = M1]; // Bar period. optional int64 low = 5; // Low price of the bar. optional uint64 deltaOpen = 6; // Delta between open and low price. open = low + deltaOpen. optional uint64 deltaClose = 7; // Delta between close and low price. close = low + deltaClose. optional uint64 deltaHigh = 8; // Delta between high and low price. high = low + deltaHigh. optional uint32 utcTimestampInMinutes = 9; // The Unix time in minutes of the bar, equal to the timestamp of the open tick. } // Trader account entity message ProtoOACtidTraderAccount { required int64 ctidTraderAccountId = 1; // Unique identifier of the trader's account. Used to match responses to trader's accounts.cTrader platform. Different brokers might have different ids optional bool isLive = 2; // If TRUE then the account is belong to Live environment and live host must be used to authorize it optional int64 traderLogin = 3; // TraderLogin for a specific account. Value is displayed on Client App UI optional int64 lastClosingDealTimestamp = 4; // The Unix time in milliseconds of the last ProtoOAClosePositionDetail happened to this account. optional int64 lastBalanceUpdateTimestamp = 5; // The Unix time in milliseconds of the last ProtoOADepositWithdraw happened to this account. optional string brokerTitleShort = 6; // The name of the broker to which the account belongs to. Shortened to be displayed in the UI. } // Request for authorizing an application to work with the cTrader platform Proxies. message ProtoOAApplicationAuthReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_APPLICATION_AUTH_REQ]; required string clientId = 2; //The unique Client ID provided during the registration. required string clientSecret = 3; //The unique Client Secret provided during the registration. } // Response to the ProtoOAApplicationAuthReq request. message ProtoOAApplicationAuthRes { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_APPLICATION_AUTH_RES]; } // Request for the authorizing of the trading account session. Requires established authorized connection with the client application using ProtoOAApplicationAuthReq. message ProtoOAAccountAuthReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_ACCOUNT_AUTH_REQ]; required int64 ctidTraderAccountId = 2; // The unique identifier of the trading account in cTrader platform. required string accessToken = 3; // The Access Token issued for providing access to the trading account. } // Response to the ProtoOAApplicationAuthRes request. message ProtoOAAccountAuthRes { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_ACCOUNT_AUTH_RES]; required int64 ctidTraderAccountId = 2; // The unique identifier of the trading account in cTrader platform. } // Generic response when an ERROR occurred. message ProtoOAErrorRes { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_ERROR_RES]; optional int64 ctidTraderAccountId = 2; // The unique identifier of the trading account in cTrader platform. required string errorCode = 3; // The name of the ProtoErrorCode or the other custom ErrorCodes (e.g. ProtoCHErrorCode). optional string description = 4; // The error description. optional int64 maintenanceEndTimestamp = 5; // The Unix time in seconds when the current maintenance session will be ended. optional uint64 retryAfter = 6; // When you hit rate limit with errorCode=BLOCKED_PAYLOAD_TYPE, this field will contain amount of seconds until related payload type will be unlocked. } // Event that is sent when the connection with the client application is cancelled by the server. // All the sessions for the trader accounts will be terminated. message ProtoOAClientDisconnectEvent { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_CLIENT_DISCONNECT_EVENT]; optional string reason = 2; // The disconnection reason explained. For example: The application access was blocked by cTrader Administrator. } // Event that is sent when a session to a specific trader account is terminated by the server but the existing connections with the other trader accounts are maintained. // Reasons to trigger: account was deleted, cTID was deleted, token was refreshed, token was revoked. message ProtoOAAccountsTokenInvalidatedEvent { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_ACCOUNTS_TOKEN_INVALIDATED_EVENT]; repeated int64 ctidTraderAccountIds = 2; // The unique identifier of the trading account in cTrader platform. optional string reason = 3; // The disconnection reason explained. For example: Access Token is expired or recalled. } // Request for getting the proxy version. Can be used to check the current version of the Open API scheme. message ProtoOAVersionReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_VERSION_REQ]; } // Response to the ProtoOAVersionReq request. message ProtoOAVersionRes { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_VERSION_RES]; required string version = 2; // The current version of the server application. } // Request for sending a new trading order. // Allowed only if the accessToken has the "trade" permissions for the trading account. message ProtoOANewOrderReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_NEW_ORDER_REQ]; required int64 ctidTraderAccountId = 2; // The unique identifier of the trading account in cTrader platform. required int64 symbolId = 3; // The unique identifier of a symbol in cTrader platform. required ProtoOAOrderType orderType = 4; // The type of an order - MARKET, LIMIT, STOP, MARKET_RANGE, STOP_LIMIT. required ProtoOATradeSide tradeSide = 5; // The trade direction - BUY or SELL. required int64 volume = 6; // The volume represented in 0.01 of a unit (e.g. 1000 in protocol means 10.00 units). optional double limitPrice = 7; // The limit price, can be specified for the LIMIT order only. optional double stopPrice = 8; // Stop Price, can be specified for the STOP and the STOP_LIMIT orders only. optional ProtoOATimeInForce timeInForce = 9 [default = GOOD_TILL_CANCEL]; // The specific order execution or expiration instruction - GOOD_TILL_DATE, GOOD_TILL_CANCEL, IMMEDIATE_OR_CANCEL, FILL_OR_KILL, MARKET_ON_OPEN. optional int64 expirationTimestamp = 10; // The Unix time in milliseconds of Order expiration time. Should be set for the Good Till Date orders. optional double stopLoss = 11; // The absolute Stop Loss price (1.23456 for example). Unsupported for MARKET orders; for these orders, please use relativeStopLoss. optional double takeProfit = 12; // The absolute Take Profit price (1.23456 for example). Unsupported for MARKET orders; for these orders, please use relativeTakeProfit. optional string comment = 13; // User-specified comment. MaxLength = 512. optional double baseSlippagePrice = 14; // Base price to calculate relative slippage price for MARKET_RANGE order. optional int32 slippageInPoints = 15; // Slippage distance for MARKET_RANGE and STOP_LIMIT order. optional string label = 16; // User-specified label. MaxLength = 100. optional int64 positionId = 17; // Reference to the existing position if the Order is intended to modify it. optional string clientOrderId = 18; // Optional user-specific clientOrderId (similar to FIX ClOrderID). MaxLength = 50. optional int64 relativeStopLoss = 19; // Relative Stop Loss that can be specified instead of the absolute as one. Specified in 1/100000 of unit of a price (e.g. 123000 in protocol means 1.23, 53423782 means 534.23782). For BUY stopLoss = entryPrice - relativeStopLoss, for SELL stopLoss = entryPrice + relativeStopLoss. optional int64 relativeTakeProfit = 20; // Relative Take Profit that can be specified instead of the absolute one. Specified in 1/100000 of unit of a price (e.g. 123000 in protocol means 1.23, 53423782 means 534.23782). For BUY takeProfit = entryPrice + relativeTakeProfit, for SELL takeProfit = entryPrice - relativeTakeProfit. optional bool guaranteedStopLoss = 21; // If TRUE then stopLoss is guaranteed. Required to be set to TRUE for the Limited Risk accounts (ProtoOATrader.isLimitedRisk=true). optional bool trailingStopLoss = 22; // If TRUE then the Stop Loss is Trailing. optional ProtoOAOrderTriggerMethod stopTriggerMethod = 23 [default = TRADE]; // Trigger method for the STOP or the STOP_LIMIT pending order. } // Event that is sent following the successful order acceptance or execution by the server. // Acts as response to the ProtoOANewOrderReq, ProtoOACancelOrderReq, ProtoOAAmendOrderReq, ProtoOAAmendPositionSLTPReq, ProtoOAClosePositionReq requests. // Also, the event is sent when a Deposit/Withdrawal took place. message ProtoOAExecutionEvent { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_EXECUTION_EVENT]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. required ProtoOAExecutionType executionType = 3; // Type of the order operation. For example: ACCEPTED, FILLED, etc. optional ProtoOAPosition position = 4; // Reference to the position linked with the execution optional ProtoOAOrder order = 5; // Reference to the initial order. optional ProtoOADeal deal = 6; // Reference to the deal (execution). optional ProtoOABonusDepositWithdraw bonusDepositWithdraw = 7; // Reference to the Bonus Deposit or Withdrawal operation. optional ProtoOADepositWithdraw depositWithdraw = 8; // Reference to the Deposit or Withdrawal operation. optional string errorCode = 9; // The name of the ProtoErrorCode or the other custom ErrorCodes (e.g. ProtoCHErrorCode). optional bool isServerEvent = 10; // If TRUE then the event is generated by the server logic instead of the trader request. (e.g. stop-out). } // Request for cancelling existing pending order. // Allowed only if the accessToken has "trade" permissions for the trading account. message ProtoOACancelOrderReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_CANCEL_ORDER_REQ]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. required int64 orderId = 3; // The unique ID of the order. } // Request for amending the existing pending order. // Allowed only if the Access Token has "trade" permissions for the trading account. message ProtoOAAmendOrderReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_AMEND_ORDER_REQ]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. required int64 orderId = 3; // The unique ID of the order. optional int64 volume = 4; // Volume, represented in 0.01 of a unit (e.g. 1000 in protocol means 10.00 units). optional double limitPrice = 5; // The Limit Price, can be specified for the LIMIT order only. optional double stopPrice = 6; // The Stop Price, can be specified for the STOP and the STOP_LIMIT orders. optional int64 expirationTimestamp = 7; // The Unix timestamp in milliseconds of Order expiration time. Should be set for the Good Till Date orders. optional double stopLoss = 8; // The absolute Stop Loss price (e.g. 1.23456). Not supported for the MARKET orders. optional double takeProfit = 9; // The absolute Take Profit price (e.g. 1.23456). Not supported for the MARKET orders. optional int32 slippageInPoints = 10; // Slippage distance for the MARKET_RANGE and the STOP_LIMIT orders. optional int64 relativeStopLoss = 11; // The relative Stop Loss can be specified instead of the absolute one. Specified in 1/100000 of a unit of price (e.g. 123000 in protocol means 1.23, 53423782 means 534.23782). For BUY stopLoss = entryPrice - relativeStopLoss, for SELL stopLoss = entryPrice + relativeStopLoss. optional int64 relativeTakeProfit = 12; // The relative Take Profit can be specified instead of the absolute one. Specified in 1/100000 of a unit of price (e.g. 123000 in protocol means 1.23, 53423782 means 534.23782). For BUY takeProfit = entryPrice + relativeTakeProfit, for SELL takeProfit = entryPrice - relativeTakeProfit. optional bool guaranteedStopLoss = 13; // If TRUE then the Stop Loss is guaranteed. Available for the French Risk or the Guaranteed Stop Loss Accounts. optional bool trailingStopLoss = 14; // If TRUE then the Trailing Stop Loss is applied. optional ProtoOAOrderTriggerMethod stopTriggerMethod = 15 [default = TRADE]; // Trigger method for the STOP or the STOP_LIMIT pending order. } // Request for amending StopLoss and TakeProfit of existing position. // Allowed only if the accessToken has "trade" permissions for the trading account. message ProtoOAAmendPositionSLTPReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_AMEND_POSITION_SLTP_REQ]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. required int64 positionId = 3; // The unique ID of the position to amend. optional double stopLoss = 4; // Absolute Stop Loss price (1.23456 for example). optional double takeProfit = 5; // Absolute Take Profit price (1.26543 for example). optional bool guaranteedStopLoss = 7; // If TRUE then the Stop Loss is guaranteed. Available for the French Risk or the Guaranteed Stop Loss Accounts. optional bool trailingStopLoss = 8; // If TRUE then the Trailing Stop Loss is applied. optional ProtoOAOrderTriggerMethod stopLossTriggerMethod = 9 [default = TRADE]; // The Stop trigger method for the Stop Loss/Take Profit order. } // Request for closing or partially closing of an existing position. // Allowed only if the accessToken has "trade" permissions for the trading account. message ProtoOAClosePositionReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_CLOSE_POSITION_REQ]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. required int64 positionId = 3; // The unique ID of the position to close. required int64 volume = 4; // Volume to close, represented in 0.01 of a unit (1000 in protocol means 10.00 units). } // Request for getting data of Trader Account. message ProtoOATraderReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_TRADER_REQ]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. } // Response to the ProtoOATraderReq request. message ProtoOATraderRes { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_TRADER_RES]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. required ProtoOATrader trader = 3; // The Trader account information. } // Request for getting Trader current open positions and pending orders data. message ProtoOAReconcileReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_RECONCILE_REQ]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. optional bool returnProtectionOrders = 3; // If TRUE, then current protection orders are returned separately, otherwise you can use position.stopLoss and position.takeProfit fields. } // The response to the ProtoOAReconcileReq request. message ProtoOAReconcileRes { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_RECONCILE_RES]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. repeated ProtoOAPosition position = 3; // The list of trading account open positions. repeated ProtoOAOrder order = 4; // The list of trading account pending orders. } // Event that is sent when errors occur during the order requests. message ProtoOAOrderErrorEvent { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_ORDER_ERROR_EVENT]; required int64 ctidTraderAccountId = 5; // Unique identifier of the trading account. Used to match responses to trading accounts. required string errorCode = 2; // The name of the ProtoErrorCode or the other custom ErrorCodes (e.g. ProtoCHErrorCode). optional int64 orderId = 3; // The unique ID of the order. optional int64 positionId = 6; // The unique ID of the position. optional string description = 7; // The error description. } // Request for getting the list of granted trading account for the access token. message ProtoOAGetAccountListByAccessTokenReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_GET_ACCOUNTS_BY_ACCESS_TOKEN_REQ]; required string accessToken = 2; // The Access Token issued for providing access to the trading account. } // Response to the ProtoOAGetAccountListByAccessTokenReq request. message ProtoOAGetAccountListByAccessTokenRes { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_GET_ACCOUNTS_BY_ACCESS_TOKEN_RES]; required string accessToken = 2; // The Access Token issued for providing access to the trading account. optional ProtoOAClientPermissionScope permissionScope = 3; // SCOPE_VIEW, SCOPE_TRADE. repeated ProtoOACtidTraderAccount ctidTraderAccount = 4; // The list of the accounts. } // Request for subscribing on spot events of the specified symbol. message ProtoOASubscribeSpotsReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_SUBSCRIBE_SPOTS_REQ]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. repeated int64 symbolId = 3; // Unique identifier of the Symbol in cTrader platform. optional bool subscribeToSpotTimestamp = 4; // If TRUE you will also receive the timestamp in ProtoOASpotEvent. } // Response to the ProtoOASubscribeSpotsReq request. Reflects that your request to subscribe for symbol has been added to queue. You'll receive technical ProtoOASpotEvent with current price shortly after this response. message ProtoOASubscribeSpotsRes { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_SUBSCRIBE_SPOTS_RES]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. } // Request for unsubscribing from the spot events of the specified symbol. Request to stop receiving ProtoOASpotEvents related to particular symbols. Unsubscription is useful to minimize traffic, especially during high volatility events. message ProtoOAUnsubscribeSpotsReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_UNSUBSCRIBE_SPOTS_REQ]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. repeated int64 symbolId = 3; // Unique identifier of the Symbol in cTrader platform. } // Response to the ProtoOASubscribeSpotsRes request. Reflects that your request to unsubscribe has been added to queue and will be completed shortly. You may still occasionally receive ProtoOASpotEvents until request processing is complete. message ProtoOAUnsubscribeSpotsRes { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_UNSUBSCRIBE_SPOTS_RES]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. } // Event that is sent when a new spot event is generated on the server side. // Requires subscription on the spot events, see ProtoOASubscribeSpotsReq. // First event, received after subscription will contain latest spot prices even if market is closed. message ProtoOASpotEvent { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_SPOT_EVENT]; required int64 ctidTraderAccountId = 2; // Unique identifier of the trading account. Used to match responses to trading accounts. required int64 symbolId = 3; // Unique identifier of the Symbol in cTrader platform. optional uint64 bid = 4; // Bid price. Specified in 1/100000 of unit of a price. (e.g. 123000 in protocol means 1.23, 53423782 means 534.23782) optional uint64 ask = 5; // Ask price. Specified in 1/100000 of unit of a price. (e.g. 123000 in protocol means 1.23, 53423782 means 534.23782 repeated ProtoOATrendbar trendbar = 6; // Returns live trend bar. Requires subscription on the trend bars. optional uint64 sessionClose = 7; // Last session close. Specified in 1/100000 of unit of a price. (e.g. 123000 in protocol means 1.23, 53423782 means 534.23782 optional int64 timestamp = 8; // The Unix timestamp for spot. } // Event that is sent when the established session for an account is dropped on the server side. A new session must be authorized for the account. message ProtoOAAccountDisconnectEvent { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_ACCOUNT_DISCONNECT_EVENT]; required int64 ctidTraderAccountId = 2; // The unique identifier of the trading account in cTrader platform. } message ProtoOAHoliday { required int64 holidayId = 1; // Unique ID of holiday. required string name = 2; // Name of holiday. optional string description = 3; // Description of holiday. required string scheduleTimeZone = 4; // Timezone used for holiday. required int64 holidayDate = 5; // Amount of days from 1st Jan 1970, multiply it by 86400000 to get Unix time in milliseconds. required bool isRecurring = 6; // If TRUE, then the holiday happens each year. optional int32 startSecond = 7; // Amount of seconds from 00:00:00 of the holiday day when holiday actually starts. optional int32 endSecond = 8; // Amount of seconds from 00:00:00 of the holiday day when holiday actually finishes. } // Request to refresh the access token using refresh token of granted trader account. message ProtoOARefreshTokenReq { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_REFRESH_TOKEN_REQ]; required string refreshToken = 2; // The Refresh Token issued for updating Access Token. } // Response to the ProtoOARefreshTokenReq request. message ProtoOARefreshTokenRes { optional ProtoOAPayloadType payloadType = 1 [default = PROTO_OA_REFRESH_TOKEN_RES]; required string accessToken = 2; // The Access Token issued for providing access to the Trader's Account. required string tokenType = 3; // bearer required int64 expiresIn = 4; // Access Token expiration in seconds. required string refreshToken = 5; // Your new Refresh Token. }